X-Git-Url: https://git.delphigl.com/?p=glBitmap.git;a=blobdiff_plain;f=glBitmap.pas;h=4ee797b9448ac38bcb674f7cbedbbe61a6c62573;hp=72c81e0ad82d039c745e4450039169b3c83bcabd;hb=6c6cf89280ab9c80fc6856c612aaabf137d69d04;hpb=ff9fe5a4282af64bf3d6fad22ce914c3124e49fa diff --git a/glBitmap.pas b/glBitmap.pas index 72c81e0..4ee797b 100644 --- a/glBitmap.pas +++ b/glBitmap.pas @@ -1,6 +1,9 @@ {*********************************************************** 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/) (2013) + ------------------------------------------------------------ The contents of this file are used with permission, subject to the Mozilla Public License Version 1.1 (the "License"); you may @@ -8,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 @@ -19,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 @@ -48,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 @@ -214,62 +219,69 @@ History ***********************************************************} unit glBitmap; -{.$MESSAGE warn 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} // 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 error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} -// ###### Start of preferences ################################################ +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// activate to enable build-in OpenGL support with statically linked methods +// use dglOpenGL.pas if not enabled +{.$DEFINE GLB_NATIVE_OGL_STATIC} -{$DEFINE GLB_NO_NATIVE_GL} -// To enable the dglOpenGL.pas Header -// With native GL then bindings are staticlly declared to support other headers -// or use the glBitmap inside of DLLs (minimize codesize). +// activate to enable build-in OpenGL support with dynamically linked methods +// use dglOpenGL.pas if not enabled +{.$DEFINE GLB_NATIVE_OGL_DYNAMIC} +// activate to enable the support for SDL_surfaces {.$DEFINE GLB_SDL} -// To enable the support for SDL_surfaces +// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap) {.$DEFINE GLB_DELPHI} -// To enable the support for TBitmap from Delphi (not lazarus) +// activate to enable the support for TLazIntfImage from Lazarus +{.$DEFINE GLB_LAZARUS} -// *** image libs *** -{.$DEFINE GLB_SDL_IMAGE} -// To enable the support of SDL_image to load files. (READ ONLY) + +// activate to enable the support of SDL_image to load files. (READ ONLY) // If you enable SDL_image all other libraries will be ignored! +{.$DEFINE GLB_SDL_IMAGE} -{.$DEFINE GLB_PNGIMAGE} -// to enable png support with the unit pngimage. You can download it from http://pngdelphi.sourceforge.net/ + +// 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} +// activate to use the libPNG -> http://www.libpng.org/ +// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng {.$DEFINE GLB_LIB_PNG} -// to use the libPNG http://www.libpng.org/ -// You will need an aditional header. -// http://www.opengl24.de/index.php?cat=header&file=libpng -{.$DEFINE GLB_DELPHI_JPEG} -// if you enable delphi jpegs the libJPEG will be ignored -{.$DEFINE GLB_LIB_JPEG} -// to use the libJPEG http://www.ijg.org/ -// You will need an aditional header. -// http://www.opengl24.de/index.php?cat=header&file=libjpeg -// ###### End of preferences ################################################## +// 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} +// activate to use the libJPEG -> http://www.ijg.org/ +// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg +{.$DEFINE GLB_LIB_JPEG} -// ###### PRIVATE. Do not change anything. #################################### -// *** old defines for compatibility *** -{$IFDEF NO_NATIVE_GL} - {$DEFINE GLB_NO_NATIVE_GL} -{$ENDIF} -{$IFDEF pngimage} - {$definde GLB_PNGIMAGE} -{$ENDIF} -// *** Delphi Versions *** +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// PRIVATE: do not change anything! ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Delphi Versions {$IFDEF fpc} {$MODE Delphi} @@ -283,24 +295,51 @@ unit glBitmap; {$ENDIF} {$ENDIF} -// *** checking define combinations *** +// Operation System +{$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)} + {$DEFINE GLB_WIN} +{$ELSEIF DEFINED(LINUX)} + {$DEFINE GLB_LINUX} +{$IFEND} + +// native OpenGL Support +{$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)} + {$DEFINE GLB_NATIVE_OGL} +{$IFEND} + +// checking define combinations +//SDL Image {$IFDEF GLB_SDL_IMAGE} {$IFNDEF GLB_SDL} {$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} @@ -310,6 +349,28 @@ 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} {$MESSAGE warn 'The library libPNG will be ignored if you are using pngimage.'} @@ -320,11 +381,34 @@ unit glBitmap; {$DEFINE GLB_SUPPORT_PNG_WRITE} {$ENDIF} +// libPNG {$IFDEF GLB_LIB_PNG} {$DEFINE GLB_SUPPORT_PNG_READ} {$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} {$MESSAGE warn 'The library libJPEG will be ignored if you are using the unit JPEG.'} @@ -335,12 +419,18 @@ unit glBitmap; {$DEFINE GLB_SUPPORT_JPEG_WRITE} {$ENDIF} +// libJPEG {$IFDEF GLB_LIB_JPEG} {$DEFINE GLB_SUPPORT_JPEG_READ} {$DEFINE GLB_SUPPORT_JPEG_WRITE} {$ENDIF} -// *** general options *** +// native OpenGL +{$IF DEFINED(GLB_NATIVE_OGL_STATIC) AND DEFINED(GLB_NATIVE_OGL_DYNAMIC)} + {$MESSAGE warn 'GLB_NATIVE_OGL_STATIC will be ignored because you enabled GLB_NATIVE_OGL_DYNAMIC'} +{$IFEND} + +// general options {$EXTENDEDSYNTAX ON} {$LONGSTRINGS ON} {$ALIGN ON} @@ -351,296 +441,398 @@ unit glBitmap; interface uses - {$IFDEF GLB_NO_NATIVE_GL} dglOpenGL, {$ENDIF} + {$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF} + {$IF DEFINED(GLB_WIN) AND + (DEFINED(GLB_NATIVE_OGL) OR + DEFINED(GLB_DELPHI))} windows, {$IFEND} - {$IFDEF GLB_SDL} SDL, {$ENDIF} - {$IFDEF GLB_DELPHI} Dialogs, Windows, Graphics, {$ENDIF} + {$IFDEF GLB_SDL} SDL, {$ENDIF} + {$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, Graphics, {$ENDIF} + {$IFDEF GLB_DELPHI} Dialogs, Graphics, Types, {$ENDIF} - {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF} + {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF} + {$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF} + {$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF} + {$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF} + {$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF} - {$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF} - {$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF} - - {$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF} - {$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF} Classes, SysUtils; -{$IFNDEF GLB_DELPHI} -type - HGLRC = Cardinal; - DWORD = Cardinal; - PDWORD = ^DWORD; - - TRGBQuad = packed record - rgbBlue: Byte; - rgbGreen: Byte; - rgbRed: Byte; - rgbReserved: Byte; - end; -{$ENDIF} - -(* TODO dglOpenGL -{$IFNDEF GLB_NO_NATIVE_GL} -// Native OpenGL Implementation -type - PByteBool = ^ByteBool; +{$IFDEF GLB_NATIVE_OGL} +const + GL_TRUE = 1; + GL_FALSE = 0; -{$IFDEF GLB_DELPHI} -var - gLastContext: HGLRC; -{$ENDIF} + GL_ZERO = 0; + GL_ONE = 1; -const - // Generell - GL_VERSION = $1F02; + GL_VERSION = $1F02; GL_EXTENSIONS = $1F03; - GL_TRUE = 1; - GL_FALSE = 0; - - GL_TEXTURE_1D = $0DE0; - GL_TEXTURE_2D = $0DE1; - - GL_MAX_TEXTURE_SIZE = $0D33; - GL_PACK_ALIGNMENT = $0D05; - GL_UNPACK_ALIGNMENT = $0CF5; - - // Textureformats - GL_RGB = $1907; - GL_RGB4 = $804F; - GL_RGB8 = $8051; - GL_RGBA = $1908; - GL_RGBA4 = $8056; - GL_RGBA8 = $8058; - GL_BGR = $80E0; - GL_BGRA = $80E1; - GL_ALPHA4 = $803B; - GL_ALPHA8 = $803C; - GL_LUMINANCE4 = $803F; - GL_LUMINANCE8 = $8040; - GL_LUMINANCE4_ALPHA4 = $8043; - GL_LUMINANCE8_ALPHA8 = $8045; - GL_DEPTH_COMPONENT = $1902; - - GL_UNSIGNED_BYTE = $1401; - GL_ALPHA = $1906; - GL_LUMINANCE = $1909; - GL_LUMINANCE_ALPHA = $190A; - - GL_TEXTURE_WIDTH = $1000; - GL_TEXTURE_HEIGHT = $1001; - GL_TEXTURE_INTERNAL_FORMAT = $1003; - GL_TEXTURE_RED_SIZE = $805C; - GL_TEXTURE_GREEN_SIZE = $805D; - GL_TEXTURE_BLUE_SIZE = $805E; - GL_TEXTURE_ALPHA_SIZE = $805F; - GL_TEXTURE_LUMINANCE_SIZE = $8060; - - // Dataformats - GL_UNSIGNED_SHORT_5_6_5 = $8363; - GL_UNSIGNED_SHORT_5_6_5_REV = $8364; - GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365; - GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366; - GL_UNSIGNED_INT_2_10_10_10_REV = $8368; - - // Filter - GL_NEAREST = $2600; - GL_LINEAR = $2601; - GL_NEAREST_MIPMAP_NEAREST = $2700; - GL_LINEAR_MIPMAP_NEAREST = $2701; - GL_NEAREST_MIPMAP_LINEAR = $2702; - GL_LINEAR_MIPMAP_LINEAR = $2703; - GL_TEXTURE_MAG_FILTER = $2800; - GL_TEXTURE_MIN_FILTER = $2801; - - // Wrapmodes - GL_TEXTURE_WRAP_S = $2802; - GL_TEXTURE_WRAP_T = $2803; - GL_CLAMP = $2900; - GL_REPEAT = $2901; - GL_CLAMP_TO_EDGE = $812F; - GL_CLAMP_TO_BORDER = $812D; - GL_TEXTURE_WRAP_R = $8072; - - GL_MIRRORED_REPEAT = $8370; - - // Border Color - GL_TEXTURE_BORDER_COLOR = $1004; + GL_TEXTURE_1D = $0DE0; + 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; - // Texgen - GL_NORMAL_MAP = $8511; - GL_REFLECTION_MAP = $8512; GL_S = $2000; GL_T = $2001; GL_R = $2002; - GL_TEXTURE_GEN_MODE = $2500; + 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; + GL_ALPHA8 = $803C; + GL_ALPHA12 = $803D; + GL_ALPHA16 = $803E; + + GL_LUMINANCE = $1909; + GL_LUMINANCE4 = $803F; + GL_LUMINANCE8 = $8040; + GL_LUMINANCE12 = $8041; + GL_LUMINANCE16 = $8042; + + GL_LUMINANCE_ALPHA = $190A; + GL_LUMINANCE4_ALPHA4 = $8043; + GL_LUMINANCE6_ALPHA2 = $8044; + GL_LUMINANCE8_ALPHA8 = $8045; + GL_LUMINANCE12_ALPHA4 = $8046; + GL_LUMINANCE12_ALPHA12 = $8047; + GL_LUMINANCE16_ALPHA16 = $8048; + + GL_RGB = $1907; + GL_BGR = $80E0; + GL_R3_G3_B2 = $2A10; + GL_RGB4 = $804F; + GL_RGB5 = $8050; + GL_RGB565 = $8D62; + GL_RGB8 = $8051; + GL_RGB10 = $8052; + GL_RGB12 = $8053; + GL_RGB16 = $8054; + + GL_RGBA = $1908; + GL_BGRA = $80E1; + GL_RGBA2 = $8055; + GL_RGBA4 = $8056; + GL_RGB5_A1 = $8057; + GL_RGBA8 = $8058; + GL_RGB10_A2 = $8059; + GL_RGBA12 = $805A; + GL_RGBA16 = $805B; + + GL_DEPTH_COMPONENT = $1902; + GL_DEPTH_COMPONENT16 = $81A5; + GL_DEPTH_COMPONENT24 = $81A6; + GL_DEPTH_COMPONENT32 = $81A7; + + GL_COMPRESSED_RGB = $84ED; + GL_COMPRESSED_RGBA = $84EE; + GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0; + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1; + GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2; + GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3; + + GL_UNSIGNED_BYTE = $1401; + GL_UNSIGNED_BYTE_3_3_2 = $8032; + GL_UNSIGNED_BYTE_2_3_3_REV = $8362; + + GL_UNSIGNED_SHORT = $1403; + GL_UNSIGNED_SHORT_5_6_5 = $8363; + GL_UNSIGNED_SHORT_4_4_4_4 = $8033; + GL_UNSIGNED_SHORT_5_5_5_1 = $8034; + GL_UNSIGNED_SHORT_5_6_5_REV = $8364; + GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365; + GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366; + + GL_UNSIGNED_INT = $1405; + GL_UNSIGNED_INT_8_8_8_8 = $8035; + GL_UNSIGNED_INT_10_10_10_2 = $8036; + GL_UNSIGNED_INT_8_8_8_8_REV = $8367; + GL_UNSIGNED_INT_2_10_10_10_REV = $8368; + + { Texture Filter } + GL_TEXTURE_MAG_FILTER = $2800; + GL_TEXTURE_MIN_FILTER = $2801; + GL_NEAREST = $2600; + GL_NEAREST_MIPMAP_NEAREST = $2700; + GL_NEAREST_MIPMAP_LINEAR = $2702; + GL_LINEAR = $2601; + GL_LINEAR_MIPMAP_NEAREST = $2701; + GL_LINEAR_MIPMAP_LINEAR = $2703; + + { Texture Wrap } + GL_TEXTURE_WRAP_S = $2802; + GL_TEXTURE_WRAP_T = $2803; + GL_TEXTURE_WRAP_R = $8072; + GL_CLAMP = $2900; + GL_REPEAT = $2901; + GL_CLAMP_TO_EDGE = $812F; + GL_CLAMP_TO_BORDER = $812D; + GL_MIRRORED_REPEAT = $8370; + + { Other } + GL_GENERATE_MIPMAP = $8191; + GL_TEXTURE_BORDER_COLOR = $1004; + GL_MAX_TEXTURE_SIZE = $0D33; + GL_PACK_ALIGNMENT = $0D05; + GL_UNPACK_ALIGNMENT = $0CF5; - // Cubemaps - GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C; - GL_TEXTURE_CUBE_MAP = $8513; - GL_TEXTURE_BINDING_CUBE_MAP = $8514; - 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_RECTANGLE_ARB = $84F5; - - // GL_SGIS_generate_mipmap - GL_GENERATE_MIPMAP = $8191; - - // GL_EXT_texture_compression_s3tc - GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0; - GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1; - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2; - GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3; - - // GL_EXT_texture_filter_anisotropic - GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE; + 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'; + libopengl = 'opengl32.dll'; +{$ELSEIF DEFINED(GLB_LINUX)} + libglu = 'libGLU.so.1'; + libopengl = 'libGL.so.1'; +{$IFEND} - // GL_ARB_texture_compression - GL_COMPRESSED_RGB = $84ED; - GL_COMPRESSED_RGBA = $84EE; - GL_COMPRESSED_ALPHA = $84E9; - GL_COMPRESSED_LUMINANCE = $84EA; - GL_COMPRESSED_LUMINANCE_ALPHA = $84EB; +type + GLboolean = BYTEBOOL; + GLint = Integer; + GLsizei = Integer; + GLuint = Cardinal; + GLfloat = Single; + GLenum = Cardinal; + + PGLvoid = Pointer; + PGLboolean = ^GLboolean; + PGLint = ^GLint; + PGLuint = ^GLuint; + PGLfloat = ^GLfloat; + + TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglCompressedTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +{$IF DEFINED(GLB_WIN)} + TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall; +{$ELSEIF DEFINED(GLB_LINUX)} + TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl; + TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl; +{$IFEND} + +{$IF DEFINED(GLB_NATIVE_OGL_DYNAMIC)} + TglEnable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglDisable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TglGetString = function(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + 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} + + TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglReadPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglPixelStorei = procedure(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TglTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + + TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + +{$ELSEIF DEFINED(GLB_NATIVE_OGL_STATIC)} + procedure glEnable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glDisable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + function glGetString(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + 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; + + function glAreTexturesResident(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glReadPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glPixelStorei(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + procedure glTexImage1D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glTexImage2D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glGetTexImage(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + + function gluBuild1DMipmaps(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu; + function gluBuild2DMipmaps(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu; +{$IFEND} - // Extensions var GL_VERSION_1_2, GL_VERSION_1_3, GL_VERSION_1_4, GL_VERSION_2_0, + GL_VERSION_3_3, + + GL_SGIS_generate_mipmap, GL_ARB_texture_border_clamp, - GL_ARB_texture_cube_map, - GL_ARB_texture_compression, - GL_ARB_texture_non_power_of_two, - GL_ARB_texture_rectangle, GL_ARB_texture_mirrored_repeat, - GL_EXT_bgra, - GL_EXT_texture_edge_clamp, - GL_EXT_texture_cube_map, - GL_EXT_texture_compression_s3tc, - GL_EXT_texture_filter_anisotropic, - GL_EXT_texture_rectangle, - GL_NV_texture_rectangle, + 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, - GL_SGIS_generate_mipmap: Boolean; -const -{$IFDEF LINUX} - libglu = 'libGLU.so.1'; - libopengl = 'libGL.so.1'; -{$else} - libglu = 'glu32.dll'; - libopengl = 'opengl32.dll'; -{$ENDIF} + GL_NV_texture_rectangle, -{$IFDEF LINUX} - function glXGetProcAddress(ProcName: PAnsiChar): Pointer; cdecl; external libopengl; -{$else} - function wglGetProcAddress(ProcName: PAnsiChar): Pointer; stdcall; external libopengl; -{$ENDIF} + 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; + glCompressedTexImage2D: TglCompressedTexImage2D; + glGetCompressedTexImage: TglGetCompressedTexImage; - function glGetString(name: Cardinal): PAnsiChar; {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; +{$IF DEFINED(GLB_WIN)} + wglGetProcAddress: TwglGetProcAddress; +{$ELSEIF DEFINED(GLB_LINUX)} + glXGetProcAddress: TglXGetProcAddress; + glXGetProcAddressARB: TglXGetProcAddress; +{$IFEND} - procedure glEnable(cap: Cardinal); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glDisable(cap: Cardinal); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glGetIntegerv(pname: Cardinal; params: PInteger); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} + glEnable: TglEnable; + glDisable: TglDisable; - procedure glTexImage1D(target: Cardinal; level, internalformat, width, border: Integer; format, atype: Cardinal; const pixels: Pointer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glTexImage2D(target: Cardinal; level, internalformat, width, height, border: Integer; format, atype: Cardinal; const pixels: Pointer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; + glGetString: TglGetString; + glGetIntegerv: TglGetIntegerv; - procedure glGenTextures(n: Integer; Textures: PCardinal); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glBindTexture(target: Cardinal; Texture: Cardinal); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glDeleteTextures(n: Integer; const textures: PCardinal); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; + glTexParameteri: TglTexParameteri; + glTexParameteriv: TglTexParameteriv; + glTexParameterfv: TglTexParameterfv; + glGetTexParameteriv: TglGetTexParameteriv; + glGetTexParameterfv: TglGetTexParameterfv; + glGetTexLevelParameteriv: TglGetTexLevelParameteriv; + glGetTexLevelParameterfv: TglGetTexLevelParameterfv; - procedure glReadPixels(x, y: Integer; width, height: Integer; format, atype: Cardinal; pixels: Pointer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glPixelStorei(pname: Cardinal; param: Integer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glGetTexImage(target: Cardinal; level: Integer; format: Cardinal; _type: Cardinal; pixels: Pointer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; + glTexGeni: TglTexGeni; + glGenTextures: TglGenTextures; + glBindTexture: TglBindTexture; + glDeleteTextures: TglDeleteTextures; - function glAreTexturesResident(n: Integer; const Textures: PCardinal; residences: PByteBool): ByteBool; {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glTexParameteri(target: Cardinal; pname: Cardinal; param: Integer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glTexParameterfv(target: Cardinal; pname: Cardinal; const params: PSingle); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glGetTexLevelParameteriv(target: Cardinal; level: Integer; pname: Cardinal; params: PInteger); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; - procedure glTexGeni(coord, pname: Cardinal; param: Integer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libopengl; + glAreTexturesResident: TglAreTexturesResident; + glReadPixels: TglReadPixels; + glPixelStorei: TglPixelStorei; - function gluBuild1DMipmaps(Target: Cardinal; Components, Width: Integer; Format, atype: Cardinal; Data: Pointer): Integer; {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libglu; - function gluBuild2DMipmaps(Target: Cardinal; Components, Width, Height: Integer; Format, aType: Cardinal; Data: Pointer): Integer; {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} external libglu; + glTexImage1D: TglTexImage1D; + glTexImage2D: TglTexImage2D; + glGetTexImage: TglGetTexImage; -var - glCompressedTexImage2D : procedure(target: Cardinal; level: Integer; internalformat: Cardinal; width, height: Integer; border: Integer; imageSize: Integer; const data: Pointer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} - glCompressedTexImage1D : procedure(target: Cardinal; level: Integer; internalformat: Cardinal; width: Integer; border: Integer; imageSize: Integer; const data: Pointer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} - glGetCompressedTexImage : procedure(target: Cardinal; level: Integer; img: Pointer); {$IFDEF WINDOWS}stdcall; {$else}cdecl; {$ENDIF} + gluBuild1DMipmaps: TgluBuild1DMipmaps; + gluBuild2DMipmaps: TgluBuild2DMipmaps; +{$ENDIF} {$ENDIF} -*) type //////////////////////////////////////////////////////////////////////////////////////////////////// - EglBitmapException = class(Exception); - EglBitmapSizeToLargeException = class(EglBitmapException); - EglBitmapNonPowerOfTwoException = class(EglBitmapException); - EglBitmapUnsupportedFormatFormat = class(EglBitmapException); - -//////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapFormat = ( - tfEmpty = 0, + tfEmpty = 0, //must be smallest value! 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, @@ -671,6 +863,17 @@ type nm3x3, nm5x5); + //////////////////////////////////////////////////////////////////////////////////////////////////// + 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; + //////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapColorRec = packed record case Integer of @@ -692,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 @@ -700,20 +940,23 @@ type Position: TglBitmapPixelPosition; Source: TglBitmapPixelData; Dest: TglBitmapPixelData; - Args: PtrInt; + Args: Pointer; end; TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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; @@ -725,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; @@ -750,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); @@ -759,9 +1006,9 @@ type procedure SetAnisotropic(const aValue: Integer); procedure CreateID; - procedure SetupParameters(var aBuildWithGlu: Boolean); - procedure SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; + procedure SetupParameters(out aBuildWithGlu: Boolean); + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; //be careful, aData could be freed by this method procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract; function FlipHorz: Boolean; virtual; @@ -780,39 +1027,42 @@ 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; + procedure PrepareResType(var aResource: String; var aResType: PChar); + //Load procedure LoadFromFile(const aFilename: String); procedure LoadFromStream(const aStream: TStream); virtual; procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; - const aFormat: TglBitmapFormat; const aArgs: PtrInt = 0); - {$IFDEF GLB_DELPHI} - procedure LoadFromResource(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); - procedure LoadFromResourceID(const sInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); - {$ENDIF} + const aFormat: TglBitmapFormat; const aArgs: Pointer = nil); + procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil); + procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); //Save procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType); procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual; //Convert - function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: PtrInt = 0): Boolean; overload; + function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload; function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; - const aFormat: TglBitmapFormat; const aArgs: PtrInt = 0): Boolean; overload; + const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload; public //Alpha & Co {$IFDEF GLB_SDL} @@ -820,7 +1070,7 @@ type function AssignFromSurface(const aSurface: PSDL_Surface): Boolean; function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean; function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; - const aArgs: PtrInt = 0): Boolean; + const aArgs: Pointer = nil): Boolean; {$ENDIF} {$IFDEF GLB_DELPHI} @@ -828,17 +1078,26 @@ type function AssignFromBitmap(const aBitmap: TBitmap): Boolean; function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; - const aArgs: PtrInt = 0): Boolean; - function AddAlphaFromResource(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil; - const aFunc: TglBitmapFunction = nil; const aArgs: PtrInt = 0): Boolean; - function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; - const aFunc: TglBitmapFunction = nil; const aArgs: PtrInt = 0): Boolean; + const aArgs: Pointer = nil): Boolean; + {$ENDIF} + + {$IFDEF GLB_LAZARUS} + function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; + function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; + function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; + function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; + const aArgs: Pointer = nil): Boolean; {$ENDIF} - function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: PtrInt = 0): Boolean; virtual; - function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: PtrInt = 0): Boolean; - function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: PtrInt = 0): Boolean; - function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: PtrInt = 0): Boolean; + function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; + const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; + const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + + function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual; + function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean; function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean; @@ -863,14 +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); - - procedure GetPixel(const aPos: TglBitmapPixelPosition; var aPixel: TglBitmapPixelData); virtual; - procedure SetPixel(const aPos: TglBitmapPixelPosition; const aPixel: TglBitmapPixelData); virtual; + 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; @@ -879,21 +1136,17 @@ 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; const aFunc: TglBitmapFunction; const aArgs: PtrInt = 0); overload; - {$IFDEF GLB_DELPHI} + 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; - {$ENDIF} private - {$IFDEF GLB_SUPPORT_PNG_READ} - function LoadPNG(const aStream: TStream): Boolean; virtual; - procedure SavePNG(const aStream: TStream); virtual; - {$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_READ} - function LoadJPEG(const aStream: TStream): Boolean; virtual; - procedure SaveJPEG(const aStream: TStream); virtual; - {$ENDIF} + {$IFDEF GLB_SUPPORT_PNG_READ} function LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF} + {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF} + + {$IFDEF GLB_SUPPORT_JPEG_READ} function LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF} + {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF} + function LoadBMP(const aStream: TStream): Boolean; virtual; procedure SaveBMP(const aStream: TStream); virtual; @@ -905,24 +1158,26 @@ type end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmap1D = class(TglBitmap) + protected + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; + procedure UploadData(const aBuildWithGlu: Boolean); + public + property Width; + procedure AfterConstruction; override; + function FlipHorz: Boolean; override; + procedure GenTexture(const aTestTextureSize: Boolean = true); override; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap2D = class(TglBitmap) protected - // Bildeinstellungen fLines: array of PByte; - - (* TODO - procedure GetDXTColorBlock(pData: pByte; relX, relY: Integer; var Pixel: TglBitmapPixelData); - procedure GetPixel2DDXT1(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure GetPixel2DDXT3(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure GetPixel2DDXT5(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure GetPixel2DUnmap(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure SetPixel2DUnmap(const Pos: TglBitmapPixelPosition; const Pixel: TglBitmapPixelData); - *) - function GetScanline(const aIndex: Integer): Pointer; - procedure SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat; + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; - procedure UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean); + procedure UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); public property Width; property Height; @@ -941,50 +1196,24 @@ type const aScale: Single = 2; const aUseAlpha: Boolean = false); end; -(* TODO +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapCubeMap = class(TglBitmap2D) protected fGenMode: Integer; - - // Hide GenTexture - procedure GenTexture(TestTextureSize: Boolean = true); reintroduce; + procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce; public procedure AfterConstruction; override; - - procedure GenerateCubeMap(CubeTarget: Cardinal; TestTextureSize: Boolean = true); - - procedure Unbind(DisableTexCoordsGen: Boolean = true; DisableTextureUnit: Boolean = true); reintroduce; virtual; - procedure Bind(EnableTexCoordsGen: Boolean = true; EnableTextureUnit: Boolean = true); reintroduce; virtual; + procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true); + procedure Bind(const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true); reintroduce; virtual; + procedure Unbind(const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true); reintroduce; virtual; end; - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapNormalMap = class(TglBitmapCubeMap) public procedure AfterConstruction; override; - - procedure GenerateNormalMap(Size: Integer = 32; TestTextureSize: Boolean = true); - end; - - - TglBitmap1D = class(TglBitmap) - protected - procedure GetPixel1DUnmap(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - - procedure SetDataPointer(Data: pByte; Format: TglBitmapInternalFormat; Width: Integer = -1; Height: Integer = -1); override; - procedure UploadData (Target, Format, InternalFormat, Typ: Cardinal; BuildWithGlu: Boolean); - public - // propertys - property Width; - - procedure AfterConstruction; override; - - // Other - function FlipHorz: Boolean; override; - - // Generation - procedure GenTexture(TestTextureSize: Boolean = true); override; + procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true); end; -*) const NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0); @@ -1020,6 +1249,7 @@ var glBitmapDefaultWrapS: Cardinal; glBitmapDefaultWrapT: Cardinal; glBitmapDefaultWrapR: Cardinal; + glDefaultSwizzle: array[0..3] of GLenum; {$IFDEF GLB_DELPHI} function CreateGrayPalette: HPALETTE; @@ -1027,19 +1257,19 @@ function CreateGrayPalette: HPALETTE; implementation - - (* TODO - function FormatIsCompressed(Format: TglBitmapInternalFormat): boolean; - function FormatIsUncompressed(Format: TglBitmapInternalFormat): boolean; - function LoadTexture(Filename: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal = 0{$ENDIF}): Boolean; - function LoadCubeMap(PositiveX, NegativeX, PositiveY, NegativeY, PositiveZ, NegativeZ: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal = 0{$ENDIF}): Boolean; - function LoadNormalMap(Size: Integer; var Texture: Cardinal): Boolean; - *) - uses - Math, syncobjs; + Math, syncobjs, typinfo + {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; type +{$IFNDEF fpc} + QWord = System.UInt64; + PQWord = ^QWord; + + PtrInt = Longint; + PtrUInt = DWord; +{$ENDIF} + //////////////////////////////////////////////////////////////////////////////////////////////////// TShiftRec = packed record case Integer of @@ -1047,70 +1277,79 @@ type 1: (arr: array[0..3] of Byte); end; - TFormatDescriptor = class(TObject) + TFormatDescriptor = class(TglBitmapFormatDescriptor) private - function GetRedMask: UInt64; - function GetGreenMask: UInt64; - function GetBlueMask: UInt64; - function GetAlphaMask: UInt64; + function GetRedMask: QWord; + function GetGreenMask: QWord; + function GetBlueMask: QWord; + function GetAlphaMask: QWord; protected 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; - property RedMask: UInt64 read GetRedMask; - property GreenMask: UInt64 read GetGreenMask; - property BlueMask: UInt64 read GetBlueMask; - property AlphaMask: UInt64 read GetAlphaMask; + property RedMask: QWord read GetRedMask; + property GreenMask: QWord read GetGreenMask; + property BlueMask: QWord read GetBlueMask; + property AlphaMask: QWord read GetAlphaMask; procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract; - procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract; - function GetSize(const aSize: TglBitmapPixelPosition): Integer; virtual; overload; - function GetSize(const aWidth, aHeight: Integer): Integer; virtual; overload; + function GetSize(const aSize: TglBitmapPixelPosition): 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: UInt64): Boolean; virtual; + function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; virtual; - procedure PreparePixel(var aPixel: TglBitmapPixelData); virtual; + procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual; constructor Create; virtual; 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; @@ -1121,118 +1360,99 @@ 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var 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; var 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1244,10 +1464,6 @@ type constructor Create; override; end; - TfdAlpha12 = class(TfdAlpha_US1) - constructor Create; override; - end; - TfdAlpha16 = class(TfdAlpha_US1) constructor Create; override; end; @@ -1260,10 +1476,6 @@ type constructor Create; override; end; - TfdLuminance12 = class(TfdLuminance_US1) - constructor Create; override; - end; - TfdLuminance16 = class(TfdLuminance_US1) constructor Create; override; end; @@ -1284,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; @@ -1304,115 +1517,160 @@ type constructor Create; override; end; - TfdRGB5 = class(TfdUniversal_US1) + TfdRGB5X1 = class(TfdUniversal_US1) constructor Create; override; end; - TfdRGB8 = class(TfdRGB_UB3) + TfdX1RGB5 = class(TfdUniversal_US1) constructor Create; override; end; - TfdRGB10 = class(TfdUniversal_UI1) + TfdRGB8 = class(TfdRGB_UB3) constructor Create; override; end; - TfdRGB12 = class(TfdRGB_US3) + TfdRGBX8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGB16 = class(TfdRGB_US3) + TfdXRGB8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGBA2 = class(TfdRGBA_UB4) + TfdRGB10X2 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGBA4 = class(TfdUniversal_US1) + TfdX2RGB10 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdRGB5A1 = class(TfdUniversal_US1) + TfdRGB16 = class(TfdRGB_US3) constructor Create; override; end; - TfdRGBA8 = class(TfdRGBA_UB4) + TfdRGBA4 = class(TfdUniversal_US1) constructor Create; override; end; - TfdRGB10A2 = class(TfdUniversal_UI1) + TfdARGB4 = class(TfdUniversal_US1) constructor Create; override; end; - TfdRGBA12 = class(TfdRGBA_US4) + TfdRGB5A1 = class(TfdUniversal_US1) constructor Create; override; end; - TfdRGBA16 = class(TfdRGBA_US4) + TfdA1RGB5 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGR4 = class(TfdUniversal_US1) + TfdRGBA8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdB5G6R5 = class(TfdUniversal_US1) + TfdARGB8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGR5 = class(TfdUniversal_US1) + TfdRGB10A2 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGR8 = class(TfdBGR_UB3) + TfdA2RGB10 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGR10 = class(TfdUniversal_UI1) + TfdRGBA16 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGR12 = class(TfdBGR_US3) +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdBGRX4 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGR16 = class(TfdBGR_US3) + TfdXBGR4 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGRA2 = class(TfdBGRA_UB4) + TfdB5G6R5 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGRA4 = class(TfdUniversal_US1) + TfdBGR5X1 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGR5A1 = class(TfdUniversal_US1) + TfdX1BGR5 = class(TfdUniversal_US1) constructor Create; override; end; - TfdBGRA8 = class(TfdBGRA_UB4) + TfdBGR8 = class(TfdBGR_UB3) constructor Create; override; end; - TfdBGR10A2 = class(TfdUniversal_UI1) + TfdBGRX8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGRA12 = class(TfdBGRA_US4) + TfdXBGR8 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdBGRA16 = class(TfdBGRA_US4) + TfdBGR10X2 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdDepth16 = class(TfdDepth_US1) + TfdX2BGR10 = class(TfdUniversal_UI1) constructor Create; override; end; - TfdDepth24 = class(TfdDepth_UI1) + TfdBGR16 = class(TfdBGR_US3) + constructor Create; override; + end; + + TfdBGRA4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdABGR4 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdBGR5A1 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdA1BGR5 = class(TfdUniversal_US1) + constructor Create; override; + end; + + TfdBGRA8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdABGR8 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdBGR10A2 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdA2BGR10 = class(TfdUniversal_UI1) + constructor Create; override; + end; + + TfdBGRA16 = class(TfdBGRA_US4) + constructor Create; override; + end; + + TfdDepth16 = class(TfdDepth_US1) + constructor Create; override; + end; + + TfdDepth24 = class(TfdDepth_UI1) constructor Create; override; end; @@ -1422,41 +1680,41 @@ type TfdS3tcDtx1RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; - procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; constructor Create; override; end; TfdS3tcDtx3RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; - procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; constructor Create; override; end; TfdS3tcDtx5RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; - procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TbmpBitfieldFormat = class(TFormatDescriptor) private - procedure SetRedMask (const aValue: UInt64); - procedure SetGreenMask(const aValue: UInt64); - procedure SetBlueMask (const aValue: UInt64); - procedure SetAlphaMask(const aValue: UInt64); + procedure SetRedMask (const aValue: QWord); + procedure SetGreenMask(const aValue: QWord); + procedure SetBlueMask (const aValue: QWord); + procedure SetAlphaMask(const aValue: QWord); - procedure Update(aMask: UInt64; out aRange: Cardinal; out aShift: Byte); + procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte); public - property RedMask: UInt64 read GetRedMask write SetRedMask; - property GreenMask: UInt64 read GetGreenMask write SetGreenMask; - property BlueMask: UInt64 read GetBlueMask write SetBlueMask; - property AlphaMask: UInt64 read GetAlphaMask write SetAlphaMask; + property RedMask: QWord read GetRedMask write SetRedMask; + property GreenMask: QWord read GetGreenMask write SetGreenMask; + property BlueMask: QWord read GetBlueMask write SetBlueMask; + property AlphaMask: QWord read GetAlphaMask write SetAlphaMask; property PixelSize: Single read fPixelSize write fPixelSize; procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; - procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1477,7 +1735,7 @@ type procedure CreateColorTable; procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; - procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; destructor Destroy; override; end; @@ -1501,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, @@ -1562,6 +1829,18 @@ var FormatDescriptorCS: TCriticalSection; FormatDescriptors: array[TglBitmapFormat] of TFormatDescriptor; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat); +begin + inherited Create('unsupported format: ' + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat))); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor EglBitmapUnsupportedFormat.Create(const aMsg: String; const aFormat: TglBitmapFormat); +begin + inherited Create(aMsg + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat))); +end; + ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition; begin @@ -1609,7 +1888,7 @@ end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function FormatGetSupportedFiles(const aFormat: TglBitmapFormat): TglBitmapFileTypes; begin - result := [ftDDS]; + result := []; if (aFormat in [ //4 bbp @@ -1619,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 [ @@ -1636,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, @@ -1646,41 +1925,40 @@ begin tfRGB10A2, tfRGBA8, tfBGR10A2, tfBGRA8]) then result := result + [ftTGA]; - //TODO Supported File Formats! + if (aFormat in [ + //8 bpp + tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2, + tfR3G3B2, + + //16 bpp + tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4, + tfRGBX4, tfXRGB4, tfR5G6B5, tfRGB5X1, tfX1RGB5, tfRGBA4, tfARGB4, tfRGB5A1, tfA1RGB5, + tfBGRX4, tfXBGR4, tfB5G6R5, tfBGR5X1, tfX1BGR5, tfBGRA4, tfABGR4, tfBGR5A1, tfA1BGR5, + + //24 bpp + tfRGB8, tfBGR8, + + //32 bbp + tfLuminance16Alpha16, + tfRGBA8, tfRGB10A2, + tfBGRA8, tfBGR10A2, + + //compressed + tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then + result := result + [ftDDS]; - (* {$IFDEF GLB_SUPPORT_PNG_WRITE} if aFormat in [ - tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16, - tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16, - tfuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16, - tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16, - tfRGBA2, tfRGBA4, tfRGB5A1, tfRGBA8, tfRGB10A2, tfRGBA12, tfRGBA16, - tfDepth16, tfDepth24, tfDepth32] - then + tfAlpha8, tfLuminance8, tfLuminance8Alpha8, + tfRGB8, tfRGBA8, + tfBGR8, tfBGRA8] then result := result + [ftPNG]; {$ENDIF} {$IFDEF GLB_SUPPORT_JPEG_WRITE} - if Format in [ - tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16, - tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16, - tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16, - tfDepth16, tfDepth24, tfDepth32] - then + if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] then result := result + [ftJPEG]; {$ENDIF} - - if aFormat in [ - tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16, - tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16, - tfuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16, - tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16, - tfRGBA2, tfRGBA4, tfRGB5A1, tfRGBA8, tfRGB10A2, tfRGBA12, tfRGBA16, - tfDepth16, tfDepth24, tfDepth32] - then - result := result + [ftDDS, ftTGA, ftBMP]; - *) end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1692,7 +1970,7 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function GetTopMostBit(aBitSet: UInt64): Integer; +function GetTopMostBit(aBitSet: QWord): Integer; begin result := 0; while aBitSet > 0 do begin @@ -1702,7 +1980,7 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function CountSetBits(aBitSet: UInt64): Integer; +function CountSetBits(aBitSet: QWord): Integer; begin result := 0; while aBitSet > 0 do begin @@ -1721,6 +1999,7 @@ begin LUMINANCE_WEIGHT_B * aPixel.Data.b); end; +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function DepthWeight(const aPixel: TglBitmapPixelData): Cardinal; begin result := Trunc( @@ -1729,187 +2008,238 @@ begin DEPTH_WEIGHT_B * aPixel.Data.b); end; -//TODO check _ARB functions and constants +{$IFDEF GLB_NATIVE_OGL} +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//OpenGLInitialization/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +var + GL_LibHandle: Pointer = nil; + +function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer; +begin + if not Assigned(aLibHandle) then + aLibHandle := GL_LibHandle; + +{$IF DEFINED(GLB_WIN)} + result := GetProcAddress({%H-}HMODULE(aLibHandle), aProcName); + if Assigned(result) then + exit; + + if Assigned(wglGetProcAddress) then + result := wglGetProcAddress(aProcName); +{$ELSEIF DEFINED(GLB_LINUX)} + if Assigned(glXGetProcAddress) then begin + result := glXGetProcAddress(aProcName); + if Assigned(result) then + exit; + end; + + if Assigned(glXGetProcAddressARB) then begin + result := glXGetProcAddressARB(aProcName); + if Assigned(result) then + exit; + end; + + result := dlsym(aLibHandle, aProcName); +{$IFEND} + if not Assigned(result) and aRaiseOnErr then + raise EglBitmap.Create('unable to load procedure form library: ' + aProcName); +end; + +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} +var + GLU_LibHandle: Pointer = nil; + OpenGLInitialized: Boolean; + InitOpenGLCS: TCriticalSection; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glbInitOpenGL; + + //////////////////////////////////////////////////////////////////////////////// + function glbLoadLibrary(const aName: PChar): Pointer; + begin + {$IF DEFINED(GLB_WIN)} + result := {%H-}Pointer(LoadLibrary(aName)); + {$ELSEIF DEFINED(GLB_LINUX)} + result := dlopen(Name, RTLD_LAZY); + {$ELSE} + result := nil; + {$IFEND} + end; + + //////////////////////////////////////////////////////////////////////////////// + function glbFreeLibrary(const aLibHandle: Pointer): Boolean; + begin + result := false; + if not Assigned(aLibHandle) then + exit; + + {$IF DEFINED(GLB_WIN)} + Result := FreeLibrary({%H-}HINST(aLibHandle)); + {$ELSEIF DEFINED(GLB_LINUX)} + Result := dlclose(aLibHandle) = 0; + {$IFEND} + end; + +begin + if Assigned(GL_LibHandle) then + glbFreeLibrary(GL_LibHandle); + + if Assigned(GLU_LibHandle) then + glbFreeLibrary(GLU_LibHandle); + + GL_LibHandle := glbLoadLibrary(libopengl); + if not Assigned(GL_LibHandle) then + raise EglBitmap.Create('unable to load library: ' + libopengl); + + GLU_LibHandle := glbLoadLibrary(libglu); + if not Assigned(GLU_LibHandle) then + raise EglBitmap.Create('unable to load library: ' + libglu); + +{$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} -(* GLB_NO_NATIVE_GL -{$IFNDEF GLB_NO_NATIVE_GL} -procedure ReadOpenGLExtensions; +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glbReadOpenGLExtensions; var - {$IFDEF GLB_DELPHI} - Context: HGLRC; - {$ENDIF} Buffer: AnsiString; MajorVersion, MinorVersion: Integer; - - procedure TrimVersionString(Buffer: AnsiString; var Major, Minor: Integer); + /////////////////////////////////////////////////////////////////////////////////////////// + procedure TrimVersionString(aBuffer: AnsiString; out aMajor, aMinor: Integer); var Separator: Integer; begin - Minor := 0; - Major := 0; + aMinor := 0; + aMajor := 0; - Separator := Pos(AnsiString('.'), Buffer); - - if (Separator > 1) and (Separator < Length(Buffer)) and - (Buffer[Separator - 1] in ['0'..'9']) and - (Buffer[Separator + 1] in ['0'..'9']) then begin + Separator := Pos(AnsiString('.'), aBuffer); + if (Separator > 1) and (Separator < Length(aBuffer)) and + (aBuffer[Separator - 1] in ['0'..'9']) and + (aBuffer[Separator + 1] in ['0'..'9']) then begin Dec(Separator); - while (Separator > 0) and (Buffer[Separator] in ['0'..'9']) do + while (Separator > 0) and (aBuffer[Separator] in ['0'..'9']) do Dec(Separator); - Delete(Buffer, 1, Separator); - Separator := Pos(AnsiString('.'), Buffer) + 1; + Delete(aBuffer, 1, Separator); + Separator := Pos(AnsiString('.'), aBuffer) + 1; - while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do + while (Separator <= Length(aBuffer)) and (AnsiChar(aBuffer[Separator]) in ['0'..'9']) do Inc(Separator); - Delete(Buffer, Separator, 255); - Separator := Pos(AnsiString('.'), Buffer); + Delete(aBuffer, Separator, 255); + Separator := Pos(AnsiString('.'), aBuffer); - Major := StrToInt(Copy(String(Buffer), 1, Separator - 1)); - Minor := StrToInt(Copy(String(Buffer), Separator + 1, 1)); + aMajor := StrToInt(Copy(String(aBuffer), 1, Separator - 1)); + aMinor := StrToInt(Copy(String(aBuffer), Separator + 1, 1)); end; end; - + /////////////////////////////////////////////////////////////////////////////////////////// function CheckExtension(const Extension: AnsiString): Boolean; var ExtPos: Integer; begin ExtPos := Pos(Extension, Buffer); result := ExtPos > 0; - if result then result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']); end; - - function glLoad (aFunc: pAnsiChar): pointer; + /////////////////////////////////////////////////////////////////////////////////////////// + function CheckVersion(const aMajor, aMinor: Integer): Boolean; begin - {$IFDEF LINUX} - result := glXGetProcAddress(aFunc); - {$else} - result := wglGetProcAddress(aFunc); - {$ENDIF} + result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor)); end; - begin - {$IFDEF GLB_DELPHI} - Context := wglGetCurrentContext; - - if Context <> gLastContext then begin - gLastContext := Context; - {$ENDIF} - - // Version - 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 >= 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; - end; - - 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; - - // Extensions - Buffer := glGetString(GL_EXTENSIONS); - GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp'); - GL_ARB_texture_cube_map := CheckExtension('GL_ARB_texture_cube_map'); - GL_ARB_texture_compression := CheckExtension('GL_ARB_texture_compression'); - GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two'); - GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle'); - GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat'); - GL_EXT_bgra := CheckExtension('GL_EXT_bgra'); - GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp'); - GL_EXT_texture_cube_map := CheckExtension('GL_EXT_texture_cube_map'); - GL_EXT_texture_compression_s3tc := CheckExtension('GL_EXT_texture_compression_s3tc'); - GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic'); - GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle'); - 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'); - - // Funtions - if GL_VERSION_1_3 then begin - // Loading Core - glCompressedTexImage1D := glLoad('glCompressedTexImage1D'); - glCompressedTexImage2D := glLoad('glCompressedTexImage2D'); - glGetCompressedTexImage := glLoad('glGetCompressedTexImage'); - end else - - begin - // Try loading Extension - glCompressedTexImage1D := glLoad('glCompressedTexImage1DARB'); - glCompressedTexImage2D := glLoad('glCompressedTexImage2DARB'); - glGetCompressedTexImage := glLoad('glGetCompressedTexImageARB'); +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} + InitOpenGLCS.Enter; + try + if not OpenGLInitialized then begin + glbInitOpenGL; + OpenGLInitialized := true; end; - {$IFDEF GLB_DELPHI} + finally + InitOpenGLCS.Leave; end; - {$ENDIF} -end; {$ENDIF} -*) - -(* TODO GLB_DELPHI -{$IFDEF GLB_DELPHI} -function CreateGrayPalette: HPALETTE; -var - Idx: Integer; - Pal: PLogPalette; -begin - GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256)); - Pal.palVersion := $300; - Pal.palNumEntries := 256; + // Version + Buffer := glGetString(GL_VERSION); + TrimVersionString(Buffer, MajorVersion, MinorVersion); - {$IFOPT R+} - {$DEFINE GLB_TEMPRANGECHECK} - {$R-} - {$ENDIF} + 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); - for Idx := 0 to 256 - 1 do begin - Pal.palPalEntry[Idx].peRed := Idx; - Pal.palPalEntry[Idx].peGreen := Idx; - Pal.palPalEntry[Idx].peBlue := Idx; - Pal.palPalEntry[Idx].peFlags := 0; + // 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'); + + if GL_VERSION_1_3 then begin + glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1D'); + glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2D'); + glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage'); + end else begin + glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1DARB', nil, false); + glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB', nil, false); + glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB', nil, false); end; - - {$IFDEF GLB_TEMPRANGECHECK} - {$UNDEF GLB_TEMPRANGECHECK} - {$R+} - {$ENDIF} - - result := CreatePalette(Pal^); - - FreeMem(Pal); end; {$ENDIF} -*) -(* TODO GLB_SDL_IMAGE {$IFDEF GLB_SDL_IMAGE} +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// SDL Image Helper ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl; begin result := TStream(context^.unknown.data1).Seek(offset, whence); @@ -1944,128 +2274,6 @@ begin result^.unknown.data1 := Stream; end; {$ENDIF} -*) - -(* TODO LoadFuncs -function LoadTexture(Filename: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal{$ENDIF}): Boolean; -var - glBitmap: TglBitmap2D; -begin - result := false; - Texture := 0; - - {$IFDEF GLB_DELPHI} - if Instance = 0 then - Instance := HInstance; - - if (LoadFromRes) then - glBitmap := TglBitmap2D.CreateFromResourceName(Instance, FileName) - else - {$ENDIF} - glBitmap := TglBitmap2D.Create(FileName); - - try - glBitmap.DeleteTextureOnFree := false; - glBitmap.FreeDataAfterGenTexture := false; - glBitmap.GenTexture(true); - if (glBitmap.ID > 0) then begin - Texture := glBitmap.ID; - result := true; - end; - finally - glBitmap.Free; - end; -end; - -function LoadCubeMap(PositiveX, NegativeX, PositiveY, NegativeY, PositiveZ, NegativeZ: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal{$ENDIF}): Boolean; -var - CM: TglBitmapCubeMap; -begin - Texture := 0; - - {$IFDEF GLB_DELPHI} - if Instance = 0 then - Instance := HInstance; - {$ENDIF} - - CM := TglBitmapCubeMap.Create; - try - CM.DeleteTextureOnFree := false; - - // Maps - {$IFDEF GLB_DELPHI} - if (LoadFromRes) then - CM.LoadFromResource(Instance, PositiveX) - else - {$ENDIF} - CM.LoadFromFile(PositiveX); - CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X); - - {$IFDEF GLB_DELPHI} - if (LoadFromRes) then - CM.LoadFromResource(Instance, NegativeX) - else - {$ENDIF} - CM.LoadFromFile(NegativeX); - CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X); - - {$IFDEF GLB_DELPHI} - if (LoadFromRes) then - CM.LoadFromResource(Instance, PositiveY) - else - {$ENDIF} - CM.LoadFromFile(PositiveY); - CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y); - - {$IFDEF GLB_DELPHI} - if (LoadFromRes) then - CM.LoadFromResource(Instance, NegativeY) - else - {$ENDIF} - CM.LoadFromFile(NegativeY); - CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y); - - {$IFDEF GLB_DELPHI} - if (LoadFromRes) then - CM.LoadFromResource(Instance, PositiveZ) - else - {$ENDIF} - CM.LoadFromFile(PositiveZ); - CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z); - - {$IFDEF GLB_DELPHI} - if (LoadFromRes) then - CM.LoadFromResource(Instance, NegativeZ) - else - {$ENDIF} - CM.LoadFromFile(NegativeZ); - CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z); - - Texture := CM.ID; - result := true; - finally - CM.Free; - end; -end; - -function LoadNormalMap(Size: Integer; var Texture: Cardinal): Boolean; -var - NM: TglBitmapNormalMap; -begin - Texture := 0; - - NM := TglBitmapNormalMap.Create; - try - NM.DeleteTextureOnFree := false; - NM.GenerateNormalMap(Size); - - Texture := NM.ID; - result := true; - finally - NM.Free; - end; -end; -*) ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean); @@ -2107,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; @@ -2131,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; @@ -2146,96 +2363,175 @@ 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: UInt64; +function TFormatDescriptor.GetRedMask: QWord; begin result := fRange.r shl fShift.r; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetGreenMask: UInt64; +function TFormatDescriptor.GetGreenMask: QWord; begin result := fRange.g shl fShift.g; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetBlueMask: UInt64; +function TFormatDescriptor.GetBlueMask: QWord; begin result := fRange.b shl fShift.b; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetAlphaMask: UInt64; +function TFormatDescriptor.GetAlphaMask: QWord; begin result := fRange.a shl fShift.a; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetComponents: Integer; -var - i: Integer; +function TFormatDescriptor.GetIsCompressed: Boolean; begin - result := 0; - for i := 0 to 3 do - if (fRange.arr[i] > 0) then - inc(result); + result := fIsCompressed; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer; -var - w, h: Integer; +function TFormatDescriptor.GetHasRed: Boolean; begin - if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin - w := Max(1, aSize.X); - h := Max(1, aSize.Y); - result := GetSize(w, h); - end else - result := 0; + result := (fRange.r > 0); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer; +function TFormatDescriptor.GetHasGreen: Boolean; begin - result := 0; - if (aWidth <= 0) or (aHeight <= 0) then - exit; - result := Ceil(aWidth * aHeight * fPixelSize); + result := (fRange.g > 0); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.CreateMappingData: Pointer; +function TFormatDescriptor.GetHasBlue: Boolean; begin - result := nil; + result := (fRange.b > 0); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TFormatDescriptor.FreeMappingData(var aMappingData: Pointer); +function TFormatDescriptor.GetHasAlpha: Boolean; begin - //DUMMY + result := (fRange.a > 0); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.IsEmpty: Boolean; +function TFormatDescriptor.GetRGBInverted: TglBitmapFormat; begin - result := (fFormat = tfEmpty); + result := fRGBInverted; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.HasAlpha: Boolean; +function TFormatDescriptor.GetWithAlpha: TglBitmapFormat; begin - result := (fRange.a > 0); + result := fWithAlpha; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: UInt64): Boolean; +function TFormatDescriptor.GetWithoutAlpha: TglBitmapFormat; begin - result := false; + result := fWithoutAlpha; +end; - if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then - raise EglBitmapException.Create('FormatCheckFormat - All Masks are 0'); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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; +begin + result := 0; + for i := 0 to 3 do + if (fRange.arr[i] > 0) then + inc(result); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer; +var + w, h: Integer; +begin + if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin + w := Max(1, aSize.X); + h := Max(1, aSize.Y); + result := GetSize(w, h); + end else + result := 0; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer; +begin + result := 0; + if (aWidth <= 0) or (aHeight <= 0) then + exit; + result := Ceil(aWidth * aHeight * fPixelSize); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.CreateMappingData: Pointer; +begin + result := nil; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TFormatDescriptor.FreeMappingData(var aMappingData: Pointer); +begin + //DUMMY +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.IsEmpty: Boolean; +begin + result := (fFormat = tfEmpty); +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 EglBitmap.Create('FormatCheckFormat - All Masks are 0'); if (aRedMask <> RedMask) then exit; if (aGreenMask <> GreenMask) then @@ -2248,9 +2544,9 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TFormatDescriptor.PreparePixel(var aPixel: TglBitmapPixelData); +procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData); begin - FillChar(aPixel, SizeOf(aPixel), 0); + FillChar(aPixel{%H-}, SizeOf(aPixel), 0); aPixel.Data := fRange; aPixel.Range := fRange; aPixel.Format := fFormat; @@ -2264,8 +2560,10 @@ begin fFormat := tfEmpty; fWithAlpha := tfEmpty; fWithoutAlpha := tfEmpty; + fOpenGLFormat := tfEmpty; fRGBInverted := tfEmpty; fUncompressed := tfEmpty; + fPixelSize := 0.0; fIsCompressed := false; @@ -2286,22 +2584,13 @@ begin inc(aData); end; -procedure TfdAlpha_UB1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdAlpha_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := 0; aPixel.Data.g := 0; aPixel.Data.b := 0; aPixel.Data.a := aData^; - inc(aData^); -end; - -constructor TfdAlpha_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; - fRange.a := $FF; - fglFormat := GL_ALPHA; - fglDataFormat := GL_UNSIGNED_BYTE; + inc(aData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2313,7 +2602,7 @@ begin inc(aData); end; -procedure TfdLuminance_UB1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminance_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := aData^; aPixel.Data.g := aData^; @@ -2322,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//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2347,7 +2625,7 @@ begin inc(aData); end; -procedure TfdUniversal_UB1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversal_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin @@ -2356,12 +2634,6 @@ begin inc(aData); end; -constructor TfdUniversal_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminanceAlpha_UB2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2372,152 +2644,61 @@ begin inc(aData); end; -procedure TfdLuminanceAlpha_UB2.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceAlpha_UB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := aData^; inc(aData); end; -constructor TfdLuminanceAlpha_UB2.Create; -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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; var 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; var 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//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2527,7 +2708,7 @@ begin inc(aData, 2); end; -procedure TfdAlpha_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdAlpha_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := 0; aPixel.Data.g := 0; @@ -2536,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//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2554,7 +2726,7 @@ begin inc(aData, 2); end; -procedure TfdLuminance_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminance_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PWord(aData)^; aPixel.Data.g := PWord(aData)^; @@ -2563,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//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2588,7 +2749,7 @@ begin inc(aData, 2); end; -procedure TfdUniversal_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversal_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin @@ -2597,12 +2758,6 @@ begin inc(aData, 2); end; -constructor TfdUniversal_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2612,26 +2767,15 @@ begin inc(aData, 2); end; -procedure TfdDepth_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdDepth_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); 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/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2642,151 +2786,127 @@ begin inc(aData, 2); end; -procedure TfdLuminanceAlpha_US2.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceAlpha_US2.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; -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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdRGBA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); 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; + 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 + aPixel.Data.a := PWord(aData)^; + inc(aData, 2); + inherited Unmap(aData, aPixel, aMapData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdRGBA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdARGB_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdARGB_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; -procedure TfdRGBA_US4.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; -constructor TfdRGBA_US4.Create; -begin - inherited Create; - fPixelSize := 8.0; - fRange.a := $FFFF; - fShift.a := 48; - fglFormat := GL_RGBA; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdBGRA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2803,7 +2923,7 @@ begin inc(aData, 4); end; -procedure TfdUniversal_UI1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversal_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin @@ -2812,12 +2932,6 @@ begin inc(aData, 2); end; -constructor TfdUniversal_UI1.Create; -begin - inherited Create; - fPixelSize := 4.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2827,7 +2941,7 @@ begin inc(aData, 4); end; -procedure TfdDepth_UI1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdDepth_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PCardinal(aData)^; aPixel.Data.g := PCardinal(aData)^; @@ -2836,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; @@ -3124,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; @@ -3257,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 TfdBGR10.Create; +constructor TfdXBGR8.Create; begin inherited Create; - fFormat := tfBGR10; + 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 TfdBGR10X2.Create; +begin + inherited Create; + 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; @@ -3337,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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3436,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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; @@ -3449,6 +4072,7 @@ begin inherited Create; fFormat := tfS3tcDtx1RGBA; fWithAlpha := tfS3tcDtx1RGBA; + fOpenGLFormat := tfS3tcDtx1RGBA; fUncompressed := tfRGB5A1; fPixelSize := 0.5; fIsCompressed := true; @@ -3462,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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; @@ -3475,6 +4099,7 @@ begin inherited Create; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; + fOpenGLFormat := tfS3tcDtx3RGBA; fUncompressed := tfRGBA8; fPixelSize := 1.0; fIsCompressed := true; @@ -3488,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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +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; @@ -3501,6 +4126,7 @@ begin inherited Create; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; + fOpenGLFormat := tfS3tcDtx3RGBA; fUncompressed := tfRGBA8; fPixelSize := 1.0; fIsCompressed := true; @@ -3510,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; @@ -3534,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; @@ -3563,31 +4204,31 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TBitfieldFormat///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetRedMask(const aValue: UInt64); +procedure TbmpBitfieldFormat.SetRedMask(const aValue: QWord); begin Update(aValue, fRange.r, fShift.r); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetGreenMask(const aValue: UInt64); +procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord); begin Update(aValue, fRange.g, fShift.g); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetBlueMask(const aValue: UInt64); +procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord); begin Update(aValue, fRange.b, fShift.b); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: UInt64); +procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord); begin Update(aValue, fRange.a, fShift.a); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.Update(aMask: UInt64; out aRange: Cardinal; out +procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte); begin aShift := 0; @@ -3611,10 +4252,8 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var - data: UInt64; + data: QWord; s: Integer; -type - PUInt64 = ^UInt64; begin data := ((aPixel.Data.r and fRange.r) shl fShift.r) or @@ -3626,29 +4265,27 @@ begin 1: aData^ := data; 2: PWord(aData)^ := data; 4: PCardinal(aData)^ := data; - 8: PUInt64(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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var - data: UInt64; + data: QWord; s, i: Integer; -type - PUInt64 = ^UInt64; begin s := Round(fPixelSize); case s of 1: data := aData^; 2: data := PWord(aData)^; 4: data := PCardinal(aData)^; - 8: data := PUInt64(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]; @@ -3660,12 +4297,10 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpColorTableFormat.CreateColorTable; var - bits: Byte; - len: Integer; 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) @@ -3708,16 +4343,16 @@ 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 if (aMapData = nil) then aData^ := 0; d := LuminanceWeight(aPixel) and Range.r; - aData^ := aData^ or (d shl (4 - PtrInt(aMapData))); - inc(aMapData, 4); - if (PtrInt(aMapData) >= 8) then begin + aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData))); + inc(PByte(aMapData), 4); + if ({%H-}PtrUInt(aMapData) >= 8) then begin inc(aData); aMapData := nil; end; @@ -3738,11 +4373,10 @@ begin end; end; -procedure TbmpColorTableFormat.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); -type - PUInt64 = ^UInt64; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var - idx: UInt64; + idx: QWord; s: Integer; bits: Byte; f: Single; @@ -3751,26 +4385,26 @@ begin f := fPixelSize - s; bits := Round(8 * f); case s of - 0: idx := (aData^ shr (8 - bits - PtrInt(aMapData))) and ((1 shl bits) - 1); + 0: idx := (aData^ shr (8 - bits - {%H-}PtrInt(aMapData))) and ((1 shl bits) - 1); 1: idx := aData^; 2: idx := PWord(aData)^; 4: idx := PCardinal(aData)^; - 8: idx := PUInt64(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; aPixel.Data.b := b; aPixel.Data.a := a; end; - inc(aMapData, bits); - if (PtrInt(aMapData) >= 8) then begin + inc(PByte(aMapData), bits); + if ({%H-}PtrUInt(aMapData) >= 8) then begin inc(aData, 1); - dec(aMapData, 8); + dec(PByte(aMapData), 8); end; inc(aData, s); end; @@ -3784,6 +4418,21 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TglBitmap - Helper////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapConvertPixel(var aPixel: TglBitmapPixelData; const aSourceFD, aDestFD: TFormatDescriptor); +var + i: Integer; +begin + for i := 0 to 3 do begin + if (aSourceFD.Range.arr[i] <> aDestFD.Range.arr[i]) then 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] := 0; + end; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glBitmapConvertCopyFunc(var aFuncRec: TglBitmapFunctionRec); begin with aFuncRec do begin @@ -3833,16 +4482,13 @@ end; procedure glBitmapInvertFunc(var aFuncRec: TglBitmapFunctionRec); begin with aFuncRec do begin - Dest.Data.r := Source.Data.r; - Dest.Data.g := Source.Data.g; - Dest.Data.b := Source.Data.b; - Dest.Data.a := Source.Data.a; - if (Args and $1 > 0) then begin + Dest.Data := Source.Data; + if ({%H-}PtrUInt(Args) and $1 > 0) then begin Dest.Data.r := Dest.Data.r xor Dest.Range.r; Dest.Data.g := Dest.Data.g xor Dest.Range.g; Dest.Data.b := Dest.Data.b xor Dest.Range.b; end; - if (Args and $2 > 0) then begin + if ({%H-}PtrUInt(Args) and $2 > 0) then begin Dest.Data.a := Dest.Data.a xor Dest.Range.a; end; end; @@ -3865,7 +4511,7 @@ var Temp: Single; begin with FuncRec do begin - if (FuncRec.Args = 0) then begin //source has no alpha + if (FuncRec.Args = nil) then begin //source has no alpha Temp := Source.Data.r / Source.Range.r * ALPHA_WEIGHT_R + Source.Data.g / Source.Range.g * ALPHA_WEIGHT_G + @@ -3898,8 +4544,6 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glBitmapValueAlphaFunc(var FuncRec: TglBitmapFunctionRec); -type - PglBitmapPixelData = ^TglBitmapPixelData; begin with FuncRec do begin Dest.Data.r := Source.Data.r; @@ -3933,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 @@ -3987,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 @@ -4000,8 +4658,8 @@ begin if fFormat = aValue then exit; if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then - raise EglBitmapUnsupportedFormatFormat.Create('SetInternalFormat - ' + UNSUPPORTED_FORMAT); - SetDataPointer(Data, aValue, Width, Height); + raise EglBitmapUnsupportedFormat.Create(Format); + SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4067,7 +4725,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetupParameters(var aBuildWithGlu: Boolean); +procedure TglBitmap.SetupParameters(out aBuildWithGlu: Boolean); begin // Set Up Parameters SetWrap(fWrapS, fWrapT, fWrapR); @@ -4075,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 @@ -4087,7 +4748,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat; +procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer; const aHeight: Integer); var s: Single; @@ -4098,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; @@ -4144,31 +4804,48 @@ 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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.BeforeDestruction; +var + NewData: PByte; begin - SetDataPointer(nil, tfEmpty); + 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; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.PrepareResType(var aResource: String; var aResType: PChar); +var + TempPos: Integer; +begin + if not Assigned(aResType) then begin + TempPos := Pos('.', aResource); + aResType := PChar(UpperCase(Copy(aResource, TempPos + 1, Length(aResource) - TempPos))); + aResource := UpperCase(Copy(aResource, 0, TempPos -1)); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.LoadFromFile(const aFilename: String); 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 @@ -4191,12 +4868,12 @@ 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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction; - const aFormat: TglBitmapFormat; const aArgs: PtrInt); + const aFormat: TglBitmapFormat; const aArgs: Pointer); var tmpData: PByte; size: Integer; @@ -4205,32 +4882,22 @@ begin GetMem(tmpData, size); try FillChar(tmpData^, size, #$FF); - SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); + SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method except - FreeMem(tmpData); + if Assigned(tmpData) then + FreeMem(tmpData); raise; end; - AddFunc(Self, aFunc, false, Format, aArgs); + AddFunc(Self, aFunc, false, aFormat, aArgs); end; -{$IFDEF GLB_DELPHI} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromResource(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); +procedure TglBitmap.LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar); var rs: TResourceStream; - TempPos: Integer; - ResTypeStr: String; - TempResType: PChar; -begin - if not Assigned(ResType) then begin - TempPos := Pos('.', Resource); - ResTypeStr := UpperCase(Copy(Resource, TempPos + 1, Length(Resource) - TempPos)); - Resource := UpperCase(Copy(Resource, 0, TempPos -1)); - TempResType := PChar(ResTypeStr); - end else - TempResType := ResType - - rs := TResourceStream.Create(Instance, Resource, TempResType); +begin + PrepareResType(aResource, aResType); + rs := TResourceStream.Create(aInstance, aResource, aResType); try LoadFromStream(rs); finally @@ -4239,18 +4906,17 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromResourceID(const sInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); +procedure TglBitmap.LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); var rs: TResourceStream; begin - rs := TResourceStream.CreateFromID(Instance, ResourceID, ResType); + rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); try LoadFromStream(rs); finally rs.Free; end; end; -{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType); @@ -4271,7 +4937,7 @@ procedure TglBitmap.SaveToStream(const aStream: TStream; const aFileType: TglBit begin case aFileType of {$IFDEF GLB_SUPPORT_PNG_WRITE} - ftPNG: SavePng(aStream); + ftPNG: SavePNG(aStream); {$ENDIF} {$IFDEF GLB_SUPPORT_JPEG_WRITE} ftJPEG: SaveJPEG(aStream); @@ -4283,14 +4949,14 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: PtrInt): Boolean; +function TglBitmap.AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean; begin result := AddFunc(Self, aFunc, aCreateTemp, Format, aArgs); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; - const aFormat: TglBitmapFormat; const aArgs: PtrInt): Boolean; + const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean; var DestData, TmpData, SourceData: pByte; TempHeight, TempWidth: Integer; @@ -4308,6 +4974,11 @@ begin SourceFD := TFormatDescriptor.Get(aSource.Format); DestFD := TFormatDescriptor.Get(aFormat); + if (SourceFD.IsCompressed) then + raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format); + if (DestFD.IsCompressed) then + raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format); + // inkompatible Formats so CreateTemp if (SourceFD.PixelSize <> DestFD.PixelSize) then aCreateTemp := true; @@ -4321,7 +4992,7 @@ begin TmpData := nil; if aCreateTemp then begin - GetMem(TmpData, TFormatDescriptor.Get(aFormat).GetSize(TempWidth, TempHeight)); + GetMem(TmpData, DestFD.GetSize(TempWidth, TempHeight)); DestData := TmpData; end else DestData := Data; @@ -4352,7 +5023,7 @@ begin // Updating Image or InternalFormat if aCreateTemp then - SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) + SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) //be careful, Data could be freed by this method else if (aFormat <> fFormat) then Format := aFormat; @@ -4362,7 +5033,7 @@ begin DestFD.FreeMappingData(DestMD); end; except - if aCreateTemp then + if aCreateTemp and Assigned(TmpData) then FreeMem(TmpData); raise; end; @@ -4376,42 +5047,37 @@ var Row, RowSize: Integer; SourceData, TmpData: PByte; TempDepth: Integer; - Pix: TglBitmapPixelData; - FormatDesc: TglBitmapFormatDescriptor; + FormatDesc: TFormatDescriptor; function GetRowPointer(Row: Integer): pByte; begin - result := Surface.pixels; + result := aSurface.pixels; Inc(result, Row * RowSize); end; begin result := false; - (* TODO - if not FormatIsUncompressed(InternalFormat) then - raise EglBitmapUnsupportedInternalFormat.Create('AssignToSurface - ' + UNSUPPORTED_INTERNAL_FORMAT); - *) + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed then + raise EglBitmapUnsupportedFormat.Create(Format); - FormatDesc := FORMAT_DESCRIPTORS[Format]; if Assigned(Data) then begin - case Trunc(FormatDesc.GetSize) of + case Trunc(FormatDesc.PixelSize) of 1: TempDepth := 8; 2: TempDepth := 16; 3: TempDepth := 24; 4: TempDepth := 32; else - raise EglBitmapException.Create('AssignToSurface - ' + UNSUPPORTED_INTERNAL_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); end; - FormatDesc.PreparePixel(Pix); - with Pix.PixelDesc do - Surface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth, - RedRange shl RedShift, GreenRange shl GreenShift, BlueRange shl BlueShift, AlphaRange shl AlphaShift); + aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth, + FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask); SourceData := Data; - RowSize := Ceil(FileWidth * FormatDesc.GetSize); + RowSize := FormatDesc.GetSize(FileWidth, 1); - for Row := 0 to FileHeight -1 do begin + for Row := 0 to FileHeight-1 do begin TmpData := GetRowPointer(Row); if Assigned(TmpData) then begin Move(SourceData^, TmpData^, RowSize); @@ -4427,34 +5093,31 @@ function TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean; var pSource, pData, pTempData: PByte; Row, RowSize, TempWidth, TempHeight: Integer; - IntFormat, f: TglBitmapInternalFormat; - FormatDesc: TglBitmapFormatDescriptor; + IntFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; function GetRowPointer(Row: Integer): pByte; begin - result := Surface^.pixels; + result := aSurface^.pixels; Inc(result, Row * RowSize); end; begin result := false; - if (Assigned(Surface)) then begin - with Surface^.format^ do begin - IntFormat := tfEmpty; - for f := Low(f) to High(f) do begin - if FORMAT_DESCRIPTORS[f].MaskMatch(RMask, GMask, BMask, AMask) then begin - IntFormat := f; + if (Assigned(aSurface)) then begin + with aSurface^.format^ do begin + for IntFormat := High(TglBitmapFormat) to Low(TglBitmapFormat) do begin + FormatDesc := TFormatDescriptor.Get(IntFormat); + if (FormatDesc.MaskMatch(RMask, GMask, BMask, AMask)) then break; - end; end; if (IntFormat = tfEmpty) then raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.'); end; - FormatDesc := FORMAT_DESCRIPTORS[IntFormat]; - TempWidth := Surface^.w; - TempHeight := Surface^.h; - RowSize := Trunc(TempWidth * FormatDesc.GetSize); + TempWidth := aSurface^.w; + TempHeight := aSurface^.h; + RowSize := FormatDesc.GetSize(TempWidth, 1); GetMem(pData, TempHeight * RowSize); try pTempData := pData; @@ -4465,10 +5128,11 @@ begin Inc(pTempData, RowSize); end; end; - SetDataPointer(pData, IntFormat, TempWidth, TempHeight); + SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method result := true; except - FreeMem(pData); + if Assigned(pData) then + FreeMem(pData); raise; end; end; @@ -4494,9 +5158,9 @@ begin AlphaInterleave := 0; case Format of - ifLuminance8Alpha8: + tfLuminance8Alpha8: AlphaInterleave := 1; - ifBGRA8, ifRGBA8: + tfBGRA8, tfRGBA8: AlphaInterleave := 3; end; @@ -4518,14 +5182,14 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; var bmp: TglBitmap2D; begin bmp := TglBitmap2D.Create; try - bmp.AssignFromSurface(Surface); - result := AddAlphaFromGlBitmap(bmp, Func, CustomData); + bmp.AssignFromSurface(aSurface); + result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs); finally bmp.Free; end; @@ -4533,7 +5197,27 @@ end; {$ENDIF} {$IFDEF GLB_DELPHI} -//TODO rework & test +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function CreateGrayPalette: HPALETTE; +var + Idx: Integer; + Pal: PLogPalette; +begin + GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256)); + + Pal.palVersion := $300; + Pal.palNumEntries := 256; + + for Idx := 0 to Pal.palNumEntries - 1 do begin + Pal.palPalEntry[Idx].peRed := Idx; + Pal.palPalEntry[Idx].peGreen := Idx; + Pal.palPalEntry[Idx].peBlue := Idx; + Pal.palPalEntry[Idx].peFlags := 0; + end; + Result := CreatePalette(Pal^); + FreeMem(Pal); +end; + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.AssignToBitmap(const aBitmap: TBitmap): Boolean; var @@ -4547,35 +5231,30 @@ begin aBitmap.Height := Height; case Format of - tfAlpha8, ifLuminance, ifDepth8: - begin - Bitmap.PixelFormat := pf8bit; - Bitmap.Palette := CreateGrayPalette; - end; - ifRGB5A1: - Bitmap.PixelFormat := pf15bit; - ifR5G6B5: - Bitmap.PixelFormat := pf16bit; - ifRGB8, ifBGR8: - Bitmap.PixelFormat := pf24bit; - ifRGBA8, ifBGRA8: - Bitmap.PixelFormat := pf32bit; - else - raise EglBitmapException.Create('AssignToBitmap - Invalid Pixelformat.'); + tfAlpha8, tfLuminance8: begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + end; + tfRGB5A1: + aBitmap.PixelFormat := pf15bit; + tfR5G6B5: + aBitmap.PixelFormat := pf16bit; + tfRGB8, tfBGR8: + aBitmap.PixelFormat := pf24bit; + tfRGBA8, tfBGRA8: + aBitmap.PixelFormat := pf32bit; + else + raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.'); end; pSource := Data; for Row := 0 to FileHeight -1 do begin - pData := Bitmap.Scanline[Row]; - + pData := aBitmap.Scanline[Row]; Move(pSource^, pData^, fRowSize); Inc(pSource, fRowSize); - - // swap RGB(A) to BGR(A) - if InternalFormat in [ifRGB8, ifRGBA8] then - SwapRGB(pData, FileWidth, InternalFormat = ifRGBA8); + if (Format in [tfRGB8, tfRGBA8]) then // swap RGB(A) to BGR(A) + SwapRGB(pData, FileWidth, Format = tfRGBA8); end; - result := true; end; end; @@ -4586,49 +5265,44 @@ function TglBitmap.AssignFromBitmap(const aBitmap: TBitmap): Boolean; var pSource, pData, pTempData: PByte; Row, RowSize, TempWidth, TempHeight: Integer; - IntFormat: TglBitmapInternalFormat; + IntFormat: TglBitmapFormat; begin result := false; - if (Assigned(Bitmap)) then begin - case Bitmap.PixelFormat of + if (Assigned(aBitmap)) then begin + case aBitmap.PixelFormat of pf8bit: - IntFormat := ifLuminance; + IntFormat := tfLuminance8; pf15bit: - IntFormat := ifRGB5A1; + IntFormat := tfRGB5A1; pf16bit: - IntFormat := ifR5G6B5; + IntFormat := tfR5G6B5; pf24bit: - IntFormat := ifBGR8; + IntFormat := tfBGR8; pf32bit: - IntFormat := ifBGRA8; - else - raise EglBitmapException.Create('AssignFromBitmap - Invalid Pixelformat.'); + IntFormat := tfBGRA8; + else + raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.'); end; - TempWidth := Bitmap.Width; - TempHeight := Bitmap.Height; - - RowSize := Trunc(TempWidth * FormatGetSize(IntFormat)); - + TempWidth := aBitmap.Width; + TempHeight := aBitmap.Height; + RowSize := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1); GetMem(pData, TempHeight * RowSize); try pTempData := pData; - for Row := 0 to TempHeight -1 do begin - pSource := Bitmap.Scanline[Row]; - + pSource := aBitmap.Scanline[Row]; if (Assigned(pSource)) then begin Move(pSource^, pTempData^, RowSize); Inc(pTempData, RowSize); end; end; - - SetDataPointer(pData, IntFormat, TempWidth, TempHeight); - + SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method result := true; except - FreeMem(pData); + if Assigned(pData) then + FreeMem(pData); raise; end; end; @@ -4643,17 +5317,17 @@ begin result := false; if Assigned(Data) then begin - if InternalFormat in [ifAlpha, ifLuminanceAlpha, ifRGBA8, ifBGRA8] then begin - if Assigned(Bitmap) then begin - Bitmap.PixelFormat := pf8bit; - Bitmap.Palette := CreateGrayPalette; - Bitmap.Width := Width; - Bitmap.Height := Height; - - case InternalFormat of - ifLuminanceAlpha: + if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin + if Assigned(aBitmap) then begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + aBitmap.Width := Width; + aBitmap.Height := Height; + + case Format of + tfLuminance8Alpha8: AlphaInterleave := 1; - ifRGBA8, ifBGRA8: + tfRGBA8, tfBGRA8: AlphaInterleave := 3; else AlphaInterleave := 0; @@ -4663,8 +5337,7 @@ begin pSource := Data; for Row := 0 to Height -1 do begin - pDest := Bitmap.Scanline[Row]; - + pDest := aBitmap.Scanline[Row]; if Assigned(pDest) then begin for Col := 0 to Width -1 do begin Inc(pSource, AlphaInterleave); @@ -4674,7 +5347,6 @@ begin end; end; end; - result := true; end; end; @@ -4682,77 +5354,290 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var tex: TglBitmap2D; begin tex := TglBitmap2D.Create; try - tex.AssignFromBitmap(Bitmap); - result := AddAlphaFromglBitmap(tex, Func, CustomData); + tex.AssignFromBitmap(ABitmap); + result := AddAlphaFromglBitmap(tex, aFunc, aArgs); finally tex.Free; end; end; +{$ENDIF} +{$IFDEF GLB_LAZARUS} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromResource(const aInstance: Cardinal; const aResource: String; const aResType: PChar; - const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; var - RS: TResourceStream; - TempPos: Integer; - ResTypeStr: String; - TempResType: PChar; + rid: TRawImageDescription; + FormatDesc: TFormatDescriptor; begin - if Assigned(ResType) then - TempResType := ResType + result := false; + if not Assigned(aImage) or (Format = tfEmpty) then + exit; + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed then + exit; + + FillChar(rid{%H-}, SizeOf(rid), 0); + if (Format in [ + tfAlpha4, tfAlpha8, tfAlpha16, + tfLuminance4, tfLuminance8, tfLuminance16, + tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance16Alpha16]) then + rid.Format := ricfGray else - begin - TempPos := Pos('.', Resource); - ResTypeStr := UpperCase(Copy(Resource, TempPos + 1, Length(Resource) - TempPos)); - Resource := UpperCase(Copy(Resource, 0, TempPos -1)); - TempResType := PChar(ResTypeStr); + rid.Format := ricfRGBA; + + rid.Width := Width; + rid.Height := Height; + rid.Depth := CountSetBits(FormatDesc.RedMask or FormatDesc.GreenMask or FormatDesc.BlueMask or FormatDesc.AlphaMask); + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := Round(8 * FormatDesc.PixelSize); + rid.RedPrec := CountSetBits(FormatDesc.Range.r); + rid.GreenPrec := CountSetBits(FormatDesc.Range.g); + rid.BluePrec := CountSetBits(FormatDesc.Range.b); + rid.AlphaPrec := CountSetBits(FormatDesc.Range.a); + rid.RedShift := FormatDesc.Shift.r; + rid.GreenShift := FormatDesc.Shift.g; + rid.BlueShift := FormatDesc.Shift.b; + rid.AlphaShift := FormatDesc.Shift.a; + + rid.MaskBitsPerPixel := 0; + rid.PaletteColorCount := 0; + + aImage.DataDescription := rid; + aImage.CreateData; + + Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension)); + + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; +var + f: TglBitmapFormat; + 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 + exit; + for f := High(f) downto Low(f) do begin + FormatDesc := TFormatDescriptor.Get(f); + with aImage.DataDescription do + if FormatDesc.MaskMatch( + (QWord(1 shl RedPrec )-1) shl RedShift, + (QWord(1 shl GreenPrec)-1) shl GreenShift, + (QWord(1 shl BluePrec )-1) shl BlueShift, + (QWord(1 shl AlphaPrec)-1) shl AlphaShift) then + break; + end; + + 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 + 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 + FreeMem(ImageData); + raise; + end; + + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; +var + rid: TRawImageDescription; + FormatDesc: TFormatDescriptor; + Pixel: TglBitmapPixelData; + x, y: Integer; + srcMD: Pointer; + src, dst: PByte; +begin + result := false; + if not Assigned(aImage) or (Format = tfEmpty) then + exit; + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then + exit; + + FillChar(rid{%H-}, SizeOf(rid), 0); + rid.Format := ricfGray; + rid.Width := Width; + rid.Height := Height; + rid.Depth := CountSetBits(FormatDesc.Range.a); + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8); + rid.RedPrec := CountSetBits(FormatDesc.Range.a); + rid.GreenPrec := 0; + rid.BluePrec := 0; + rid.AlphaPrec := 0; + rid.RedShift := 0; + rid.GreenShift := 0; + rid.BlueShift := 0; + rid.AlphaShift := 0; + + rid.MaskBitsPerPixel := 0; + rid.PaletteColorCount := 0; + + aImage.DataDescription := rid; + aImage.CreateData; + + srcMD := FormatDesc.CreateMappingData; + try + FormatDesc.PreparePixel(Pixel); + src := Data; + dst := aImage.PixelData; + for y := 0 to Height-1 do + for x := 0 to Width-1 do begin + FormatDesc.Unmap(src, Pixel, srcMD); + case rid.BitsPerPixel of + 8: begin + dst^ := Pixel.Data.a; + inc(dst); + end; + 16: begin + PWord(dst)^ := Pixel.Data.a; + inc(dst, 2); + end; + 24: begin + PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0]; + PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1]; + PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2]; + inc(dst, 3); + end; + 32: begin + PCardinal(dst)^ := Pixel.Data.a; + inc(dst, 4); + end; + else + raise EglBitmapUnsupportedFormat.Create(Format); + end; + end; + finally + FormatDesc.FreeMappingData(srcMD); + end; + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + tex: TglBitmap2D; +begin + tex := TglBitmap2D.Create; + try + tex.AssignFromLazIntfImage(aImage); + result := AddAlphaFromglBitmap(tex, aFunc, aArgs); + finally + tex.Free; + end; +end; +{$ENDIF} - RS := TResourceStream.Create(Instance, Resource, TempResType); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar; + const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + rs: TResourceStream; +begin + PrepareResType(aResource, aResType); + rs := TResourceStream.Create(aInstance, aResource, aResType); try - result := AddAlphaFromStream(RS, Func, CustomData); + result := AddAlphaFromStream(rs, aFunc, aArgs); finally - RS.Free; + rs.Free; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; - const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; + const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var - RS: TResourceStream; + rs: TResourceStream; begin - RS := TResourceStream.CreateFromID(Instance, ResourceID, ResType); + rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); try - result := AddAlphaFromStream(RS, Func, CustomData); + result := AddAlphaFromStream(rs, aFunc, aArgs); finally - RS.Free; + rs.Free; end; end; -{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; begin - (* TODO - if not FormatIsUncompressed(InternalFormat) then - raise EglBitmapUnsupportedFormatFormat.Create('AddAlphaFromFunc - ' + UNSUPPORTED_FORMAT); - *) + if TFormatDescriptor.Get(Format).IsCompressed then + raise EglBitmapUnsupportedFormat.Create(Format); result := AddFunc(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var FS: TFileStream; begin - FS := TFileStream.Create(FileName, fmOpenRead); + FS := TFileStream.Create(aFileName, fmOpenRead); try result := AddAlphaFromStream(FS, aFunc, aArgs); finally @@ -4761,7 +5646,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var tex: TglBitmap2D; begin @@ -4774,7 +5659,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var DestData, DestData2, SourceData: pByte; TempHeight, TempWidth: Integer; @@ -4791,21 +5676,23 @@ begin if ((aBitmap.Width = Width) and (aBitmap.Height = Height)) then begin result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha); - if not Assigned(aFunc) then - aFunc := glBitmapAlphaFunc; SourceFD := TFormatDescriptor.Get(aBitmap.Format); DestFD := TFormatDescriptor.Get(Format); + if not Assigned(aFunc) then begin + aFunc := glBitmapAlphaFunc; + FuncRec.Args := {%H-}Pointer(SourceFD.HasAlpha); + end else + FuncRec.Args := aArgs; + // Values TempHeight := aBitmap.FileHeight; TempWidth := aBitmap.FileWidth; FuncRec.Sender := Self; - FuncRec.Args := aArgs; FuncRec.Size := Dimension; FuncRec.Position.Fields := FuncRec.Size.Fields; - FuncRec.Args := PtrInt(SourceFD.HasAlpha) and 1; DestData := Data; DestData2 := Data; @@ -4850,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, @@ -4866,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; @@ -4880,7 +5767,7 @@ begin Data.a := 0; Range.a := 0; end; - result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, PtrInt(@PixelData)); + result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, @PixelData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4894,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; @@ -4903,10 +5790,10 @@ 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, PtrInt(@PixelData.Data.a)); + result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4917,8 +5804,8 @@ begin result := false; FormatDesc := TFormatDescriptor.Get(Format); if Assigned(Data) then begin - if not ({FormatDesc.IsUncompressed or }FormatDesc.HasAlpha) then - raise EglBitmapUnsupportedFormatFormat.Create('RemoveAlpha - ' + UNSUPPORTED_FORMAT); + if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then + raise EglBitmapUnsupportedFormat.Create(Format); result := ConvertTo(FormatDesc.WithoutAlpha); end; end; @@ -4939,13 +5826,16 @@ begin GetMem(TempPtr, Size); try Move(Data^, TempPtr^, Size); - Temp.SetDataPointer(TempPtr, Format, Width, Height); + Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method except - FreeMem(TempPtr); + if Assigned(TempPtr) then + FreeMem(TempPtr); raise; end; - end else - Temp.SetDataPointer(nil, Format, Width, Height); + end else begin + TempPtr := nil; + Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method + end; // copy properties Temp.fID := ID; @@ -4980,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 := @@ -5012,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); @@ -5022,7 +5927,7 @@ begin ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g); ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b); ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a); - result := AddFunc(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, PtrInt(@ShiftData)); + result := AddFunc(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData); end else result := AddFunc(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat); end else @@ -5033,7 +5938,9 @@ end; procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean); begin if aUseRGB or aUseAlpha then - AddFunc(glBitmapInvertFunc, false, ((PtrInt(aUseAlpha) and 1) shl 1) or (PtrInt(aUseRGB) and 1)); + AddFunc(glBitmapInvertFunc, false, {%H-}Pointer( + ((Byte(aUseAlpha) and 1) shl 1) or + (Byte(aUseRGB) and 1) )); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5051,8 +5958,11 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.FreeData; +var + TempPtr: PByte; begin - SetDataPointer(nil, tfEmpty); + TempPtr := nil; + SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5067,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, @@ -5087,11 +5997,11 @@ begin Data.b := Max(0, Min(Range.b, Trunc(Range.b * aBlue))); Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha))); end; - AddFunc(glBitmapFillWithColorFunc, false, PtrInt(@PixelData)); + AddFunc(glBitmapFillWithColorFunc, false, @PixelData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFilter(const aMin, aMag: Cardinal); +procedure TglBitmap.SetFilter(const aMin, aMag: GLenum); begin //check MIN filter case aMin of @@ -5108,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 @@ -5118,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 @@ -5141,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 @@ -5170,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; @@ -5191,21 +6101,29 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.GetPixel(const aPos: TglBitmapPixelPosition; var aPixel: TglBitmapPixelData); -begin - { TODO delete? - if Assigned (fGetPixelFunc) then - fGetPixelFunc(aPos, aPixel); - } -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; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetPixel(const aPos: TglBitmapPixelPosition; const aPixel: TglBitmapPixelData); begin - {TODO delete? - if Assigned (fSetPixelFunc) then - fSetPixelFuc(aPos, aPixel); - } + 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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5228,19 +6146,21 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TglBitmap.Create; begin -{$IFNDEF GLB_NO_NATIVE_GL} - ReadOpenGLExtensions; -{$ENDIF} 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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5251,32 +6171,35 @@ 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; - TFormatDescriptor.Get(aFormat).GetSize(aSize); - GetMem(Image, ImageSize); - try - FillChar(Image^, ImageSize, #$FF); - SetDataPointer(Image, aFormat, aSize.X, aSize.Y); - except - FreeMem(Image); - raise; +begin + Create; + 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: PtrInt); +constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); begin Create; LoadFromFunc(aSize, aFunc, aFormat, aArgs); end; -{$IFDEF GLB_DELPHI} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar); begin @@ -5290,14 +6213,53 @@ begin Create; LoadFromResourceID(aInstance, aResourceID, aResType); end; -{$ENDIF} {$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; @@ -5309,7 +6271,7 @@ begin Surface := IMG_LoadPNG_RW(RWops); try AssignFromSurface(Surface); - Rresult := true; + result := true; finally SDL_FreeSurface(Surface); end; @@ -5335,7 +6297,7 @@ var png_info: png_infop; TempHeight, TempWidth: Integer; - Format: TglBitmapInternalFormat; + Format: TglBitmapFormat; png_data: pByte; png_rows: array of pByte; @@ -5348,9 +6310,9 @@ begin try // signature - StreamPos := Stream.Position; - Stream.Read(signature, 8); - Stream.Position := StreamPos; + StreamPos := aStream.Position; + aStream.Read(signature{%H-}, 8); + aStream.Position := StreamPos; if png_check_sig(@signature, 8) <> 0 then begin // png read struct @@ -5366,12 +6328,12 @@ begin end; // set read callback - png_set_read_fn(png, stream, glBitmap_libPNG_read_func); + png_set_read_fn(png, aStream, glBitmap_libPNG_read_func); // 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); @@ -5419,11 +6381,12 @@ begin SetLength(png_rows, 0); // set new data - SetDataPointer(png_data, Format, TempWidth, TempHeight); + SetDataPointer(png_data, Format, TempWidth, TempHeight); //be careful, Data could be freed by this method result := true; except - FreeMem(png_data); + if Assigned(png_data) then + FreeMem(png_data); raise; end; end; @@ -5438,42 +6401,44 @@ function TglBitmap.LoadPNG(const aStream: TStream): Boolean; var StreamPos: Int64; Png: TPNGObject; - Header: Array[0..7] of Byte; + Header: String[8]; Row, Col, PixSize, LineSize: Integer; NewImage, pSource, pDest, pAlpha: pByte; - Format: TglBitmapInternalFormat; + PngFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; const - PngHeader: Array[0..7] of Byte = (#137, #80, #78, #71, #13, #10, #26, #10); + PngHeader: String[8] = #137#80#78#71#13#10#26#10; begin result := false; - StreamPos := Stream.Position; - Stream.Read(Header[0], SizeOf(Header)); - Stream.Position := StreamPos; + StreamPos := aStream.Position; + aStream.Read(Header[0], SizeOf(Header)); + aStream.Position := StreamPos; {Test if the header matches} if Header = PngHeader then begin Png := TPNGObject.Create; try - Png.LoadFromStream(Stream); + Png.LoadFromStream(aStream); case Png.Header.ColorType of COLOR_GRAYSCALE: - Format := ifLuminance; + PngFormat := tfLuminance8; COLOR_GRAYSCALEALPHA: - Format := ifLuminanceAlpha; + PngFormat := tfLuminance8Alpha8; COLOR_RGB: - Format := ifBGR8; + PngFormat := tfBGR8; COLOR_RGBALPHA: - Format := ifBGRA8; + PngFormat := tfBGRA8; else raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); end; - PixSize := Trunc(FormatGetSize(Format)); - LineSize := Integer(Png.Header.Width) * PixSize; + FormatDesc := TFormatDescriptor.Get(PngFormat); + PixSize := Round(FormatDesc.PixelSize); + LineSize := FormatDesc.GetSize(Png.Header.Width, 1); GetMem(NewImage, LineSize * Integer(Png.Header.Height)); try @@ -5510,11 +6475,12 @@ begin raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); end; - SetDataPointer(NewImage, Format, Png.Header.Width, Png.Header.Height); + SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); //be careful, Data could be freed by this method result := true; except - FreeMem(NewImage); + if Assigned(NewImage) then + FreeMem(NewImage); raise; end; finally @@ -5534,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 @@ -5544,27 +6532,30 @@ var LineSize: Integer; ColorType: Integer; Row: Integer; + FormatDesc: TFormatDescriptor; begin - if not (ftPNG in FormatGetSupportedFiles (InternalFormat)) then - raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT); + if not (ftPNG in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); if not init_libPNG then - raise Exception.Create('SavePNG - unable to initialize libPNG.'); + raise Exception.Create('unable to initialize libPNG.'); try - case FInternalFormat of - ifAlpha, ifLuminance, ifDepth8: + case Format of + tfAlpha8, tfLuminance8: ColorType := PNG_COLOR_TYPE_GRAY; - ifLuminanceAlpha: + tfLuminance8Alpha8: ColorType := PNG_COLOR_TYPE_GRAY_ALPHA; - ifBGR8, ifRGB8: + tfBGR8, tfRGB8: ColorType := PNG_COLOR_TYPE_RGB; - ifBGRA8, ifRGBA8: + tfBGRA8, tfRGBA8: ColorType := PNG_COLOR_TYPE_RGBA; else - raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); end; - LineSize := Trunc(FormatGetSize(FInternalFormat) * Width); + + FormatDesc := TFormatDescriptor.Get(Format); + LineSize := FormatDesc.GetSize(Width, 1); // creating array for scanline SetLength(png_rows, Height); @@ -5587,12 +6578,12 @@ begin end; // set read callback - png_set_write_fn(png, stream, glBitmap_libPNG_write_func, nil); + png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil); // set compression png_set_compression_level(png, 6); - if InternalFormat in [ifBGR8, ifBGRA8] then + if Format in [tfBGR8, tfBGRA8] then png_set_bgr(png); png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); @@ -5622,32 +6613,32 @@ var pTemp: pByte; Temp: Byte; begin - if not (ftPNG in FormatGetSupportedFiles (InternalFormat)) then - raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT); + if not (ftPNG in FormatGetSupportedFiles (Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); - case FInternalFormat of - ifAlpha, ifLuminance, ifDepth8: begin + case Format of + tfAlpha8, tfLuminance8: begin ColorType := COLOR_GRAYSCALE; - PixSize := 1; - Alpha := false; + PixSize := 1; + Alpha := false; end; - ifLuminanceAlpha: begin + tfLuminance8Alpha8: begin ColorType := COLOR_GRAYSCALEALPHA; - PixSize := 1; - Alpha := true; + PixSize := 1; + Alpha := true; end; - ifBGR8, ifRGB8: begin + tfBGR8, tfRGB8: begin ColorType := COLOR_RGB; - PixSize := 3; - Alpha := false; + PixSize := 3; + Alpha := false; end; - ifBGRA8, ifRGBA8: begin + tfBGRA8, tfRGBA8: begin ColorType := COLOR_RGBALPHA; - PixSize := 3; - Alpha := true + PixSize := 3; + Alpha := true end; else - raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); end; Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height); @@ -5667,7 +6658,7 @@ begin end; // convert RGB line to BGR - if InternalFormat in [ifRGB8, ifRGBA8] then begin + if Format in [tfRGB8, tfRGBA8] then begin pTemp := png.ScanLine[Y]; for X := 0 to Width -1 do begin Temp := pByteArray(pTemp)^[0]; @@ -5680,7 +6671,7 @@ begin // Save to Stream Png.CompressionLevel := 6; - Png.SaveToStream(Stream); + Png.SaveToStream(aStream); finally FreeAndNil(Png); end; @@ -5709,39 +6700,34 @@ type DestBuffer: array [1..4096] of byte; end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{ procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl; -var - Msg: String; begin - SetLength(Msg, 256); - cinfo^.err^.format_message(cinfo, pChar(Msg)); - Writeln('ERROR [' + IntToStr(cinfo^.err^.msg_code) + '] ' + Msg); - cinfo^.global_state := 0; - jpeg_abort(cinfo); + //DUMMY end; -} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{ + procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl; -var - Msg: String; begin - SetLength(Msg, 256); - cinfo^.err^.format_message(cinfo, pChar(Msg)); - Writeln('OUTPUT [' + IntToStr(cinfo^.err^.msg_code) + '] ' + Msg); - cinfo^.global_state := 0; + //DUMMY end; -} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{ + procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl; begin + //DUMMY +end; + +procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl; +begin + //DUMMY +end; + + +procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl; +begin + //DUMMY end; -} + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl; @@ -5785,20 +6771,6 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{ -procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl; -begin -end; -} - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{ -procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl; -begin -end; -} - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl; var dest: glBitmap_libJPEG_dest_mgr_ptr; @@ -5840,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 @@ -5849,7 +6861,7 @@ var begin result := false; - RWops := glBitmapCreateRWops(Stream); + RWops := glBitmapCreateRWops(aStream); try if IMG_isJPG(RWops) > 0 then begin Surface := IMG_LoadJPG_RW(RWops); @@ -5875,12 +6887,14 @@ var jpeg: jpeg_decompress_struct; jpeg_err: jpeg_error_mgr; - IntFormat: TglBitmapInternalFormat; + IntFormat: TglBitmapFormat; pImage: pByte; TempHeight, TempWidth: Integer; pTemp: pByte; Row: Integer; + + FormatDesc: TFormatDescriptor; begin result := false; @@ -5889,18 +6903,18 @@ begin try // reading first two bytes to test file and set cursor back to begin - StreamPos := Stream.Position; - Stream.Read(Temp[0], 2); - Stream.Position := StreamPos; + StreamPos := aStream.Position; + aStream.Read({%H-}Temp[0], 2); + aStream.Position := StreamPos; // if Bitmap then read file. if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin - FillChar(jpeg, SizeOf(jpeg_decompress_struct), $00); - FillChar(jpeg_err, SizeOf(jpeg_error_mgr), $00); + FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00); + FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); // error managment jpeg.err := jpeg_std_error(@jpeg_err); - jpeg_err.error_exit := glBitmap_libJPEG_error_exit; + jpeg_err.error_exit := glBitmap_libJPEG_error_exit; jpeg_err.output_message := glBitmap_libJPEG_output_message; // decompression struct @@ -5920,7 +6934,7 @@ begin pub.bytes_in_buffer := 0; // forces fill_input_buffer on first read pub.next_input_byte := nil; // until buffer loaded - SrcStream := Stream; + SrcStream := aStream; end; // set global decoding state @@ -5934,11 +6948,11 @@ begin JCS_GRAYSCALE: begin jpeg.out_color_space := JCS_GRAYSCALE; - IntFormat := ifLuminance; + IntFormat := tfLuminance8; end; else jpeg.out_color_space := JCS_RGB; - IntFormat := ifRGB8; + IntFormat := tfRGB8; end; // reading image @@ -5947,14 +6961,16 @@ begin TempHeight := jpeg.output_height; TempWidth := jpeg.output_width; + FormatDesc := TFormatDescriptor.Get(IntFormat); + // creating new image - GetMem(pImage, FormatGetImageSize(glBitmapPosition(TempWidth, TempHeight), IntFormat)); + GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight)); try pTemp := pImage; for Row := 0 to TempHeight -1 do begin jpeg_read_scanlines(@jpeg, @pTemp, 1); - Inc(pTemp, Trunc(FormatGetSize(IntFormat) * TempWidth)); + Inc(pTemp, FormatDesc.GetSize(TempWidth, 1)); end; // finish decompression @@ -5963,11 +6979,12 @@ begin // destroy decompression jpeg_destroy_decompress(@jpeg); - SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); + SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method result := true; except - FreeMem(pImage); + if Assigned(pImage) then + FreeMem(pImage); raise; end; end; @@ -5988,9 +7005,9 @@ begin result := false; // reading first two bytes to test file and set cursor back to begin - StreamPos := Stream.Position; - Stream.Read(Temp[0], 2); - Stream.Position := StreamPos; + StreamPos := aStream.Position; + aStream.Read(Temp[0], 2); + aStream.Position := StreamPos; // if Bitmap then read file. if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin @@ -5998,7 +7015,7 @@ begin try jpg := TJPEGImage.Create; try - jpg.LoadFromStream(Stream); + jpg.LoadFromStream(aStream); bmp.Assign(jpg); result := AssignFromBitmap(bmp); finally @@ -6013,9 +7030,31 @@ end; {$ENDIF} {$IFDEF GLB_SUPPORT_JPEG_WRITE} -{$IF DEFEFINED(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(Stream: TStream); +procedure TglBitmap.SaveJPEG(const aStream: TStream); var jpeg: jpeg_compress_struct; jpeg_err: jpeg_error_mgr; @@ -6037,18 +7076,18 @@ var begin if not (ftJPEG in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedInternalFormat.Create('SaveJpg - ' + UNSUPPORTED_INTERNAL_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); if not init_libJPEG then raise Exception.Create('SaveJPG - unable to initialize libJPEG.'); try - FillChar(jpeg, SizeOf(jpeg_compress_struct), $00); - FillChar(jpeg_err, SizeOf(jpeg_error_mgr), $00); + FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00); + FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); // error managment jpeg.err := jpeg_std_error(@jpeg_err); - jpeg_err.error_exit := glBitmap_libJPEG_error_exit; + jpeg_err.error_exit := glBitmap_libJPEG_error_exit; jpeg_err.output_message := glBitmap_libJPEG_output_message; // compression struct @@ -6066,21 +7105,21 @@ begin pub.next_output_byte := @DestBuffer[1]; pub.free_in_buffer := Length(DestBuffer); - DestStream := Stream; + DestStream := aStream; end; // very important state jpeg.global_state := CSTATE_START; jpeg.image_width := Width; jpeg.image_height := Height; - case InternalFormat of - ifAlpha, ifLuminance, ifDepth8: begin + case Format of + tfAlpha8, tfLuminance8: begin jpeg.input_components := 1; - jpeg.in_color_space := JCS_GRAYSCALE; + jpeg.in_color_space := JCS_GRAYSCALE; end; - ifRGB8, ifBGR8: begin + tfRGB8, tfBGR8: begin jpeg.input_components := 3; - jpeg.in_color_space := JCS_RGB; + jpeg.in_color_space := JCS_RGB; end; end; @@ -6089,7 +7128,7 @@ begin jpeg_start_compress(@jpeg, true); pTemp := Data; - if InternalFormat = ifBGR8 then + if Format = tfBGR8 then GetMem(pTemp2, fRowSize) else pTemp2 := pTemp; @@ -6097,7 +7136,7 @@ begin try for Row := 0 to jpeg.image_height -1 do begin // prepare row - if InternalFormat = ifBGR8 then + if Format = tfBGR8 then CopyRow(pTemp2, pTemp) else pTemp2 := pTemp; @@ -6108,7 +7147,7 @@ begin end; finally // free memory - if InternalFormat = ifBGR8 then + if Format = tfBGR8 then FreeMem(pTemp2); end; jpeg_finish_compress(@jpeg); @@ -6120,25 +7159,25 @@ end; {$ELSEIF DEFINED(GLB_DELPHI_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveJPEG(Stream: TStream); +procedure TglBitmap.SaveJPEG(const aStream: TStream); var Bmp: TBitmap; Jpg: TJPEGImage; begin - if not (ftJPEG in FormatGetSupportedFiles (InternalFormat)) then - raise EglBitmapUnsupportedInternalFormat.Create('SaveJpg - ' + UNSUPPORTED_INTERNAL_FORMAT); + if not (ftJPEG in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); Bmp := TBitmap.Create; try Jpg := TJPEGImage.Create; try AssignToBitmap(Bmp); - if FInternalFormat in [ifAlpha, ifLuminance, ifDepth8] then begin - Jpg.Grayscale := true; + if (Format in [tfAlpha8, tfLuminance8]) then begin + Jpg.Grayscale := true; Jpg.PixelFormat := jf8Bit; end; Jpg.Assign(Bmp); - Jpg.SaveToStream(Stream); + Jpg.SaveToStream(aStream); finally FreeAndNil(Jpg); end; @@ -6146,7 +7185,7 @@ begin FreeAndNil(Bmp); end; end; -{$ENDIF} +{$IFEND} {$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -6187,17 +7226,17 @@ type function TglBitmap.LoadBMP(const aStream: TStream): Boolean; ////////////////////////////////////////////////////////////////////////////////////////////////// - function ReadInfo(var aInfo: TBMPInfo; var aMask: TglBitmapColorRec): TglBitmapFormat; + function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapColorRec): TglBitmapFormat; begin result := tfEmpty; - aStream.Read(aInfo, SizeOf(aInfo)); - FillChar(aMask, SizeOf(aMask), 0); + aStream.Read(aInfo{%H-}, SizeOf(aInfo)); + FillChar(aMask{%H-}, SizeOf(aMask), 0); //Read Compression 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 @@ -6206,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; @@ -6283,7 +7322,6 @@ var LineBuf, ImageData, TmpData: PByte; SourceMD, DestMD: Pointer; BmpFormat: TglBitmapFormat; - ColorTable: TbmpColorTable; //records Mask: TglBitmapColorRec; @@ -6297,23 +7335,14 @@ var ////////////////////////////////////////////////////////////////////////////////////////////////// procedure SpecialFormatReadLine(aData: PByte; aLineBuf: PByte); var - i, j: Integer; + i: Integer; Pixel: TglBitmapPixelData; begin aStream.Read(aLineBuf^, rbLineSize); SpecialFormat.PreparePixel(Pixel); for i := 0 to Info.biWidth-1 do begin SpecialFormat.Unmap(aLineBuf, Pixel, SourceMD); - with FormatDesc do begin - //TODO: use convert function - for j := 0 to 3 do - if (SpecialFormat.Range.arr[j] <> Range.arr[j]) then begin - if (SpecialFormat.Range.arr[j] > 0) then - Pixel.Data.arr[j] := Round(Pixel.Data.arr[j] / SpecialFormat.Range.arr[j] * Range.arr[j]) - else - Pixel.Data.arr[j] := 0; - end; - end; + glBitmapConvertPixel(Pixel, SpecialFormat, FormatDesc); FormatDesc.Map(Pixel, aData, DestMD); end; end; @@ -6328,7 +7357,7 @@ begin // Header StartPos := aStream.Position; - aStream.Read(Header, SizeOf(Header)); + aStream.Read(Header{%H-}, SizeOf(Header)); if Header.bfType = BMP_MAGIC then begin try try @@ -6368,9 +7397,9 @@ begin dec(TmpData, wbLineSize) else inc(TmpData, wbLineSize); - aStream.Read(PaddingBuff, Padding); + aStream.Read(PaddingBuff{%H-}, Padding); end; - SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); + SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); //be careful, Data could be freed by this method result := true; finally if Assigned(LineBuf) then @@ -6380,11 +7409,12 @@ begin FormatDesc.FreeMappingData(DestMD); end; except - FreeMem(ImageData); + if Assigned(ImageData) then + FreeMem(ImageData); 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; @@ -6401,14 +7431,13 @@ 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; Pixel: TglBitmapPixelData; - PixelFormat: TglBitmapPixelData; - ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx, i: Integer; + ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx: Integer; RedMask, GreenMask, BlueMask, AlphaMask: Cardinal; PaddingBuff: Cardinal; @@ -6420,20 +7449,20 @@ var begin if not (ftBMP in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); Converter := nil; FormatDesc := TFormatDescriptor.Get(Format); ImageSize := FormatDesc.GetSize(Dimension); - FillChar(Header, SizeOf(Header), 0); + FillChar(Header{%H-}, SizeOf(Header), 0); Header.bfType := BMP_MAGIC; Header.bfSize := SizeOf(Header) + SizeOf(Info) + ImageSize; Header.bfReserved1 := 0; Header.bfReserved2 := 0; Header.bfOffBits := SizeOf(Header) + SizeOf(Info); - FillChar(Info, SizeOf(Info), 0); + FillChar(Info{%H-}, SizeOf(Info), 0); Info.biSize := SizeOf(Info); Info.biWidth := Width; Info.biHeight := Height; @@ -6447,45 +7476,51 @@ 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; else - raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); end; Info.biXPelsPerMeter := 2835; Info.biYPelsPerMeter := 2835; @@ -6506,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 @@ -6545,16 +7581,7 @@ begin dstData := ConvertBuffer; for PixelIdx := 0 to Info.biWidth-1 do begin FormatDesc.Unmap(srcData, Pixel, SourceFD); - with FormatDesc do begin - //TODO use convert function - for i := 0 to 3 do - if (Converter.Range.arr[i] <> Range.arr[i]) then begin - if (Range.arr[i] > 0) then - Pixel.Data.arr[i] := Round(Pixel.Data.arr[i] / Range.arr[i] * Converter.Range.arr[i]) - else - Pixel.Data.arr[i] := 0; - end; - end; + glBitmapConvertPixel(Pixel, FormatDesc, Converter); Converter.Map(Pixel, dstData, DestFD); end; aStream.Write(ConvertBuffer^, wbLineSize); @@ -6600,21 +7627,18 @@ type end; const - TGA_UNCOMPRESSED_COLOR_TABLE = 1; - TGA_UNCOMPRESSED_RGB = 2; - TGA_UNCOMPRESSED_GRAY = 3; - TGA_COMPRESSED_COLOR_TABLE = 9; - TGA_COMPRESSED_RGB = 10; - TGA_COMPRESSED_GRAY = 11; + TGA_UNCOMPRESSED_RGB = 2; + TGA_UNCOMPRESSED_GRAY = 3; + TGA_COMPRESSED_RGB = 10; + TGA_COMPRESSED_GRAY = 11; - TGA_NONE_COLOR_TABLE = 0; - TGA_COLOR_TABLE = 1; + TGA_NONE_COLOR_TABLE = 0; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.LoadTGA(const aStream: TStream): Boolean; var Header: TTGAHeader; - ImageData: PByte; + ImageData: System.PByte; StartPosition: Int64; PixelSize, LineSize: Integer; tgaFormat: TglBitmapFormat; @@ -6632,17 +7656,19 @@ const procedure ReadUncompressed; var i, j: Integer; - buf, tmp1, tmp2: PByte; + buf, tmp1, tmp2: System.PByte; begin buf := nil; if (Counter.X.dir < 0) then - buf := GetMem(LineSize); + GetMem(buf, LineSize); try while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin - tmp1 := ImageData + (Counter.Y.low * LineSize); //pointer to LineStart + tmp1 := ImageData; + inc(tmp1, (Counter.Y.low * LineSize)); //pointer to LineStart if (Counter.X.dir < 0) then begin //flip X aStream.Read(buf^, LineSize); - tmp2 := buf + LineSize - PixelSize; //pointer to last pixel in line + tmp2 := buf; + inc(tmp2, LineSize - PixelSize); //pointer to last pixel in line for i := 0 to Header.Width-1 do begin //for all pixels in line for j := 0 to PixelSize-1 do begin //for all bytes in pixel tmp1^ := tmp2^; @@ -6666,16 +7692,17 @@ const ///////////////////////////////////////////////////////////////// var - TmpData: PByte; + TmpData: System.PByte; LinePixelsRead: Integer; procedure CheckLine; begin if (LinePixelsRead >= Header.Width) then begin LinePixelsRead := 0; inc(Counter.Y.low, Counter.Y.dir); //next line index - TmpData := ImageData + Counter.Y.low * LineSize; //set line + TmpData := ImageData; + inc(TmpData, Counter.Y.low * LineSize); //set line if (Counter.X.dir < 0) then //if x flipped then - TmpData := TmpData + LineSize - PixelSize; //set last pixel + inc(TmpData, LineSize - PixelSize); //set last pixel end; end; @@ -6692,7 +7719,7 @@ const BytesRead := 0; if (CacheSize - CachePos > 0) then begin BytesRead := CacheSize - CachePos; - Move(PByteArray(Cache)^[CachePos], Buffer, BytesRead); + Move(PByteArray(Cache)^[CachePos], Buffer{%H-}, BytesRead); inc(CachePos, BytesRead); end; @@ -6753,9 +7780,10 @@ const GetMem(Cache, CACHE_SIZE); try - TmpData := ImageData + Counter.Y.low * LineSize; //set line + TmpData := ImageData; + inc(TmpData, Counter.Y.low * LineSize); //set line if (Counter.X.dir < 0) then //if x flipped then - TmpData := TmpData + LineSize - PixelSize; //set last pixel + inc(TmpData, LineSize - PixelSize); //set last pixel repeat //read CommandByte @@ -6794,7 +7822,7 @@ begin // reading header to test file and set cursor back to begin StartPosition := aStream.Position; - aStream.Read(Header, SizeOf(Header)); + aStream.Read(Header{%H-}, SizeOf(Header)); // no colormapped files if (Header.ColorMapType = TGA_NONE_COLOR_TABLE) and (Header.ImageType in [ @@ -6804,6 +7832,7 @@ begin if Header.ImageID <> 0 then // skip image ID aStream.Position := aStream.Position + Header.ImageID; + tgaFormat := tfEmpty; case Header.Bpp of 8: if IsGrayFormat then case (Header.ImageDesc and $F) of 0: tgaFormat := tfLuminance8; @@ -6814,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); @@ -6868,10 +7897,11 @@ begin ReadCompressed; end; - SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); + SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); //be careful, Data could be freed by this method result := true; except - FreeMem(ImageData); + if Assigned(ImageData) then + FreeMem(ImageData); raise; end; finally @@ -6893,10 +7923,10 @@ var Converter: TFormatDescriptor; begin if not (ftTGA in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedFormatFormat.Create('SaveTGA - ' + UNSUPPORTED_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); //prepare header - FillChar(Header, SizeOf(Header), 0); + FillChar(Header{%H-}, SizeOf(Header), 0); //set ImageType if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8, @@ -6909,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 @@ -6937,18 +7967,18 @@ 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 LineSize := FormatDesc.GetSize(Width, 1); - LineBuf := GetMem(LineSize); + GetMem(LineBuf, LineSize); SourceMD := FormatDesc.CreateMappingData; DestMD := Converter.CreateMappingData; try @@ -6974,39 +8004,26 @@ end; //DDS///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// const - DDS_MAGIC = $20534444; + DDS_MAGIC: Cardinal = $20534444; // DDS_header.dwFlags DDSD_CAPS = $00000001; DDSD_HEIGHT = $00000002; DDSD_WIDTH = $00000004; - DDSD_PITCH = $00000008; DDSD_PIXELFORMAT = $00001000; - DDSD_MIPMAPCOUNT = $00020000; - DDSD_LINEARSIZE = $00080000; - DDSD_DEPTH = $00800000; // DDS_header.sPixelFormat.dwFlags DDPF_ALPHAPIXELS = $00000001; + DDPF_ALPHA = $00000002; DDPF_FOURCC = $00000004; - DDPF_INDEXED = $00000020; DDPF_RGB = $00000040; DDPF_LUMINANCE = $00020000; // DDS_header.sCaps.dwCaps1 - DDSCAPS_COMPLEX = $00000008; DDSCAPS_TEXTURE = $00001000; - DDSCAPS_MIPMAP = $00400000; // DDS_header.sCaps.dwCaps2 DDSCAPS2_CUBEMAP = $00000200; - DDSCAPS2_CUBEMAP_POSITIVEX = $00000400; - DDSCAPS2_CUBEMAP_NEGATIVEX = $00000800; - DDSCAPS2_CUBEMAP_POSITIVEY = $00001000; - DDSCAPS2_CUBEMAP_NEGATIVEY = $00002000; - DDSCAPS2_CUBEMAP_POSITIVEZ = $00004000; - DDSCAPS2_CUBEMAP_NEGATIVEZ = $00008000; - DDSCAPS2_VOLUME = $00200000; D3DFMT_DXT1 = $31545844; D3DFMT_DXT3 = $33545844; @@ -7032,7 +8049,6 @@ type end; TDDSHeader = packed record - dwMagic: Cardinal; dwSize: Cardinal; dwFlags: Cardinal; dwHeight: Cardinal; @@ -7050,8 +8066,14 @@ type function TglBitmap.LoadDDS(const aStream: TStream): Boolean; var Header: TDDSHeader; + Converter: TbmpBitfieldFormat; function GetDDSFormat: TglBitmapFormat; + var + fd: TFormatDescriptor; + i: Integer; + Range: TglBitmapColorRec; + match: Boolean; begin result := tfEmpty; with Header.PixelFormat do begin @@ -7062,168 +8084,326 @@ var D3DFMT_DXT3: result := tfS3tcDtx3RGBA; D3DFMT_DXT5: result := tfS3tcDtx5RGBA; end; - end else - - // RGB - if (dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin - case dwRGBBitCount of - 8: begin - if ((dwFlags and DDPF_ALPHAPIXELS) > 0) then - result := tfAlpha8 - else if ((dwFlags and DDPF_LUMINANCE) > 0) then - result := tfLuminance8; - end; + 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(Range.r, Range.g, Range.b, Range.a) and + (8 * fd.PixelSize = dwRGBBitCount) then + exit; + end; - 16: begin - if ((dwFlags and DDPF_ALPHAPIXELS) > 0) then begin - case CountSetBits(dwRBitMask) of - 5: result := tfRGB5A1; - 4: result := tfRGBA4; - else - result := tfLuminance8Alpha8; - end; - end else if (CountSetBits(dwGBitMask) = 6) then - result := tfR5G6B5 - else - result := tfRGB5; - end; + //find format with same Range + 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; + end; + for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + fd := TFormatDescriptor.Get(result); + match := true; + for i := 0 to 3 do + if (fd.Range.arr[i] <> Range.arr[i]) then begin + match := false; + break; + end; + if match then + break; + end; - 24: begin + //no format with same range found -> use default + if (result = tfEmpty) then begin + if (dwABitMask > 0) then + result := tfRGBA8 + else result := tfRGB8; - end; + end; - 32: begin - if CountSetBits(dwRBitMask) = 10 then - result := tfRGB10A2 - else - result := tfRGBA8; + Converter := TbmpBitfieldFormat.Create; + Converter.RedMask := dwRBitMask; + Converter.GreenMask := dwGBitMask; + Converter.BlueMask := dwBBitMask; + Converter.AlphaMask := dwABitMask; + Converter.PixelSize := dwRGBBitCount / 8; + end; + end; + end; + +var + StreamPos: Int64; + x, y, LineSize, RowSize, Magic: Cardinal; + NewImage, TmpData, RowData, SrcData: System.PByte; + SourceMD, DestMD: Pointer; + Pixel: TglBitmapPixelData; + ddsFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; + +begin + result := false; + Converter := nil; + StreamPos := aStream.Position; + + // Magic + aStream.Read(Magic{%H-}, sizeof(Magic)); + if (Magic <> DDS_MAGIC) then begin + aStream.Position := StreamPos; + exit; + end; + + //Header + aStream.Read(Header{%H-}, sizeof(Header)); + if (Header.dwSize <> SizeOf(Header)) or + ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <> + (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then + begin + aStream.Position := StreamPos; + exit; + end; + + if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then + raise EglBitmap.Create('LoadDDS - CubeMaps are not supported'); + + ddsFormat := GetDDSFormat; + try + if (ddsFormat = tfEmpty) then + raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); + + FormatDesc := TFormatDescriptor.Get(ddsFormat); + LineSize := Trunc(Header.dwWidth * FormatDesc.PixelSize); + GetMem(NewImage, Header.dwHeight * LineSize); + try + TmpData := NewImage; + + //Converter needed + if Assigned(Converter) then begin + RowSize := Round(Header.dwWidth * Header.PixelFormat.dwRGBBitCount / 8); + GetMem(RowData, RowSize); + SourceMD := Converter.CreateMappingData; + DestMD := FormatDesc.CreateMappingData; + try + for y := 0 to Header.dwHeight-1 do begin + TmpData := NewImage; + inc(TmpData, y * LineSize); + SrcData := RowData; + aStream.Read(SrcData^, RowSize); + for x := 0 to Header.dwWidth-1 do begin + Converter.Unmap(SrcData, Pixel, SourceMD); + glBitmapConvertPixel(Pixel, Converter, FormatDesc); + FormatDesc.Map(Pixel, TmpData, DestMD); + end; end; + finally + Converter.FreeMappingData(SourceMD); + FormatDesc.FreeMappingData(DestMD); + FreeMem(RowData); + end; + end else + + // Compressed + if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin + RowSize := Header.dwPitchOrLinearSize div Header.dwWidth; + for Y := 0 to Header.dwHeight-1 do begin + aStream.Read(TmpData^, RowSize); + Inc(TmpData, LineSize); + end; + end else + + // Uncompressed + if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin + RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3; + for Y := 0 to Header.dwHeight-1 do begin + aStream.Read(TmpData^, RowSize); + Inc(TmpData, LineSize); end; + end else + 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; + except + if Assigned(NewImage) then + FreeMem(NewImage); + raise; + end; + finally + FreeAndNil(Converter); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SaveDDS(const aStream: TStream); +var + Header: TDDSHeader; + FormatDesc: TFormatDescriptor; +begin + if not (ftDDS in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); + + FormatDesc := TFormatDescriptor.Get(Format); + + // Generell + FillChar(Header{%H-}, SizeOf(Header), 0); + Header.dwSize := SizeOf(Header); + Header.dwFlags := DDSD_WIDTH or DDSD_HEIGHT or DDSD_CAPS or DDSD_PIXELFORMAT; + + Header.dwWidth := Max(1, Width); + Header.dwHeight := Max(1, Height); + + // Caps + Header.Caps.dwCaps1 := DDSCAPS_TEXTURE; + + // Pixelformat + Header.PixelFormat.dwSize := sizeof(Header); + if (FormatDesc.IsCompressed) then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_FOURCC; + case Format of + tfS3tcDtx1RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT1; + tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3; + tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5; + end; + end else if (Format in [tfAlpha8, tfAlpha16]) then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA; + Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); + Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + end else if (FormatDesc.RedMask = FormatDesc.GreenMask) and (FormatDesc.GreenMask = FormatDesc.BlueMask) then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE; + Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); + Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; + Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + end else begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB; + Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); + Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; + Header.PixelFormat.dwGBitMask := FormatDesc.GreenMask; + Header.PixelFormat.dwBBitMask := FormatDesc.BlueMask; + Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + end; + + if (FormatDesc.HasAlpha) then + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS; + + aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC)); + aStream.Write(Header, SizeOf(Header)); + aStream.Write(Data^, FormatDesc.GetSize(Dimension)); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap1D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer; const aHeight: Integer); +var + pTemp: pByte; + Size: Integer; +begin + if (aHeight > 1) then begin + Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1); + GetMem(pTemp, Size); + try + Move(aData^, pTemp^, Size); + FreeMem(aData); + aData := nil; + except + FreeMem(pTemp); + raise; + end; + end else + pTemp := aData; + inherited SetDataPointer(pTemp, aFormat, aWidth); +end; - if (dwRBitMask <> 0) and (dwBBitMask <> 0) and (dwRBitMask > dwBBitMask) then - result := TFormatDescriptor.Get(result).RGBInverted; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap1D.FlipHorz: Boolean; +var + Col: Integer; + pTempDest, pDest, pSource: PByte; +begin + result := inherited FlipHorz; + if Assigned(Data) and not TFormatDescriptor.Get(Format).IsCompressed then begin + pSource := Data; + GetMem(pDest, fRowSize); + try + pTempDest := pDest; + Inc(pTempDest, fRowSize); + for Col := 0 to Width-1 do begin + dec(pTempDest, fPixelSize); //dec before, because ptr is behind last byte of data + Move(pSource^, pTempDest^, fPixelSize); + Inc(pSource, fPixelSize); end; + SetDataPointer(pDest, Format, Width); //be careful, Data could be freed by this method + result := true; + except + if Assigned(pDest) then + FreeMem(pDest); + raise; end; end; +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.UploadData(const aBuildWithGlu: Boolean); var - StreamPos: Int64; - Y, LineSize: Cardinal; - RowSize: Cardinal; - NewImage, TmpData: PByte; - ddsFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; - begin - result := false; - - // Header - StreamPos := aStream.Position; - aStream.Read(Header, sizeof(Header)); - - if (Header.dwMagic <> DDS_MAGIC) or (Header.dwSize <> 124) or - ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <> - (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then - begin - aStream.Position := StreamPos; - exit; - end; - - if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then - raise EglBitmapException.Create('LoadDDS - CubeMaps are not supported'); - - ddsFormat := GetDDSFormat; - if (ddsFormat = tfEmpty) then - raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.'); - - FormatDesc := TFormatDescriptor.Get(ddsFormat); - LineSize := Trunc(Header.dwWidth * FormatDesc.PixelSize); - GetMem(NewImage, Header.dwHeight * LineSize); - try - TmpData := NewImage; - - // Compressed - if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin - RowSize := Header.dwPitchOrLinearSize div Header.dwWidth; - for Y := 0 to Header.dwHeight-1 do begin - aStream.Read(TmpData^, RowSize); - Inc(TmpData, LineSize); - end; - end else - - // Uncompressed - if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin - RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3; - for Y := 0 to Header.dwHeight-1 do begin - aStream.Read(TmpData^, RowSize); - Inc(TmpData, LineSize); - end; - end else - raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.'); + // Upload data + FormatDesc := TFormatDescriptor.Get(Format); + 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) + 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); - SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); - result := true; - except - FreeMem(NewImage); - raise; - end; + // Free Data + if (FreeDataAfterGenTexture) then + FreeData; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveDDS(const aStream: TStream); +procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean); var - Header: TDDSHeader; - Pix: TglBitmapPixelData; - FormatDesc: TFormatDescriptor; + BuildWithGlu, TexRec: Boolean; + TexSize: Integer; begin - //if not FormatIsUncompressed(InternalFormat) then - // raise EglBitmapUnsupportedFormatFormat.Create('SaveDDS - ' + UNSUPPORTED_FORMAT); - - (* TODO if Format = tfAlpha8 then - FORMAT_DESCRIPTORS[tfLuminance8].PreparePixel(Pix); - else *) - TFormatDescriptor.Get(Format).PreparePixel(Pix); + if Assigned(Data) then begin + // Check Texture Size + if (aTestTextureSize) then begin + glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); - // Generell - FillChar(Header, SizeOf(Header), 0); - Header.dwMagic := DDS_MAGIC; - Header.dwSize := 124; - Header.dwFlags := DDSD_PITCH or DDSD_CAPS or DDSD_PIXELFORMAT; + if (Width > TexSize) then + raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.'); - if Width > 0 then begin - Header.dwWidth := Width; - Header.dwFlags := Header.dwFlags or DDSD_WIDTH; - end; + TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and + (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 EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.'); + end; - if Height > 0 then begin - Header.dwHeight := Height; - Header.dwFlags := Header.dwFlags or DDSD_HEIGHT; + CreateId; + SetupParameters(BuildWithGlu); + UploadData(BuildWithGlu); + glAreTexturesResident(1, @fID, @fIsResident); end; +end; - Header.dwPitchOrLinearSize := fRowSize; - Header.dwMipMapCount := 1; - - // Caps - Header.Caps.dwCaps1 := DDSCAPS_TEXTURE; - - // Pixelformat - Header.PixelFormat.dwSize := Sizeof(Header.PixelFormat); - Header.PixelFormat.dwFlags := DDPF_RGB; - - (* TODO tfAlpha8 - if FORMAT_DESCRIPTORS[Format].HasAlpha and (Format <> tfAlpha8) then - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS; - *) - - FormatDesc := TFormatDescriptor.Get(Format); - Header.PixelFormat.dwRGBBitCount := Trunc(FormatDesc.PixelSize * 8); - Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; - Header.PixelFormat.dwGBitMask := FormatDesc.GreenMask; - Header.PixelFormat.dwBBitMask := FormatDesc.BlueMask; - Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; - - aStream.Write(Header, SizeOf(Header)); - aStream.Write(Data^, FormatDesc.GetSize(Dimension)); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.AfterConstruction; +begin + inherited; + Target := GL_TEXTURE_1D; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -7238,7 +8418,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat; +procedure TglBitmap2D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer; const aHeight: Integer); var Idx, LineWidth: Integer; @@ -7246,16 +8426,12 @@ begin inherited SetDataPointer(aData, aFormat, aWidth, aHeight); if not TFormatDescriptor.Get(aFormat).IsCompressed then begin - (* TODO PixelFuncs - fGetPixelFunc := GetPixel2DUnmap; - fSetPixelFunc := SetPixel2DUnmap; - *) // Assigning Data if Assigned(Data) then begin SetLength(fLines, GetHeight); LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).PixelSize); - for Idx := 0 to GetHeight -1 do begin + for Idx := 0 to GetHeight-1 do begin fLines[Idx] := Data; Inc(fLines[Idx], Idx * LineWidth); end; @@ -7263,25 +8439,11 @@ begin else SetLength(fLines, 0); end else begin SetLength(fLines, 0); - (* - fSetPixelFunc := nil; - - case Format of - ifDXT1: - fGetPixelFunc := GetPixel2DDXT1; - ifDXT3: - fGetPixelFunc := GetPixel2DDXT3; - ifDXT5: - fGetPixelFunc := GetPixel2DDXT5; - else - fGetPixelFunc := nil; - end; - *) end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean); +procedure TglBitmap2D.UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); var FormatDesc: TFormatDescriptor; begin @@ -7289,7 +8451,9 @@ begin FormatDesc := TFormatDescriptor.Get(Format); if FormatDesc.IsCompressed then begin - glCompressedTexImage2D(Target, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) + 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, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) @@ -7317,9 +8481,9 @@ var Size, w, h: Integer; FormatDesc: TFormatDescriptor; begin - FormatDesc := TFormatDescriptor.Get(Format); + FormatDesc := TFormatDescriptor.Get(aFormat); if FormatDesc.IsCompressed then - raise EglBitmapUnsupportedFormatFormat.Create('TglBitmap2D.GrabScreen - ' + UNSUPPORTED_FORMAT); + raise EglBitmapUnsupportedFormat.Create(aFormat); w := aRight - aLeft; h := aBottom - aTop; @@ -7328,10 +8492,11 @@ begin try glPixelStorei(GL_PACK_ALIGNMENT, 1); glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp); - SetDataPointer(Temp, Format, w, h); + SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method FlipVert; except - FreeMem(Temp); + if Assigned(Temp) then + FreeMem(Temp); raise; end; end; @@ -7341,8 +8506,8 @@ procedure TglBitmap2D.GetDataFromTexture; var Temp: PByte; TempWidth, TempHeight: Integer; - TempType, TempIntFormat: Cardinal; - IntFormat, f: TglBitmapFormat; + TempIntFormat: GLint; + IntFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; begin Bind; @@ -7352,24 +8517,24 @@ 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 - if (TFormatDescriptor.Get(f).glInternalFormat = TempIntFormat) then begin - IntFormat := FormatDesc.Format; - break; - 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); - SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); + 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 - FreeMem(Temp); + if Assigned(Temp) then + FreeMem(Temp); raise; end; end; @@ -7386,13 +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_ARB); - + 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; @@ -7425,10 +8589,11 @@ begin Dec(TempDestData, fPixelSize); end; end; - SetDataPointer(DestData, Format); + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method result := true; except - FreeMem(DestData); + if Assigned(DestData) then + FreeMem(DestData); raise; end; end; @@ -7452,10 +8617,11 @@ begin Dec(TempDestData, fRowSize); Inc(SourceData, fRowSize); end; - SetDataPointer(DestData, Format); + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method result := true; except - FreeMem(DestData); + if Assigned(DestData) then + FreeMem(DestData); raise; end; end; @@ -7567,10 +8733,8 @@ var end; begin - (* TODO Compression - if not FormatIsUncompressed(InternalFormat) then - raise EglBitmapUnsupportedFormatFormat.Create('TglBitmap2D.ToNormalMap - ' + UNSUPPORTED_FORMAT); - *) + if TFormatDescriptor.Get(Format).IsCompressed then + raise EglBitmapUnsupportedFormat.Create(Format); if aScale > 100 then Rec.Scale := 100 @@ -7677,237 +8841,89 @@ begin // Daten Sammeln if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then - AddFunc(glBitmapToNormalMapPrepareAlphaFunc, false, PtrInt(@Rec)) + AddFunc(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec) else - AddFunc(glBitmapToNormalMapPrepareFunc, false, PtrInt(@Rec)); - AddFunc(glBitmapToNormalMapFunc, false, PtrInt(@Rec)); + AddFunc(glBitmapToNormalMapPrepareFunc, false, @Rec); + AddFunc(glBitmapToNormalMapFunc, false, @Rec); finally SetLength(Rec.Heights, 0); end; end; - - - - - - - - -(* -procedure TglBitmap1D.SetDataPointer(Data: pByte; Format: TglBitmapInternalFormat; Width, Height: Integer); -var - pTemp: pByte; - Size: Integer; -begin - if Height > 1 then begin - // extract first line of the data - Size := FormatGetImageSize(glBitmapPosition(Width), Format); - GetMem(pTemp, Size); - - Move(Data^, pTemp^, Size); - - FreeMem(Data); - end else - pTemp := Data; - - // set data pointer - inherited SetDataPointer(pTemp, Format, Width); - - if FormatIsUncompressed(Format) then begin - fUnmapFunc := FormatGetUnMapFunc(Format); - fGetPixelFunc := GetPixel1DUnmap; - end; -end; - - -procedure TglBitmap1D.GetPixel1DUnmap(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); -var - pTemp: pByte; -begin - pTemp := Data; - Inc(pTemp, Pos.X * fPixelSize); - - fUnmapFunc(pTemp, Pixel); -end; - - -function TglBitmap1D.FlipHorz: Boolean; -var - Col: Integer; - pTempDest, pDest, pSource: pByte; -begin - result := inherited FlipHorz; - - if Assigned(Data) and FormatIsUncompressed(InternalFormat) then begin - pSource := Data; - - GetMem(pDest, fRowSize); - try - pTempDest := pDest; - - Inc(pTempDest, fRowSize); - for Col := 0 to Width -1 do begin - Move(pSource^, pTempDest^, fPixelSize); - - Inc(pSource, fPixelSize); - Dec(pTempDest, fPixelSize); - end; - - SetDataPointer(pDest, InternalFormat); - - result := true; - finally - FreeMem(pDest); - end; - end; -end; - - -procedure TglBitmap1D.UploadData (Target, Format, InternalFormat, Typ: Cardinal; BuildWithGlu: Boolean); -begin - // Upload data - if Self.InternalFormat in [ifDXT1, ifDXT3, ifDXT5] then - glCompressedTexImage1D(Target, 0, InternalFormat, Width, 0, Trunc(Width * FormatGetSize(Self.InternalFormat)), Data) - else - - // Upload data - if BuildWithGlu then - gluBuild1DMipmaps(Target, InternalFormat, Width, Format, Typ, Data) - else - glTexImage1D(Target, 0, InternalFormat, Width, 0, Format, Typ, Data); - - // Freigeben - if (FreeDataAfterGenTexture) then - FreeData; -end; - - -procedure TglBitmap1D.GenTexture(TestTextureSize: Boolean); -var - BuildWithGlu, TexRec: Boolean; - glFormat, glInternalFormat, glType: Cardinal; - TexSize: Integer; -begin - if Assigned(Data) then begin - // Check Texture Size - if (TestTextureSize) then 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.'); - - TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and - (Target = GL_TEXTURE_RECTANGLE_ARB); - - 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.'); - end; - - CreateId; - - SetupParameters(BuildWithGlu); - SelectFormat(InternalFormat, glFormat, glInternalFormat, glType); - - UploadData(Target, glFormat, glInternalFormat, glType, BuildWithGlu); - - // Infos sammeln - glAreTexturesResident(1, @fID, @fIsResident); - end; -end; - - -procedure TglBitmap1D.AfterConstruction; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapCubeMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean); begin - inherited; - - Target := GL_TEXTURE_1D; + Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); end; - -{ TglBitmapCubeMap } - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmapCubeMap.AfterConstruction; 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; // set all to GL_CLAMP_TO_EDGE - Target := GL_TEXTURE_CUBE_MAP; + SetWrap; + Target := GL_TEXTURE_CUBE_MAP; fGenMode := GL_REFLECTION_MAP; end; - -procedure TglBitmapCubeMap.Bind(EnableTexCoordsGen, EnableTextureUnit: Boolean); -begin - inherited Bind (EnableTextureUnit); - - if EnableTexCoordsGen then begin - glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode); - glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode); - glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode); - glEnable(GL_TEXTURE_GEN_S); - glEnable(GL_TEXTURE_GEN_T); - glEnable(GL_TEXTURE_GEN_R); - end; -end; - - -procedure TglBitmapCubeMap.GenerateCubeMap(CubeTarget: Cardinal; TestTextureSize: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean); var - glFormat, glInternalFormat, glType: Cardinal; BuildWithGlu: Boolean; TexSize: Integer; begin - // Check Texture Size - if (TestTextureSize) then begin + if (aTestTextureSize) then 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.'); + if (Height > TexSize) or (Width > TexSize) then + 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.'); + if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then + raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.'); end; - // create Texture - if ID = 0 then begin + if (ID = 0) then CreateID; - SetupParameters(BuildWithGlu); - end; - - SelectFormat(InternalFormat, glFormat, glInternalFormat, glType); - - UploadData (CubeTarget, glFormat, glInternalFormat, glType, BuildWithGlu); + SetupParameters(BuildWithGlu); + UploadData(aCubeTarget, BuildWithGlu); end; - -procedure TglBitmapCubeMap.GenTexture(TestTextureSize: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Bind(const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean); begin - Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); + inherited Bind (aEnableTextureUnit); + if aEnableTexCoordsGen then begin + glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode); + glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode); + glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode); + glEnable(GL_TEXTURE_GEN_S); + glEnable(GL_TEXTURE_GEN_T); + glEnable(GL_TEXTURE_GEN_R); + end; end; - -procedure TglBitmapCubeMap.Unbind(DisableTexCoordsGen, - DisableTextureUnit: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Unbind(const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean); begin - inherited Unbind (DisableTextureUnit); - - if DisableTexCoordsGen then begin + inherited Unbind(aDisableTextureUnit); + if aDisableTexCoordsGen then begin glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); end; end; - -{ TglBitmapNormalMap } - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapNormalMap////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// type TVec = Array[0..2] of Single; - TglBitmapNormalMapGetVectorFunc = procedure (var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); + TglBitmapNormalMapGetVectorFunc = procedure (out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); PglBitmapNormalMapRec = ^TglBitmapNormalMapRec; TglBitmapNormalMapRec = record @@ -7915,62 +8931,63 @@ type Func: TglBitmapNormalMapGetVectorFunc; end; - -procedure glBitmapNormalMapPosX(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapNormalMapPosX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); begin - Vec[0] := HalfSize; - Vec[1] := - (Position.Y + 0.5 - HalfSize); - Vec[2] := - (Position.X + 0.5 - HalfSize); + aVec[0] := aHalfSize; + aVec[1] := - (aPosition.Y + 0.5 - aHalfSize); + aVec[2] := - (aPosition.X + 0.5 - aHalfSize); end; - -procedure glBitmapNormalMapNegX(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapNormalMapNegX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); begin - Vec[0] := - HalfSize; - Vec[1] := - (Position.Y + 0.5 - HalfSize); - Vec[2] := Position.X + 0.5 - HalfSize; + aVec[0] := - aHalfSize; + aVec[1] := - (aPosition.Y + 0.5 - aHalfSize); + aVec[2] := aPosition.X + 0.5 - aHalfSize; end; - -procedure glBitmapNormalMapPosY(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapNormalMapPosY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); begin - Vec[0] := Position.X + 0.5 - HalfSize; - Vec[1] := HalfSize; - Vec[2] := Position.Y + 0.5 - HalfSize; + aVec[0] := aPosition.X + 0.5 - aHalfSize; + aVec[1] := aHalfSize; + aVec[2] := aPosition.Y + 0.5 - aHalfSize; end; - -procedure glBitmapNormalMapNegY(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapNormalMapNegY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); begin - Vec[0] := Position.X + 0.5 - HalfSize; - Vec[1] := - HalfSize; - Vec[2] := - (Position.Y + 0.5 - HalfSize); + aVec[0] := aPosition.X + 0.5 - aHalfSize; + aVec[1] := - aHalfSize; + aVec[2] := - (aPosition.Y + 0.5 - aHalfSize); end; - -procedure glBitmapNormalMapPosZ(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapNormalMapPosZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); begin - Vec[0] := Position.X + 0.5 - HalfSize; - Vec[1] := - (Position.Y + 0.5 - HalfSize); - Vec[2] := HalfSize; + aVec[0] := aPosition.X + 0.5 - aHalfSize; + aVec[1] := - (aPosition.Y + 0.5 - aHalfSize); + aVec[2] := aHalfSize; end; - -procedure glBitmapNormalMapNegZ(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapNormalMapNegZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); begin - Vec[0] := - (Position.X + 0.5 - HalfSize); - Vec[1] := - (Position.Y + 0.5 - HalfSize); - Vec[2] := - HalfSize; + aVec[0] := - (aPosition.X + 0.5 - aHalfSize); + aVec[1] := - (aPosition.Y + 0.5 - aHalfSize); + aVec[2] := - aHalfSize; end; - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glBitmapNormalMapFunc(var FuncRec: TglBitmapFunctionRec); var - Vec : TVec; + i: Integer; + Vec: TVec; Len: Single; begin with FuncRec do begin - with PglBitmapNormalMapRec (CustomData)^ do begin + with PglBitmapNormalMapRec(Args)^ do begin Func(Vec, Position, HalfSize); // Normalize @@ -7988,80 +9005,92 @@ begin end; // Set Color - Dest.Red := Round(Vec[0] * 255); - Dest.Green := Round(Vec[1] * 255); - Dest.Blue := Round(Vec[2] * 255); + for i := 0 to 2 do + Dest.Data.arr[i] := Round(Vec[i] * 255); end; end; - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmapNormalMap.AfterConstruction; begin inherited; - fGenMode := GL_NORMAL_MAP; end; - -procedure TglBitmapNormalMap.GenerateNormalMap(Size: Integer; - TestTextureSize: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean); var Rec: TglBitmapNormalMapRec; SizeRec: TglBitmapPixelPosition; begin - Rec.HalfSize := Size div 2; - + Rec.HalfSize := aSize div 2; FreeDataAfterGenTexture := false; SizeRec.Fields := [ffX, ffY]; - SizeRec.X := Size; - SizeRec.Y := Size; + SizeRec.X := aSize; + SizeRec.Y := aSize; // Positive X Rec.Func := glBitmapNormalMapPosX; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize); // Negative X Rec.Func := glBitmapNormalMapNegX; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize); // Positive Y Rec.Func := glBitmapNormalMapPosY; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize); // Negative Y Rec.Func := glBitmapNormalMapNegY; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize); // Positive Z Rec.Func := glBitmapNormalMapPosZ; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize); // Negative Z Rec.Func := glBitmapNormalMapNegZ; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize); 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); TFormatDescriptor.Init; +{$IFDEF GLB_NATIVE_OGL_DYNAMIC} + OpenGLInitialized := false; + InitOpenGLCS := TCriticalSection.Create; +{$ENDIF} + finalization TFormatDescriptor.Finalize; -end. +{$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.