X-Git-Url: https://git.delphigl.com/?p=glBitmap.git;a=blobdiff_plain;f=glBitmap.pas;h=4986ed471cd5380819e44a9b8ca3d4e4a8bbdf7d;hp=32ee5753735bbb6723e5a5505220ec9e9d5d49ec;hb=5a2eeb45d528c5a2406b2ae5d73a4c711b2ea7dc;hpb=3abbe3ab4b2faa2f817a2d99085009467e1aadbe diff --git a/glBitmap.pas b/glBitmap.pas index 32ee575..4986ed4 100644 --- a/glBitmap.pas +++ b/glBitmap.pas @@ -2,8 +2,7 @@ glBitmap by Steffen Xonna aka Lossy eX (2003-2008) http://www.opengl24.de/index.php?cat=header&file=glbitmap -modified by Delphi OpenGL Community (http://delphigl.com/) - +modified by Delphi OpenGL Community (http://delphigl.com/) (2013) ------------------------------------------------------------ The contents of this file are used with permission, subject to @@ -12,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 @@ -23,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 @@ -52,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 @@ -218,13 +219,19 @@ 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! ;)'} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// enable OpenGL ES support +{.$DEFINE OPENGL_ES_1_1} +{.$DEFINE OPENGL_ES_2_0} +{.$DEFINE OPENGL_ES_3_0} +{.$DEFINE OPENGL_ES_EXT} + // activate to enable build-in OpenGL support with statically linked methods // use dglOpenGL.pas if not enabled {.$DEFINE GLB_NATIVE_OGL_STATIC} @@ -233,19 +240,28 @@ unit glBitmap; // use dglOpenGL.pas if not enabled {.$DEFINE GLB_NATIVE_OGL_DYNAMIC} + // activate to enable the support for SDL_surfaces {.$DEFINE GLB_SDL} -// activate to enable the support for TBitmap from Delphi (not lazarus) +// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap) {.$DEFINE GLB_DELPHI} +// activate to enable the support for TLazIntfImage from Lazarus +{.$DEFINE GLB_LAZARUS} + + -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // 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} -// PNG ///////////////////////////////////////////////////////////////////////////////////////////// + + +// 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} @@ -254,13 +270,18 @@ unit glBitmap; // You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng {.$DEFINE GLB_LIB_PNG} -// JPEG //////////////////////////////////////////////////////////////////////////////////////////// + + +// 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} +{.$DEFINE GLB_LIB_JPEG} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -281,15 +302,25 @@ unit glBitmap; {$ENDIF} // Operation System -{$IF DEFINED(WIN32) or DEFINED(WIN64)} +{$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)} {$DEFINE GLB_WIN} {$ELSEIF DEFINED(LINUX)} {$DEFINE GLB_LINUX} {$IFEND} +// OpenGL ES +{$IF DEFINED(OPENGL_ES_EXT)} {$DEFINE OPENGL_ES_1_1} {$IFEND} +{$IF DEFINED(OPENGL_ES_3_0)} {$DEFINE OPENGL_ES_2_0} {$IFEND} +{$IF DEFINED(OPENGL_ES_2_0)} {$DEFINE OPENGL_ES_1_1} {$IFEND} +{$IF DEFINED(OPENGL_ES_1_1)} {$DEFINE OPENGL_ES} {$IFEND} + // native OpenGL Support {$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)} - {$DEFINE GLB_NATIVE_OGL} + {$IFDEF OPENGL_ES} + {$ERROR 'native OpenGL is not supported yet for OpenGL ES, please use dglOpenGLES.pas instead'} + {$ELSE} + {$DEFINE GLB_NATIVE_OGL} + {$ENDIF} {$IFEND} // checking define combinations @@ -299,18 +330,32 @@ unit glBitmap; {$MESSAGE warn 'SDL_image won''t work without SDL. SDL will be activated.'} {$DEFINE GLB_SDL} {$ENDIF} + + {$IFDEF GLB_LAZ_PNG} + {$MESSAGE warn 'The Lazarus TPortableNetworkGraphics will be ignored because you are using SDL_image.'} + {$undef GLB_LAZ_PNG} + {$ENDIF} + {$IFDEF GLB_PNGIMAGE} {$MESSAGE warn 'The unit pngimage will be ignored because you are using SDL_image.'} {$undef GLB_PNGIMAGE} {$ENDIF} + + {$IFDEF GLB_LAZ_JPEG} + {$MESSAGE warn 'The Lazarus TJPEGImage will be ignored because you are using SDL_image.'} + {$undef GLB_LAZ_JPEG} + {$ENDIF} + {$IFDEF GLB_DELPHI_JPEG} {$MESSAGE warn 'The unit JPEG will be ignored because you are using SDL_image.'} {$undef GLB_DELPHI_JPEG} {$ENDIF} + {$IFDEF GLB_LIB_PNG} {$MESSAGE warn 'The library libPNG will be ignored because you are using SDL_image.'} {$undef GLB_LIB_PNG} {$ENDIF} + {$IFDEF GLB_LIB_JPEG} {$MESSAGE warn 'The library libJPEG will be ignored because you are using SDL_image.'} {$undef GLB_LIB_JPEG} @@ -320,6 +365,27 @@ unit glBitmap; {$DEFINE GLB_SUPPORT_JPEG_READ} {$ENDIF} +// Lazarus TPortableNetworkGraphic +{$IFDEF GLB_LAZ_PNG} + {$IFNDEF GLB_LAZARUS} + {$MESSAGE warn 'Lazarus TPortableNetworkGraphic won''t work without Lazarus. Lazarus will be activated.'} + {$DEFINE GLB_LAZARUS} + {$ENDIF} + + {$IFDEF GLB_PNGIMAGE} + {$MESSAGE warn 'The pngimage will be ignored if you are using Lazarus TPortableNetworkGraphic.'} + {$undef GLB_PNGIMAGE} + {$ENDIF} + + {$IFDEF GLB_LIB_PNG} + {$MESSAGE warn 'The library libPNG will be ignored if you are using Lazarus TPortableNetworkGraphic.'} + {$undef GLB_LIB_PNG} + {$ENDIF} + + {$DEFINE GLB_SUPPORT_PNG_READ} + {$DEFINE GLB_SUPPORT_PNG_WRITE} +{$ENDIF} + // PNG Image {$IFDEF GLB_PNGIMAGE} {$IFDEF GLB_LIB_PNG} @@ -337,6 +403,27 @@ unit glBitmap; {$DEFINE GLB_SUPPORT_PNG_WRITE} {$ENDIF} +// Lazarus TJPEGImage +{$IFDEF GLB_LAZ_JPEG} + {$IFNDEF GLB_LAZARUS} + {$MESSAGE warn 'Lazarus TJPEGImage won''t work without Lazarus. Lazarus will be activated.'} + {$DEFINE GLB_LAZARUS} + {$ENDIF} + + {$IFDEF GLB_DELPHI_JPEG} + {$MESSAGE warn 'The Delphi JPEGImage will be ignored if you are using the Lazarus TJPEGImage.'} + {$undef GLB_DELPHI_JPEG} + {$ENDIF} + + {$IFDEF GLB_LIB_JPEG} + {$MESSAGE warn 'The library libJPEG will be ignored if you are using the Lazarus TJPEGImage.'} + {$undef GLB_LIB_JPEG} + {$ENDIF} + + {$DEFINE GLB_SUPPORT_JPEG_READ} + {$DEFINE GLB_SUPPORT_JPEG_WRITE} +{$ENDIF} + // JPEG Image {$IFDEF GLB_DELPHI_JPEG} {$IFDEF GLB_LIB_JPEG} @@ -357,7 +444,7 @@ unit glBitmap; // 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'} -{$ENDIF} +{$IFEND} // general options {$EXTENDEDSYNTAX ON} @@ -370,42 +457,34 @@ unit glBitmap; interface uses - {$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF} + {$IFNDEF GLB_NATIVE_OGL} + {$IFDEF OPENGL_ES} dglOpenGLES, + {$ELSE} dglOpenGL, {$ENDIF} + {$ENDIF} {$IF DEFINED(GLB_WIN) AND - DEFINED(GLB_NATIVE_OGL)} windows, {$IFEND} - - {$IFDEF GLB_SDL} SDL, {$ENDIF} - {$IFDEF GLB_DELPHI} Dialogs, Graphics, {$ENDIF} + (DEFINED(GLB_NATIVE_OGL) OR + DEFINED(GLB_DELPHI))} windows, {$IFEND} - {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF} + {$IFDEF GLB_SDL} SDL, {$ENDIF} + {$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, Graphics, {$ENDIF} + {$IFDEF GLB_DELPHI} Dialogs, Graphics, Types, {$ENDIF} - {$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF} - {$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF} - - {$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF} - {$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF} + {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF} + {$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF} + {$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF} + {$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF} + {$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF} Classes, SysUtils; -{$IFNDEF GLB_DELPHI} -type - HGLRC = Cardinal; - DWORD = Cardinal; - PDWORD = ^DWORD; - - TRGBQuad = packed record - rgbBlue: Byte; - rgbGreen: Byte; - rgbRed: Byte; - rgbReserved: Byte; - end; -{$ENDIF} - {$IFDEF GLB_NATIVE_OGL} const GL_TRUE = 1; GL_FALSE = 0; + GL_ZERO = 0; + GL_ONE = 1; + GL_VERSION = $1F02; GL_EXTENSIONS = $1F03; @@ -413,9 +492,34 @@ const GL_TEXTURE_2D = $0DE1; GL_TEXTURE_RECTANGLE = $84F5; + GL_NORMAL_MAP = $8511; + GL_TEXTURE_CUBE_MAP = $8513; + GL_REFLECTION_MAP = $8512; + GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515; + GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516; + GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518; + GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519; + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A; + GL_TEXTURE_WIDTH = $1000; GL_TEXTURE_HEIGHT = $1001; GL_TEXTURE_INTERNAL_FORMAT = $1003; + GL_TEXTURE_SWIZZLE_RGBA = $8E46; + + GL_S = $2000; + GL_T = $2001; + GL_R = $2002; + GL_Q = $2003; + + GL_TEXTURE_GEN_S = $0C60; + GL_TEXTURE_GEN_T = $0C61; + GL_TEXTURE_GEN_R = $0C62; + GL_TEXTURE_GEN_Q = $0C63; + + GL_RED = $1903; + GL_GREEN = $1904; + GL_BLUE = $1905; GL_ALPHA = $1906; GL_ALPHA4 = $803B; @@ -517,14 +621,16 @@ const GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE; GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF; + GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C; + GL_TEXTURE_GEN_MODE = $2500; -{$ifdef LINUX} - libglu = 'libGLU.so.1'; - libopengl = 'libGL.so.1'; -{$else} +{$IF DEFINED(GLB_WIN)} libglu = 'glu32.dll'; libopengl = 'opengl32.dll'; -{$endif} +{$ELSEIF DEFINED(GLB_LINUX)} + libglu = 'libGLU.so.1'; + libopengl = 'libGL.so.1'; +{$IFEND} type GLboolean = BYTEBOOL; @@ -544,6 +650,13 @@ type 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} @@ -552,12 +665,14 @@ type TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} + TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} @@ -573,12 +688,6 @@ type 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} - {$IFDEF GLB_LINUX} - TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl; - {$ELSE} - TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall; - {$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; @@ -587,12 +696,14 @@ type procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; + procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl; @@ -607,13 +718,14 @@ type 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; -{$ENDIF} +{$IFEND} 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, @@ -621,6 +733,8 @@ var GL_ARB_texture_mirrored_repeat, GL_ARB_texture_rectangle, GL_ARB_texture_non_power_of_two, + GL_ARB_texture_swizzle, + GL_ARB_texture_cube_map, GL_IBM_texture_mirrored_repeat, @@ -628,12 +742,21 @@ var GL_EXT_texture_edge_clamp, GL_EXT_texture_rectangle, + GL_EXT_texture_swizzle, + GL_EXT_texture_cube_map, GL_EXT_texture_filter_anisotropic: Boolean; glCompressedTexImage1D: TglCompressedTexImage1D; glCompressedTexImage2D: TglCompressedTexImage2D; glGetCompressedTexImage: TglGetCompressedTexImage; +{$IF DEFINED(GLB_WIN)} + wglGetProcAddress: TwglGetProcAddress; +{$ELSEIF DEFINED(GLB_LINUX)} + glXGetProcAddress: TglXGetProcAddress; + glXGetProcAddressARB: TglXGetProcAddress; +{$IFEND} + {$IFDEF GLB_NATIVE_OGL_DYNAMIC} glEnable: TglEnable; glDisable: TglDisable; @@ -642,12 +765,14 @@ var glGetIntegerv: TglGetIntegerv; glTexParameteri: TglTexParameteri; + glTexParameteriv: TglTexParameteriv; glTexParameterfv: TglTexParameterfv; glGetTexParameteriv: TglGetTexParameteriv; glGetTexParameterfv: TglGetTexParameterfv; glGetTexLevelParameteriv: TglGetTexLevelParameteriv; glGetTexLevelParameterfv: TglGetTexLevelParameterfv; + glTexGeni: TglTexGeni; glGenTextures: TglGenTextures; glBindTexture: TglBindTexture; glDeleteTextures: TglDeleteTextures; @@ -662,82 +787,93 @@ var gluBuild1DMipmaps: TgluBuild1DMipmaps; gluBuild2DMipmaps: TgluBuild2DMipmaps; - - {$IF DEFINED(GLB_WIN)} - wglGetProcAddress: TwglGetProcAddress; - {$ELSEIF DEFINED(GLB_LINUX)} - glXGetProcAddress: TglXGetProcAddress; - glXGetProcAddressARB: TglXGetProcAddressARB; - {$ENDIF} -{$ENDIF} - -(* -{$IFDEF GLB_DELPHI} -var - gLastContext: HGLRC; {$ENDIF} -*) - {$ENDIF} type //////////////////////////////////////////////////////////////////////////////////////////////////// +// the name of formats is composed of the following constituents: +// - multiple chanals: +// - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved) +// - width of the chanel in bit (4, 8, 16, ...) +// - data type (e.g. ub, us, ui) +// - number of data types + +{$IFNDEF fpc} + QWord = System.UInt64; + PQWord = ^QWord; + + PtrInt = Longint; + PtrUInt = DWord; +{$ENDIF} + TglBitmapFormat = ( - tfEmpty = 0, //must be smallest value! - - tfAlpha4, - tfAlpha8, - tfAlpha12, - tfAlpha16, - - tfLuminance4, - tfLuminance8, - tfLuminance12, - tfLuminance16, - - tfLuminance4Alpha4, - tfLuminance6Alpha2, - tfLuminance8Alpha8, - tfLuminance12Alpha4, - tfLuminance12Alpha12, - tfLuminance16Alpha16, - - tfR3G3B2, - tfRGB4, - tfR5G6B5, - tfRGB5, - tfRGB8, - tfRGB10, - tfRGB12, - tfRGB16, - - tfRGBA2, - tfRGBA4, - tfRGB5A1, - tfRGBA8, - tfRGB10A2, - tfRGBA12, - tfRGBA16, - - tfBGR4, - tfB5G6R5, - tfBGR5, - tfBGR8, - tfBGR10, - tfBGR12, - tfBGR16, - - tfBGRA2, - tfBGRA4, - tfBGR5A1, - tfBGRA8, - tfBGR10A2, - tfBGRA12, - tfBGRA16, - - tfDepth16, - tfDepth24, - tfDepth32, + tfEmpty = 0, //must be smallest value! + + tfAlpha4ub1, // 1 x unsigned byte + tfAlpha8ub1, // 1 x unsigned byte + tfAlpha16us1, // 1 x unsigned short + + tfLuminance4ub1, // 1 x unsigned byte + tfLuminance8ub1, // 1 x unsigned byte + tfLuminance16us1, // 1 x unsigned short + + tfLuminance4Alpha4ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance6Alpha2ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance8Alpha8ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance12Alpha4us2, // 1 x unsigned short (lum), 1 x unsigned short (alpha) + tfLuminance16Alpha16us2, // 1 x unsigned short (lum), 1 x unsigned short (alpha) + + tfR3G3B2ub1, // 1 x unsigned byte (3bit red, 3bit green, 2bit blue) + tfRGBX4us1, // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd) + tfXRGB4us1, // 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue) + tfR5G6B5us1, // 1 x unsigned short (5bit red, 6bit green, 5bit blue) + tfRGB5X1us1, // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved) + tfX1RGB5us1, // 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue) + tfRGB8ub3, // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue) + tfRGBX8ui1, // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved) + tfXRGB8ui1, // 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue) + tfRGB10X2ui1, // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved) + tfX2RGB10ui1, // 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue) + tfRGB16us3, // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue) + + tfRGBA4us1, // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha) + tfARGB4us1, // 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue) + tfRGB5A1us1, // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha) + tfA1RGB5us1, // 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue) + tfRGBA8ui1, // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha) + tfARGB8ui1, // 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue) + tfRGBA8ub4, // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha) + tfRGB10A2ui1, // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha) + tfA2RGB10ui1, // 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue) + tfRGBA16us4, // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha) + + tfBGRX4us1, // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved) + tfXBGR4us1, // 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red) + tfB5G6R5us1, // 1 x unsigned short (5bit blue, 6bit green, 5bit red) + tfBGR5X1us1, // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved) + tfX1BGR5us1, // 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red) + tfBGR8ub3, // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red) + tfBGRX8ui1, // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved) + tfXBGR8ui1, // 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red) + tfBGR10X2ui1, // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved) + tfX2BGR10ui1, // 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red) + tfBGR16us3, // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red) + + tfBGRA4us1, // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha) + tfABGR4us1, // 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red) + tfBGR5A1us1, // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha) + tfA1BGR5us1, // 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red) + tfBGRA8ui1, // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha) + tfABGR8ui1, // 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red) + tfBGRA8ub4, // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha) + tfBGR10A2ui1, // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha) + tfA2BGR10ui1, // 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red) + tfBGRA16us4, // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha) + + tfDepth16us1, // 1 x unsigned short (depth) + tfDepth24ui1, // 1 x unsigned int (depth) + tfDepth32ui1, // 1 x unsigned int (depth) tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, @@ -749,7 +885,8 @@ type {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF} ftDDS, ftTGA, - ftBMP); + ftBMP, + ftRAW); TglBitmapFileTypes = set of TglBitmapFileType; TglBitmapMipMap = ( @@ -764,27 +901,111 @@ type nm5x5); //////////////////////////////////////////////////////////////////////////////////////////////////// - EglBitmapException = class(Exception); - EglBitmapSizeToLargeException = class(EglBitmapException); - EglBitmapNonPowerOfTwoException = class(EglBitmapException); - EglBitmapUnsupportedFormat = class(EglBitmapException) - constructor Create(const aFormat: TglBitmapFormat); + 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 + TglBitmapRec4ui = packed record case Integer of 0: (r, g, b, a: Cardinal); 1: (arr: array[0..3] of Cardinal); end; + TglBitmapRec4ub = packed record + case Integer of + 0: (r, g, b, a: Byte); + 1: (arr: array[0..3] of Byte); + end; + + TglBitmapRec4ul = packed record + case Integer of + 0: (r, g, b, a: QWord); + 1: (arr: array[0..3] of QWord); + end; + + TglBitmapFormatDescriptor = class(TObject) + private + // cached properties + fBytesPerPixel: Single; + fChannelCount: Integer; + fMask: TglBitmapRec4ul; + fRange: TglBitmapRec4ui; + + function GetHasRed: Boolean; + function GetHasGreen: Boolean; + function GetHasBlue: Boolean; + function GetHasAlpha: Boolean; + function GetHasColor: Boolean; + function GetIsGrayscale: Boolean; + protected + fFormat: TglBitmapFormat; + fWithAlpha: TglBitmapFormat; + fWithoutAlpha: TglBitmapFormat; + fOpenGLFormat: TglBitmapFormat; + fRGBInverted: TglBitmapFormat; + fUncompressed: TglBitmapFormat; + + fBitsPerPixel: Integer; + fIsCompressed: Boolean; + + fPrecision: TglBitmapRec4ub; + fShift: TglBitmapRec4ub; + + fglFormat: GLenum; + fglInternalFormat: GLenum; + fglDataFormat: GLenum; + + procedure SetValues; virtual; + procedure CalcValues; + public + property Format: TglBitmapFormat read fFormat; + property ChannelCount: Integer read fChannelCount; + property IsCompressed: Boolean read fIsCompressed; + property BitsPerPixel: Integer read fBitsPerPixel; + property BytesPerPixel: Single read fBytesPerPixel; + + property Precision: TglBitmapRec4ub read fPrecision; + property Shift: TglBitmapRec4ub read fShift; + property Range: TglBitmapRec4ui read fRange; + property Mask: TglBitmapRec4ul read fMask; + + property RGBInverted: TglBitmapFormat read fRGBInverted; + property WithAlpha: TglBitmapFormat read fWithAlpha; + property WithoutAlpha: TglBitmapFormat read fWithAlpha; + property OpenGLFormat: TglBitmapFormat read fOpenGLFormat; + property Uncompressed: TglBitmapFormat read fUncompressed; + + property glFormat: GLenum read fglFormat; + property glInternalFormat: GLenum read fglInternalFormat; + property glDataFormat: GLenum read fglDataFormat; + + property HasRed: Boolean read GetHasRed; + property HasGreen: Boolean read GetHasGreen; + property HasBlue: Boolean read GetHasBlue; + property HasAlpha: Boolean read GetHasAlpha; + property HasColor: Boolean read GetHasColor; + property IsGrayscale: Boolean read GetIsGrayscale; + + constructor Create; + public + class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; + end; + +//////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapPixelData = packed record - Data, Range: TglBitmapColorRec; + Data: TglBitmapRec4ui; + Range: TglBitmapRec4ui; Format: TglBitmapFormat; end; PglBitmapPixelData = ^TglBitmapPixelData; -//////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapPixelPositionFields = set of (ffX, ffY); TglBitmapPixelPosition = record Fields : TglBitmapPixelPositionFields; @@ -806,14 +1027,19 @@ type ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap = class + private + function GetFormatDesc: TglBitmapFormatDescriptor; protected fID: GLuint; fTarget: GLuint; fAnisotropic: Integer; fDeleteTextureOnFree: Boolean; + fFreeDataOnDestroy: Boolean; fFreeDataAfterGenTexture: Boolean; fData: PByte; - fIsResident: Boolean; +{$IFNDEF OPENGL_ES} + fIsResident: GLboolean; +{$ENDIF} fBorderColor: array[0..3] of Single; fDimension: TglBitmapPixelPosition; @@ -825,13 +1051,18 @@ 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; + +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + //Swizzle + fSwizzle: array[0..3] of GLenum; +{$IFEND} // CustomData fFilename: String; @@ -850,6 +1081,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); @@ -859,9 +1091,9 @@ type procedure SetAnisotropic(const aValue: Integer); procedure CreateID; - procedure SetupParameters(out aBuildWithGlu: Boolean); - procedure SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; + procedure SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF}); + 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; @@ -880,30 +1112,35 @@ 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; +{$IFNDEF OPENGL_ES} + property IsResident: GLboolean read fIsResident; +{$ENDIF} 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: Pointer = nil); - {$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} + 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); @@ -929,11 +1166,20 @@ type function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; - function AddAlphaFromResource(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil; + {$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 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; - {$ENDIF} 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; @@ -954,7 +1200,9 @@ type function Clone: TglBitmap; function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual; procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false); +{$IFNDEF OPENGL_ES} procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); +{$ENDIF} procedure FreeData; //ColorFill @@ -963,11 +1211,14 @@ type procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1); //TexParameters - procedure SetFilter(const aMin, aMag: Cardinal); + procedure SetFilter(const aMin, aMag: GLenum); procedure SetWrap( - const S: Cardinal = GL_CLAMP_TO_EDGE; - const T: Cardinal = GL_CLAMP_TO_EDGE; - const R: Cardinal = GL_CLAMP_TO_EDGE); + const S: GLenum = GL_CLAMP_TO_EDGE; + const T: GLenum = GL_CLAMP_TO_EDGE; + const R: GLenum = GL_CLAMP_TO_EDGE); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + procedure SetSwizzle(const r, g, b, a: GLenum); +{$IFEND} procedure Bind(const aEnableTextureUnit: Boolean = true); virtual; procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual; @@ -976,12 +1227,10 @@ type constructor Create; overload; constructor Create(const aFileName: String); overload; constructor Create(const aStream: TStream); overload; - constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat); overload; + constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload; constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload; - {$IFDEF GLB_DELPHI} 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; {$ENDIF} {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF} @@ -989,35 +1238,42 @@ type {$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; + function LoadRAW(const aStream: TStream): Boolean; + procedure SaveRAW(const aStream: TStream); + + function LoadBMP(const aStream: TStream): Boolean; + procedure SaveBMP(const aStream: TStream); - function LoadTGA(const aStream: TStream): Boolean; virtual; - procedure SaveTGA(const aStream: TStream); virtual; + function LoadTGA(const aStream: TStream): Boolean; + procedure SaveTGA(const aStream: TStream); + + function LoadDDS(const aStream: TStream): Boolean; + procedure SaveDDS(const aStream: TStream); + end; - function LoadDDS(const aStream: TStream): Boolean; virtual; - procedure SaveDDS(const aStream: TStream); virtual; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{$IFNDEF OPENGL_ES} + 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; +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF}); public property Width; property Height; @@ -1026,7 +1282,9 @@ type procedure AfterConstruction; override; procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); +{$IFNDEF OPENGL_ES} procedure GetDataFromTexture; +{$ENDIF} procedure GenTexture(const aTestTextureSize: Boolean = true); override; function FlipHorz: Boolean; override; @@ -1036,50 +1294,30 @@ type const aScale: Single = 2; const aUseAlpha: Boolean = false); end; -(* TODO +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} TglBitmapCubeMap = class(TglBitmap2D) protected + {$IFNDEF OPENGL_ES} fGenMode: Integer; - - // Hide GenTexture - procedure GenTexture(TestTextureSize: Boolean = true); reintroduce; + {$ENDIF} + 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({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean = true;{$ENDIF} const aEnableTextureUnit: Boolean = true); reintroduce; virtual; + procedure Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean = true;{$ENDIF} const aDisableTextureUnit: Boolean = true); reintroduce; virtual; end; +{$IFEND} - +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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; -*) +{$IFEND} const NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0); @@ -1102,8 +1340,13 @@ procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal); procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal); function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition; -function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; -function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean; +function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub; +function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui; +function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul; +function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean; +function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean; + +function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; var glBitmapDefaultDeleteTextureOnFree: Boolean; @@ -1115,6 +1358,7 @@ var glBitmapDefaultWrapS: Cardinal; glBitmapDefaultWrapT: Cardinal; glBitmapDefaultWrapR: Cardinal; + glDefaultSwizzle: array[0..3] of GLenum; {$IFDEF GLB_DELPHI} function CreateGrayPalette: HPALETTE; @@ -1122,82 +1366,25 @@ 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, typinfo; + Math, syncobjs, typinfo + {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; -type //////////////////////////////////////////////////////////////////////////////////////////////////// - TShiftRec = packed record - case Integer of - 0: (r, g, b, a: Byte); - 1: (arr: array[0..3] of Byte); - end; - - TFormatDescriptor = class(TObject) - private - function GetRedMask: QWord; - function GetGreenMask: QWord; - function GetBlueMask: QWord; - function GetAlphaMask: QWord; - protected - fFormat: TglBitmapFormat; - fWithAlpha: TglBitmapFormat; - fWithoutAlpha: TglBitmapFormat; - fRGBInverted: TglBitmapFormat; - fUncompressed: TglBitmapFormat; - fPixelSize: Single; - fIsCompressed: Boolean; - - fRange: TglBitmapColorRec; - fShift: TShiftRec; - - fglFormat: Cardinal; - fglInternalFormat: Cardinal; - fglDataFormat: Cardinal; - - function GetComponents: Integer; virtual; +type + TFormatDescriptor = class(TglBitmapFormatDescriptor) 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: 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; 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: QWord): Boolean; virtual; + function IsEmpty: Boolean; virtual; + function MaskMatch(const aMask: TglBitmapRec4ul): Boolean; virtual; procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual; @@ -1205,7 +1392,9 @@ type public class procedure Init; class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor; - class function GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; + class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; + class function GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer = 0): TFormatDescriptor; + class function GetFromPrecShift(const aPrec, aShift: TglBitmapRec4ub; const aBitCount: Integer): TFormatDescriptor; class procedure Clear; class procedure Finalize; end; @@ -1214,342 +1403,367 @@ type TfdEmpty = class(TFormatDescriptor); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha_UB1 = class(TFormatDescriptor) //1* unsigned byte + TfdAlphaUB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminance_UB1 = class(TFormatDescriptor) //1* unsigned byte + TfdLuminanceUB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdUniversal_UB1 = class(TFormatDescriptor) //1* unsigned byte + TfdUniversalUB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //2* unsigned byte + TfdLuminanceAlphaUB2 = class(TfdLuminanceUB1) //2* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGB_UB3 = class(TFormatDescriptor) //3* unsigned byte + TfdRGBub3 = class(TFormatDescriptor) //3* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGR_UB3 = class(TFormatDescriptor) //3* unsigned byte (inverse) + TfdBGRub3 = class(TFormatDescriptor) //3* unsigned byte (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGBA_UB4 = class(TfdRGB_UB3) //4* unsigned byte + TfdRGBAub4 = class(TfdRGBub3) //3* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGRA_UB4 = class(TfdBGR_UB3) //4* unsigned byte (inverse) + TfdBGRAub4 = class(TfdBGRub3) //3* unsigned byte (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha_US1 = class(TFormatDescriptor) //1* unsigned short + TfdAlphaUS1 = class(TFormatDescriptor) //1* unsigned short + procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + end; + + TfdLuminanceUS1 = class(TFormatDescriptor) //1* unsigned short + procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + end; + + TfdUniversalUS1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminance_US1 = class(TFormatDescriptor) //1* unsigned short + TfdDepthUS1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdUniversal_US1 = class(TFormatDescriptor) //1* unsigned short + TfdLuminanceAlphaUS2 = class(TfdLuminanceUS1) //2* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdDepth_US1 = class(TFormatDescriptor) //1* unsigned short + TfdRGBus3 = class(TFormatDescriptor) //3* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //2* unsigned short + TfdBGRus3 = class(TFormatDescriptor) //3* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGB_US3 = class(TFormatDescriptor) //3* unsigned short + TfdRGBAus4 = class(TfdRGBus3) //4* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGR_US3 = class(TFormatDescriptor) //3* unsigned short (inverse) + TfdARGBus4 = class(TfdRGBus3) //4* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGBA_US4 = class(TfdRGB_US3) //4* unsigned short + TfdBGRAus4 = class(TfdBGRus3) //4* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGRA_US4 = class(TfdBGR_US3) //4* unsigned short (inverse) + TfdABGRus4 = class(TfdBGRus3) //4* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdUniversal_UI1 = class(TFormatDescriptor) //1* unsigned int + TfdUniversalUI1 = class(TFormatDescriptor) //1* unsigned int procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdDepth_UI1 = class(TFormatDescriptor) //1* unsigned int + TfdDepthUI1 = class(TFormatDescriptor) //1* unsigned int procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha4 = class(TfdAlpha_UB1) - constructor Create; override; + TfdAlpha4ub1 = class(TfdAlphaUB1) + procedure SetValues; override; + end; + + TfdAlpha8ub1 = class(TfdAlphaUB1) + procedure SetValues; override; + end; + + TfdAlpha16us1 = class(TfdAlphaUS1) + procedure SetValues; override; + end; + + TfdLuminance4ub1 = class(TfdLuminanceUB1) + procedure SetValues; override; + end; + + TfdLuminance8ub1 = class(TfdLuminanceUB1) + procedure SetValues; override; + end; + + TfdLuminance16us1 = class(TfdLuminanceUS1) + procedure SetValues; override; + end; + + TfdLuminance4Alpha4ub2 = class(TfdLuminanceAlphaUB2) + procedure SetValues; override; + end; + + TfdLuminance6Alpha2ub2 = class(TfdLuminanceAlphaUB2) + procedure SetValues; override; + end; + + TfdLuminance8Alpha8ub2 = class(TfdLuminanceAlphaUB2) + procedure SetValues; override; + end; + + TfdLuminance12Alpha4us2 = class(TfdLuminanceAlphaUS2) + procedure SetValues; override; + end; + + TfdLuminance16Alpha16us2 = class(TfdLuminanceAlphaUS2) + procedure SetValues; override; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdR3G3B2ub1 = class(TfdUniversalUB1) + procedure SetValues; override; end; - TfdAlpha8 = class(TfdAlpha_UB1) - constructor Create; override; + TfdRGBX4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdAlpha12 = class(TfdAlpha_US1) - constructor Create; override; + TfdXRGB4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdAlpha16 = class(TfdAlpha_US1) - constructor Create; override; + TfdR5G6B5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdLuminance4 = class(TfdLuminance_UB1) - constructor Create; override; + TfdRGB5X1us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdLuminance8 = class(TfdLuminance_UB1) - constructor Create; override; + TfdX1RGB5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdLuminance12 = class(TfdLuminance_US1) - constructor Create; override; + TfdRGB8ub3 = class(TfdRGBub3) + procedure SetValues; override; end; - TfdLuminance16 = class(TfdLuminance_US1) - constructor Create; override; + TfdRGBX8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance4Alpha4 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; + TfdXRGB8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance6Alpha2 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; + TfdRGB10X2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance8Alpha8 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; + TfdX2RGB10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance12Alpha4 = class(TfdLuminanceAlpha_US2) - constructor Create; override; + TfdRGB16us3 = class(TfdRGBus3) + procedure SetValues; override; end; - TfdLuminance12Alpha12 = class(TfdLuminanceAlpha_US2) - constructor Create; override; + TfdRGBA4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2) - constructor Create; override; + TfdARGB4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdR3G3B2 = class(TfdUniversal_UB1) - constructor Create; override; + TfdRGB5A1us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGB4 = class(TfdUniversal_US1) - constructor Create; override; + TfdA1RGB5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdR5G6B5 = class(TfdUniversal_US1) - constructor Create; override; + TfdRGBA8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGB5 = class(TfdUniversal_US1) - constructor Create; override; + TfdARGB8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGB8 = class(TfdRGB_UB3) - constructor Create; override; + TfdRGBA8ub4 = class(TfdRGBAub4) + procedure SetValues; override; end; - TfdRGB10 = class(TfdUniversal_UI1) - constructor Create; override; + TfdRGB10A2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGB12 = class(TfdRGB_US3) - constructor Create; override; + TfdA2RGB10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGB16 = class(TfdRGB_US3) - constructor Create; override; + TfdRGBA16us4 = class(TfdRGBAus4) + procedure SetValues; override; end; - TfdRGBA2 = class(TfdRGBA_UB4) - constructor Create; override; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdBGRX4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGBA4 = class(TfdUniversal_US1) - constructor Create; override; + TfdXBGR4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGB5A1 = class(TfdUniversal_US1) - constructor Create; override; + TfdB5G6R5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGBA8 = class(TfdRGBA_UB4) - constructor Create; override; + TfdBGR5X1us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGB10A2 = class(TfdUniversal_UI1) - constructor Create; override; + TfdX1BGR5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGBA12 = class(TfdRGBA_US4) - constructor Create; override; + TfdBGR8ub3 = class(TfdBGRub3) + procedure SetValues; override; end; - TfdRGBA16 = class(TfdRGBA_US4) - constructor Create; override; + TfdBGRX8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR4 = class(TfdUniversal_US1) - constructor Create; override; + TfdXBGR8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdB5G6R5 = class(TfdUniversal_US1) - constructor Create; override; + TfdBGR10X2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR5 = class(TfdUniversal_US1) - constructor Create; override; + TfdX2BGR10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR8 = class(TfdBGR_UB3) - constructor Create; override; + TfdBGR16us3 = class(TfdBGRus3) + procedure SetValues; override; end; - TfdBGR10 = class(TfdUniversal_UI1) - constructor Create; override; + TfdBGRA4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGR12 = class(TfdBGR_US3) - constructor Create; override; + TfdABGR4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGR16 = class(TfdBGR_US3) - constructor Create; override; + TfdBGR5A1us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGRA2 = class(TfdBGRA_UB4) - constructor Create; override; + TfdA1BGR5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGRA4 = class(TfdUniversal_US1) - constructor Create; override; + TfdBGRA8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR5A1 = class(TfdUniversal_US1) - constructor Create; override; + TfdABGR8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGRA8 = class(TfdBGRA_UB4) - constructor Create; override; + TfdBGRA8ub4 = class(TfdBGRAub4) + procedure SetValues; override; end; - TfdBGR10A2 = class(TfdUniversal_UI1) - constructor Create; override; + TfdBGR10A2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGRA12 = class(TfdBGRA_US4) - constructor Create; override; + TfdA2BGR10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGRA16 = class(TfdBGRA_US4) - constructor Create; override; + TfdBGRA16us4 = class(TfdBGRAus4) + procedure SetValues; override; end; - TfdDepth16 = class(TfdDepth_US1) - constructor Create; override; + TfdDepth16us1 = class(TfdDepthUS1) + procedure SetValues; override; end; - TfdDepth24 = class(TfdDepth_UI1) - constructor Create; override; + TfdDepth24ui1 = class(TfdDepthUI1) + procedure SetValues; override; end; - TfdDepth32 = class(TfdDepth_UI1) - constructor Create; override; + TfdDepth32ui1 = class(TfdDepthUI1) + procedure SetValues; override; end; TfdS3tcDtx1RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure SetValues; override; end; TfdS3tcDtx3RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure SetValues; override; end; TfdS3tcDtx5RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure SetValues; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TbmpBitfieldFormat = class(TFormatDescriptor) - private - procedure SetRedMask (const aValue: QWord); - procedure SetGreenMask(const aValue: QWord); - procedure SetBlueMask (const aValue: QWord); - procedure SetAlphaMask(const aValue: QWord); - - procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte); public - 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 SetCustomValues(const aBPP: Integer; aMask: TglBitmapRec4ul); overload; + procedure SetCustomValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload; 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; @@ -1561,14 +1775,16 @@ type TbmpColorTable = array of TbmpColorTableEnty; TbmpColorTableFormat = class(TFormatDescriptor) private + fBitsPerPixel: Integer; fColorTable: TbmpColorTable; + protected + procedure SetValues; override; public - property PixelSize: Single read fPixelSize write fPixelSize; - property ColorTable: TbmpColorTable read fColorTable write fColorTable; - property Range: TglBitmapColorRec read fRange write fRange; - property Shift: TShiftRec read fShift write fShift; - property Format: TglBitmapFormat read fFormat write fFormat; + property ColorTable: TbmpColorTable read fColorTable write fColorTable; + property BitsPerPixel: Integer read fBitsPerPixel write fBitsPerPixel; + procedure SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload; + procedure CalcValues; procedure CreateColorTable; procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; @@ -1589,64 +1805,73 @@ const DEPTH_WEIGHT_G = 0.333333333; DEPTH_WEIGHT_B = 0.333333333; - UNSUPPORTED_FORMAT = 'the given format isn''t supported by this function.'; - FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = ( TfdEmpty, - TfdAlpha4, - TfdAlpha8, - TfdAlpha12, - TfdAlpha16, - - TfdLuminance4, - TfdLuminance8, - TfdLuminance12, - TfdLuminance16, - - TfdLuminance4Alpha4, - TfdLuminance6Alpha2, - TfdLuminance8Alpha8, - TfdLuminance12Alpha4, - TfdLuminance12Alpha12, - TfdLuminance16Alpha16, - - TfdR3G3B2, - TfdRGB4, - TfdR5G6B5, - TfdRGB5, - TfdRGB8, - TfdRGB10, - TfdRGB12, - TfdRGB16, - - TfdRGBA2, - TfdRGBA4, - TfdRGB5A1, - TfdRGBA8, - TfdRGB10A2, - TfdRGBA12, - TfdRGBA16, - - TfdBGR4, - TfdB5G6R5, - TfdBGR5, - TfdBGR8, - TfdBGR10, - TfdBGR12, - TfdBGR16, - - TfdBGRA2, - TfdBGRA4, - TfdBGR5A1, - TfdBGRA8, - TfdBGR10A2, - TfdBGRA12, - TfdBGRA16, - - TfdDepth16, - TfdDepth24, - TfdDepth32, + TfdAlpha4ub1, + TfdAlpha8ub1, + TfdAlpha16us1, + + TfdLuminance4ub1, + TfdLuminance8ub1, + TfdLuminance16us1, + + TfdLuminance4Alpha4ub2, + TfdLuminance6Alpha2ub2, + TfdLuminance8Alpha8ub2, + TfdLuminance12Alpha4us2, + TfdLuminance16Alpha16us2, + + TfdR3G3B2ub1, + TfdRGBX4us1, + TfdXRGB4us1, + TfdR5G6B5us1, + TfdRGB5X1us1, + TfdX1RGB5us1, + TfdRGB8ub3, + TfdRGBX8ui1, + TfdXRGB8ui1, + TfdRGB10X2ui1, + TfdX2RGB10ui1, + TfdRGB16us3, + + TfdRGBA4us1, + TfdARGB4us1, + TfdRGB5A1us1, + TfdA1RGB5us1, + TfdRGBA8ui1, + TfdARGB8ui1, + TfdRGBA8ub4, + TfdRGB10A2ui1, + TfdA2RGB10ui1, + TfdRGBA16us4, + + TfdBGRX4us1, + TfdXBGR4us1, + TfdB5G6R5us1, + TfdBGR5X1us1, + TfdX1BGR5us1, + TfdBGR8ub3, + TfdBGRX8ui1, + TfdXBGR8ui1, + TfdBGR10X2ui1, + TfdX2BGR10ui1, + TfdBGR16us3, + + TfdBGRA4us1, + TfdABGR4us1, + TfdBGR5A1us1, + TfdA1BGR5us1, + TfdBGRA8ui1, + TfdABGR8ui1, + TfdBGRA8ub4, + TfdBGR10A2ui1, + TfdA2BGR10ui1, + TfdBGRA16us4, + + TfdDepth16us1, + TfdDepth24ui1, + TfdDepth32ui1, TfdS3tcDtx1RGBA, TfdS3tcDtx3RGBA, @@ -1660,11 +1885,17 @@ var ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat); begin - inherited Create(GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat))); + 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; +function glBitmapPosition(X: Integer; Y: Integer): TglBitmapPixelPosition; begin result.Fields := []; @@ -1678,7 +1909,7 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; +function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub; begin result.r := r; result.g := g; @@ -1687,19 +1918,96 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean; -var - i: Integer; +function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui; begin - result := false; - for i := 0 to high(r1.arr) do - if (r1.arr[i] <> r2.arr[i]) then - exit; - result := true; + result.r := r; + result.g := g; + result.b := b; + result.a := a; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul; +begin + result.r := r; + result.g := g; + result.b := b; + result.a := a; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean; +var + i: Integer; +begin + result := false; + for i := 0 to high(r1.arr) do + if (r1.arr[i] <> r2.arr[i]) then + exit; + result := true; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean; +var + i: Integer; +begin + result := false; + for i := 0 to high(r1.arr) do + if (r1.arr[i] <> r2.arr[i]) then + exit; + result := true; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; +var + desc: TFormatDescriptor; + p, tmp: PByte; + x, y, i: Integer; + md: Pointer; + px: TglBitmapPixelData; +begin + result := nil; + desc := TFormatDescriptor.Get(aFormat); + if (desc.IsCompressed) or (desc.glFormat = 0) then + exit; + + p := GetMemory(ceil(25 * desc.BytesPerPixel)); // 5 x 5 pixel + md := desc.CreateMappingData; + try + tmp := p; + desc.PreparePixel(px); + for y := 0 to 4 do + for x := 0 to 4 do begin + px.Data := glBitmapRec4ui(0, 0, 0, 0); + for i := 0 to 3 do begin + if ((y < 3) and (y = i)) or + ((y = 3) and (i < 3)) or + ((y = 4) and (i = 3)) + then + px.Data.arr[i] := Trunc(px.Range.arr[i] / 4 * x) + else if ((y < 4) and (i = 3)) or + ((y = 4) and (i < 3)) + then + px.Data.arr[i] := px.Range.arr[i] + else + px.Data.arr[i] := 0; //px.Range.arr[i]; + end; + desc.Map(px, tmp, md); + end; + finally + desc.FreeMappingData(md); + end; + + result := TglBitmap2D.Create(glBitmapPosition(5, 5), aFormat, p); + result.FreeDataOnDestroy := true; + result.FreeDataAfterGenTexture := false; + result.SetFilter(GL_NEAREST, GL_NEAREST); end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapShiftRec(const r, g, b, a: Byte): TShiftRec; +function glBitmapShiftRec(const r, g, b, a: Byte): TglBitmapRec4ub; begin result.r := r; result.g := g; @@ -1713,74 +2021,57 @@ begin result := []; if (aFormat in [ - //4 bbp - tfLuminance4, - //8bpp - tfR3G3B2, tfLuminance8, + tfAlpha4ub1, tfAlpha8ub1, + tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1, //16bpp - tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4, - tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4, + tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, + tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1, + tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1, //24bpp - tfBGR8, tfRGB8, + tfBGR8ub3, tfRGB8ub3, //32bpp - tfRGB10, tfRGB10A2, tfRGBA8, - tfBGR10, tfBGR10A2, tfBGRA8]) then - result := result + [ftBMP]; + tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1, + tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1]) + then + result := result + [ ftBMP ]; if (aFormat in [ - //8 bpp - tfLuminance8, tfAlpha8, + //8bbp + tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, - //16 bpp - tfLuminance16, tfLuminance8Alpha8, - tfRGB5, tfRGB5A1, tfRGBA4, - tfBGR5, tfBGR5A1, tfBGRA4, + //16bbp + tfAlpha16us1, tfLuminance16us1, + tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, + tfX1RGB5us1, tfARGB4us1, tfA1RGB5us1, tfDepth16us1, - //24 bpp - tfRGB8, tfBGR8, + //24bbp + tfBGR8ub3, - //32 bpp - tfRGB10A2, tfRGBA8, tfBGR10A2, tfBGRA8]) then + //32bbp + tfX2RGB10ui1, tfARGB8ui1, tfBGRA8ub4, tfA2RGB10ui1, + tfDepth24ui1, tfDepth32ui1]) + then result := result + [ftTGA]; - if (aFormat in [ - //8 bpp - tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2, - tfR3G3B2, tfRGBA2, tfBGRA2, - - //16 bpp - tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4, - tfRGB4, tfR5G6B5, tfRGB5, tfRGBA4, tfRGB5A1, - tfBGR4, tfB5G6R5, tfBGR5, tfBGRA4, tfBGR5A1, - - //24 bpp - tfRGB8, tfBGR8, - - //32 bbp - tfLuminance16Alpha16, - tfRGBA8, tfRGB10A2, - tfBGRA8, tfBGR10A2, - - //compressed - tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then + if not (aFormat in [tfEmpty, tfRGB16us3, tfBGR16us3]) then result := result + [ftDDS]; - {$IFDEF GLB_SUPPORT_PNG_WRITE} +{$IFDEF GLB_SUPPORT_PNG_WRITE} if aFormat in [ - tfAlpha8, tfLuminance8, tfLuminance8Alpha8, - tfRGB8, tfRGBA8, - tfBGR8, tfBGRA8] then + tfAlpha8ub1, tfLuminance8ub1, tfLuminance8Alpha8ub2, + tfRGB8ub3, tfRGBA8ui1, + tfBGR8ub3, tfBGRA8ui1] then result := result + [ftPNG]; - {$ENDIF} +{$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_WRITE} - if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] then +{$IFDEF GLB_SUPPORT_JPEG_WRITE} + if aFormat in [tfAlpha8ub1, tfLuminance8ub1, tfRGB8ub3, tfBGR8ub3] then result := result + [ftJPEG]; - {$ENDIF} +{$ENDIF} end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1837,10 +2128,8 @@ end; var GL_LibHandle: Pointer = nil; -function glbGetProcAddress(aProcName: PChar; aLibHandle: Pointer = nil): Pointer; +function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer; begin - result := nil; - if not Assigned(aLibHandle) then aLibHandle := GL_LibHandle; @@ -1865,9 +2154,9 @@ begin end; result := dlsym(aLibHandle, aProcName); -{$ENDIF} - if not Assigned(result) then - raise EglBitmapException.Create('unable to load procedure form library: ' + 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} @@ -1888,7 +2177,7 @@ procedure glbInitOpenGL; result := dlopen(Name, RTLD_LAZY); {$ELSE} result := nil; - {$ENDIF} + {$IFEND} end; //////////////////////////////////////////////////////////////////////////////// @@ -1902,7 +2191,7 @@ procedure glbInitOpenGL; Result := FreeLibrary({%H-}HINST(aLibHandle)); {$ELSEIF DEFINED(GLB_LINUX)} Result := dlclose(aLibHandle) = 0; - {$ENDIF} + {$IFEND} end; begin @@ -1914,55 +2203,49 @@ begin GL_LibHandle := glbLoadLibrary(libopengl); if not Assigned(GL_LibHandle) then - raise EglBitmapException.Create('unable to load library: ' + libopengl); + raise EglBitmap.Create('unable to load library: ' + libopengl); GLU_LibHandle := glbLoadLibrary(libglu); if not Assigned(GLU_LibHandle) then - raise EglBitmapException.Create('unable to load library: ' + libglu); + raise EglBitmap.Create('unable to load library: ' + libglu); - try - {$IF DEFINED(GLB_WIN)} - wglGetProcAddress := glbGetProcAddress('wglGetProcAddress'); - {$ELSEIF DEFINED(GLB_LINUX)} - glXGetProcAddress := glbGetProcAddress('glXGetProcAddress'); - glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB'); - {$ENDIF} +{$IF DEFINED(GLB_WIN)} + wglGetProcAddress := glbGetProcAddress('wglGetProcAddress'); +{$ELSEIF DEFINED(GLB_LINUX)} + glXGetProcAddress := glbGetProcAddress('glXGetProcAddress'); + glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB'); +{$IFEND} - glEnable := glbGetProcAddress('glEnable'); - glDisable := glbGetProcAddress('glDisable'); - glGetString := glbGetProcAddress('glGetString'); - glGetIntegerv := glbGetProcAddress('glGetIntegerv'); - glTexParameteri := glbGetProcAddress('glTexParameteri'); - glTexParameterfv := glbGetProcAddress('glTexParameterfv'); - glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv'); - glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv'); - glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv'); - glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv'); - glGenTextures := glbGetProcAddress('glGenTextures'); - glBindTexture := glbGetProcAddress('glBindTexture'); - glDeleteTextures := glbGetProcAddress('glDeleteTextures'); - glAreTexturesResident := glbGetProcAddress('glAreTexturesResident'); - glReadPixels := glbGetProcAddress('glReadPixels'); - glPixelStorei := glbGetProcAddress('glPixelStorei'); - glTexImage1D := glbGetProcAddress('glTexImage1D'); - glTexImage2D := glbGetProcAddress('glTexImage2D'); - glGetTexImage := glbGetProcAddress('glGetTexImage'); - - gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle); - gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle); - finally - glbFreeLibrary(GL_LibHandle); - glbFreeLibrary(GLU_LibHandle); - end; + 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} ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glbReadOpenGLExtensions; var - {$IFDEF GLB_DELPHI} - Context: HGLRC; - {$ENDIF} Buffer: AnsiString; MajorVersion, MinorVersion: Integer; @@ -2008,6 +2291,12 @@ var result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']); end; + /////////////////////////////////////////////////////////////////////////////////////////// + function CheckVersion(const aMajor, aMinor: Integer): Boolean; + begin + result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor)); + end; + begin {$IFDEF GLB_NATIVE_OGL_DYNAMIC} InitOpenGLCS.Enter; @@ -2021,99 +2310,44 @@ begin end; {$ENDIF} -{$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 >= 2 then - GL_VERSION_1_2 := true; - - if MinorVersion >= 3 then - GL_VERSION_1_3 := true; - - if MinorVersion >= 4 then - GL_VERSION_1_4 := true; - end else if MajorVersion >= 2 then begin - GL_VERSION_1_2 := true; - GL_VERSION_1_3 := true; - GL_VERSION_1_4 := true; - GL_VERSION_2_0 := true; - end; - - // 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_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_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'); - glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB'); - glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB'); - end; -{$IFDEF GLB_DELPHI} - 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; - - {$IFOPT R+} - {$DEFINE GLB_TEMPRANGECHECK} - {$R-} - {$ENDIF} - - 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; + // Version + Buffer := glGetString(GL_VERSION); + TrimVersionString(Buffer, MajorVersion, MinorVersion); + + GL_VERSION_1_2 := CheckVersion(1, 2); + GL_VERSION_1_3 := CheckVersion(1, 3); + GL_VERSION_1_4 := CheckVersion(1, 4); + GL_VERSION_2_0 := CheckVersion(2, 0); + GL_VERSION_3_3 := CheckVersion(3, 3); + + // Extensions + Buffer := glGetString(GL_EXTENSIONS); + GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp'); + GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two'); + GL_ARB_texture_swizzle := CheckExtension('GL_ARB_texture_swizzle'); + GL_ARB_texture_cube_map := CheckExtension('GL_ARB_texture_cube_map'); + GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle'); + GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat'); + GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp'); + GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic'); + GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle'); + GL_EXT_texture_swizzle := CheckExtension('GL_EXT_texture_swizzle'); + GL_EXT_texture_cube_map := CheckExtension('GL_EXT_texture_cube_map'); + GL_NV_texture_rectangle := CheckExtension('GL_NV_texture_rectangle'); + GL_IBM_texture_mirrored_repeat := CheckExtension('GL_IBM_texture_mirrored_repeat'); + GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap'); + + 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} -*) {$IFDEF GLB_SDL_IMAGE} ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2144,7 +2378,7 @@ begin result := SDL_AllocRW; if result = nil then - raise EglBitmapException.Create('glBitmapCreateRWops - SDL_AllocRW failed.'); + raise EglBitmap.Create('glBitmapCreateRWops - SDL_AllocRW failed.'); result^.seek := glBitmapRWseek; result^.read := glBitmapRWread; @@ -2154,127 +2388,6 @@ begin 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); begin @@ -2315,6 +2428,17 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} +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; +{$IFEND} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmapGetDefaultDeleteTextureOnFree: Boolean; begin result := glBitmapDefaultDeleteTextureOnFree; @@ -2353,43 +2477,19 @@ begin R := glBitmapDefaultWrapR; end; +{$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetRedMask: QWord; -begin - result := fRange.r shl fShift.r; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetGreenMask: QWord; -begin - result := fRange.g shl fShift.g; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetBlueMask: QWord; -begin - result := fRange.b shl fShift.b; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetAlphaMask: QWord; +procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum); begin - result := fRange.a shl fShift.a; + r := glDefaultSwizzle[0]; + g := glDefaultSwizzle[1]; + b := glDefaultSwizzle[2]; + a := glDefaultSwizzle[3]; end; +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -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; - +//TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer; var @@ -2409,7 +2509,7 @@ begin result := 0; if (aWidth <= 0) or (aHeight <= 0) then exit; - result := Ceil(aWidth * aHeight * fPixelSize); + result := Ceil(aWidth * aHeight * BytesPerPixel); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2431,27 +2531,18 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.HasAlpha: Boolean; -begin - result := (fRange.a > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; +function TFormatDescriptor.MaskMatch(const aMask: TglBitmapRec4ul): Boolean; +var + i: Integer; + m: TglBitmapRec4ul; begin result := false; - - if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then - raise EglBitmapException.Create('FormatCheckFormat - All Masks are 0'); - - if (aRedMask <> RedMask) then - exit; - if (aGreenMask <> GreenMask) then - exit; - if (aBlueMask <> BlueMask) then - exit; - if (aAlphaMask <> AlphaMask) then - exit; + if (aMask.r = 0) and (aMask.g = 0) and (aMask.b = 0) and (aMask.a = 0) then + raise EglBitmap.Create('FormatCheckFormat - All Masks are 0'); + m := Mask; + for i := 0 to 3 do + if (aMask.arr[i] <> m.arr[i]) then + exit; result := true; end; @@ -2459,69 +2550,45 @@ end; procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData); begin FillChar(aPixel{%H-}, SizeOf(aPixel), 0); - aPixel.Data := fRange; - aPixel.Range := fRange; + aPixel.Data := Range; aPixel.Format := fFormat; + aPixel.Range := Range; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TFormatDescriptor.Create; begin inherited Create; - - fFormat := tfEmpty; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfEmpty; - fRGBInverted := tfEmpty; - fUncompressed := tfEmpty; - fPixelSize := 0.0; - fIsCompressed := false; - - fglFormat := 0; - fglInternalFormat := 0; - fglDataFormat := 0; - - FillChar(fRange, 0, SizeOf(fRange)); - FillChar(fShift, 0, SizeOf(fShift)); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdAlpha_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdAlpha_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdAlphaUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdAlpha_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdAlphaUB1.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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminance_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminance_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := LuminanceWeight(aPixel); inc(aData); end; -procedure TfdLuminance_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := aData^; aPixel.Data.g := aData^; @@ -2530,77 +2597,50 @@ 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//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdUniversal_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdUniversalUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var i: Integer; begin aData^ := 0; for i := 0 to 3 do - if (fRange.arr[i] > 0) then - aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + if (Range.arr[i] > 0) then + aData^ := aData^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]); inc(aData); end; -procedure TfdUniversal_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversalUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin for i := 0 to 3 do - aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and fRange.arr[i]; + aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and Range.arr[i]; inc(aData); end; -constructor TfdUniversal_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminanceAlpha_UB2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminanceAlpha_UB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceAlphaUB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdLuminanceAlpha_UB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceAlphaUB2.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); +procedure TfdRGBub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := aPixel.Data.r; inc(aData); @@ -2610,7 +2650,7 @@ begin inc(aData); end; -procedure TfdRGB_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := aData^; inc(aData); @@ -2621,24 +2661,10 @@ begin 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); +procedure TfdBGRub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := aPixel.Data.b; inc(aData); @@ -2648,7 +2674,7 @@ begin inc(aData); end; -procedure TfdBGR_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.b := aData^; inc(aData); @@ -2659,83 +2685,50 @@ begin 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///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdRGBA_UB4////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGBA_UB4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdRGBAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdRGBA_UB4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := aData^; inc(aData); end; -constructor TfdRGBA_UB4.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FF; - fShift.a := 24; - fglFormat := GL_RGBA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdBGRA_UB4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdBGRA_UB4////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGRA_UB4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdBGRAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdBGRA_UB4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := aData^; inc(aData); end; -constructor TfdBGRA_UB4.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FF; - fShift.a := 24; - fglFormat := GL_BGRA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdAlpha_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdAlpha_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdAlphaUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := aPixel.Data.a; inc(aData, 2); end; -procedure TfdAlpha_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdAlphaUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := 0; aPixel.Data.g := 0; @@ -2744,25 +2737,16 @@ 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//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminance_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := LuminanceWeight(aPixel); inc(aData, 2); end; -procedure TfdLuminance_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PWord(aData)^; aPixel.Data.g := PWord(aData)^; @@ -2771,106 +2755,68 @@ 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//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdUniversal_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdUniversalUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var i: Integer; begin PWord(aData)^ := 0; for i := 0 to 3 do - if (fRange.arr[i] > 0) then - PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + if (Range.arr[i] > 0) then + PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]); inc(aData, 2); end; -procedure TfdUniversal_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversalUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin for i := 0 to 3 do - aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and fRange.arr[i]; + aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and Range.arr[i]; inc(aData, 2); end; -constructor TfdUniversal_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdDepth_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdDepthUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := DepthWeight(aPixel); inc(aData, 2); end; -procedure TfdDepth_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdDepthUS1.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/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminanceAlpha_US2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceAlphaUS2.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 TfdLuminanceAlpha_US2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceAlphaUS2.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); +procedure TfdRGBus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := aPixel.Data.r; inc(aData, 2); @@ -2880,7 +2826,7 @@ begin inc(aData, 2); end; -procedure TfdRGB_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PWord(aData)^; inc(aData, 2); @@ -2891,24 +2837,10 @@ begin 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); +procedure TfdBGRus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := aPixel.Data.b; inc(aData, 2); @@ -2918,7 +2850,7 @@ begin inc(aData, 2); end; -procedure TfdBGR_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.b := PWord(aData)^; inc(aData, 2); @@ -2929,714 +2861,1216 @@ begin aPixel.Data.a := 0; end; -constructor TfdBGR_US3.Create; -begin - inherited Create; - fPixelSize := 6.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fShift.r := 32; - fShift.g := 16; - fShift.b := 0; - fglFormat := GL_BGR; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdRGBA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdRGBAus4.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; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBAus4.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; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdARGB_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdARGBus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Create; - fPixelSize := 8.0; - fRange.a := $FFFF; - fShift.a := 48; - fglFormat := GL_RGBA; - fglDataFormat := GL_UNSIGNED_SHORT; + PWord(aData)^ := aPixel.Data.a; + inc(aData, 2); + inherited Map(aPixel, aData, aMapData); +end; + +procedure TfdARGBus4.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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdBGRA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGRA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdBGRAus4.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 TfdBGRA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRAus4.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 TfdBGRA_US4.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdABGR_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdABGRus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Create; - fPixelSize := 8.0; - fRange.a := $FFFF; - fShift.a := 48; - fglFormat := GL_BGRA; - fglDataFormat := GL_UNSIGNED_SHORT; + PWord(aData)^ := aPixel.Data.a; + inc(aData, 2); + inherited Map(aPixel, aData, aMapData); +end; + +procedure TfdABGRus4.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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdUniversal_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdUniversal_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdUniversalUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var i: Integer; begin PCardinal(aData)^ := 0; for i := 0 to 3 do - if (fRange.arr[i] > 0) then - PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + if (Range.arr[i] > 0) then + PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]); inc(aData, 4); end; -procedure TfdUniversal_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversalUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin for i := 0 to 3 do - aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and fRange.arr[i]; + aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and Range.arr[i]; inc(aData, 2); end; -constructor TfdUniversal_UI1.Create; -begin - inherited Create; - fPixelSize := 4.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdDepth_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdDepthUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PCardinal(aData)^ := DepthWeight(aPixel); inc(aData, 4); end; -procedure TfdDepth_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdDepthUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PCardinal(aData)^; aPixel.Data.g := PCardinal(aData)^; aPixel.Data.b := PCardinal(aData)^; - aPixel.Data.a := 0; + aPixel.Data.a := PCardinal(aData)^; 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; +procedure TfdAlpha4ub1.SetValues; begin - inherited Create; - fFormat := tfAlpha4; - fWithAlpha := tfAlpha4; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfAlpha4ub1; + fWithAlpha := tfAlpha4ub1; + fPrecision := glBitmapRec4ub(0, 0, 0, 8); + fShift := glBitmapRec4ub(0, 0, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfAlpha4ub1; + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := tfAlpha8ub1; +{$ENDIF} end; -constructor TfdAlpha8.Create; -begin - inherited Create; - fFormat := tfAlpha8; - fWithAlpha := tfAlpha8; - fglInternalFormat := GL_ALPHA8; -end; - -constructor TfdAlpha12.Create; +procedure TfdAlpha8ub1.SetValues; begin - inherited Create; - fFormat := tfAlpha12; - fWithAlpha := tfAlpha12; - fglInternalFormat := GL_ALPHA12; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfAlpha8ub1; + fWithAlpha := tfAlpha8ub1; + fPrecision := glBitmapRec4ub(0, 0, 0, 8); + fShift := glBitmapRec4ub(0, 0, 0, 0); + fOpenGLFormat := tfAlpha8ub1; + fglFormat := GL_ALPHA; + fglInternalFormat := {$IFNDEF OPENGL_ES}GL_ALPHA8{$ELSE}GL_ALPHA{$ENDIF}; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdAlpha16.Create; +procedure TfdAlpha16us1.SetValues; begin - inherited Create; - fFormat := tfAlpha16; - fWithAlpha := tfAlpha16; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfAlpha16us1; + fWithAlpha := tfAlpha16us1; + fPrecision := glBitmapRec4ub(0, 0, 0, 16); + fShift := glBitmapRec4ub(0, 0, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfAlpha16us1; + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfAlpha8ub1; +{$ENDIF} end; -constructor TfdLuminance4.Create; +procedure TfdLuminance4ub1.SetValues; begin - inherited Create; - fFormat := tfLuminance4; - fWithAlpha := tfLuminance4Alpha4; - fWithoutAlpha := tfLuminance4; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfLuminance4ub1; + fWithAlpha := tfLuminance4Alpha4ub2; + fWithoutAlpha := tfLuminance4ub1; + fPrecision := glBitmapRec4ub(8, 8, 8, 0); + fShift := glBitmapRec4ub(0, 0, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfLuminance4ub1; + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE4; + fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := tfLuminance8ub1; +{$ENDIF} end; -constructor TfdLuminance8.Create; -begin - inherited Create; - fFormat := tfLuminance8; - fWithAlpha := tfLuminance8Alpha8; - fWithoutAlpha := tfLuminance8; - fglInternalFormat := GL_LUMINANCE8; -end; - -constructor TfdLuminance12.Create; +procedure TfdLuminance8ub1.SetValues; begin - inherited Create; - fFormat := tfLuminance12; - fWithAlpha := tfLuminance12Alpha12; - fWithoutAlpha := tfLuminance12; - fglInternalFormat := GL_LUMINANCE12; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfLuminance8ub1; + fWithAlpha := tfLuminance8Alpha8ub2; + fWithoutAlpha := tfLuminance8ub1; + fOpenGLFormat := tfLuminance8ub1; + fPrecision := glBitmapRec4ub(8, 8, 8, 0); + fShift := glBitmapRec4ub(0, 0, 0, 0); + fglFormat := GL_LUMINANCE; + fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8{$ELSE}GL_LUMINANCE{$ENDIF}; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdLuminance16.Create; +procedure TfdLuminance16us1.SetValues; begin - inherited Create; - fFormat := tfLuminance16; - fWithAlpha := tfLuminance16Alpha16; - fWithoutAlpha := tfLuminance16; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance16us1; + fWithAlpha := tfLuminance16Alpha16us2; + fWithoutAlpha := tfLuminance16us1; + fPrecision := glBitmapRec4ub(16, 16, 16, 0); + fShift := glBitmapRec4ub( 0, 0, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfLuminance16us1; + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE16; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfLuminance8ub1; +{$ENDIF} end; -constructor TfdLuminance4Alpha4.Create; +procedure TfdLuminance4Alpha4ub2.SetValues; begin - inherited Create; - fFormat := tfLuminance4Alpha4; - fWithAlpha := tfLuminance4Alpha4; - fWithoutAlpha := tfLuminance4; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance4Alpha4ub2; + fWithAlpha := tfLuminance4Alpha4ub2; + fWithoutAlpha := tfLuminance4ub1; + fPrecision := glBitmapRec4ub(8, 8, 8, 8); + fShift := glBitmapRec4ub(0, 0, 0, 8); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfLuminance4Alpha4ub2; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE4_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := tfLuminance8Alpha8ub2; +{$ENDIF} end; -constructor TfdLuminance6Alpha2.Create; +procedure TfdLuminance6Alpha2ub2.SetValues; begin - inherited Create; - fFormat := tfLuminance6Alpha2; - fWithAlpha := tfLuminance6Alpha2; - fWithoutAlpha := tfLuminance8; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance6Alpha2ub2; + fWithAlpha := tfLuminance6Alpha2ub2; + fWithoutAlpha := tfLuminance8ub1; + fPrecision := glBitmapRec4ub(8, 8, 8, 8); + fShift := glBitmapRec4ub(0, 0, 0, 8); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfLuminance6Alpha2ub2; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE6_ALPHA2; + fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := tfLuminance8Alpha8ub2; +{$ENDIF} end; -constructor TfdLuminance8Alpha8.Create; +procedure TfdLuminance8Alpha8ub2.SetValues; begin - inherited Create; - fFormat := tfLuminance8Alpha8; - fWithAlpha := tfLuminance8Alpha8; - fWithoutAlpha := tfLuminance8; - fglInternalFormat := GL_LUMINANCE8_ALPHA8; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance8Alpha8ub2; + fWithAlpha := tfLuminance8Alpha8ub2; + fWithoutAlpha := tfLuminance8ub1; + fOpenGLFormat := tfLuminance8Alpha8ub2; + fPrecision := glBitmapRec4ub(8, 8, 8, 8); + fShift := glBitmapRec4ub(0, 0, 0, 8); + fglFormat := GL_LUMINANCE_ALPHA; + fglInternalFormat := {$IFNDEF OPENGL_ES}GL_LUMINANCE8_ALPHA8{$ELSE}GL_LUMINANCE_ALPHA{$ENDIF}; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdLuminance12Alpha4.Create; +procedure TfdLuminance12Alpha4us2.SetValues; begin - inherited Create; - fFormat := tfLuminance12Alpha4; - fWithAlpha := tfLuminance12Alpha4; - fWithoutAlpha := tfLuminance12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfLuminance12Alpha4us2; + fWithAlpha := tfLuminance12Alpha4us2; + fWithoutAlpha := tfLuminance16us1; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 0, 0, 16); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfLuminance12Alpha4us2; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE12_ALPHA4; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfLuminance8Alpha8ub2; +{$ENDIF} end; -constructor TfdLuminance12Alpha12.Create; -begin - inherited Create; - fFormat := tfLuminance12Alpha12; - fWithAlpha := tfLuminance12Alpha12; - fWithoutAlpha := tfLuminance12; - fglInternalFormat := GL_LUMINANCE12_ALPHA12; -end; - -constructor TfdLuminance16Alpha16.Create; +procedure TfdLuminance16Alpha16us2.SetValues; begin - inherited Create; - fFormat := tfLuminance16Alpha16; - fWithAlpha := tfLuminance16Alpha16; - fWithoutAlpha := tfLuminance16; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfLuminance16Alpha16us2; + fWithAlpha := tfLuminance16Alpha16us2; + fWithoutAlpha := tfLuminance16us1; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 0, 0, 16); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfLuminance16Alpha16us2; + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE16_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfLuminance8Alpha8ub2; +{$ENDIF} end; -constructor TfdR3G3B2.Create; +procedure TfdR3G3B2ub1.SetValues; begin - inherited Create; - fFormat := tfR3G3B2; - fWithAlpha := tfRGBA2; - fWithoutAlpha := tfR3G3B2; - fRange.r := $7; - fRange.g := $7; - fRange.b := $3; - fShift.r := 0; - fShift.g := 3; - fShift.b := 6; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfR3G3B2ub1; + fWithAlpha := tfRGBA4us1; + fWithoutAlpha := tfR3G3B2ub1; + fRGBInverted := tfEmpty; + fPrecision := glBitmapRec4ub(3, 3, 2, 0); + fShift := glBitmapRec4ub(5, 2, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfR3G3B2ub1; fglFormat := GL_RGB; fglInternalFormat := GL_R3_G3_B2; - fglDataFormat := GL_UNSIGNED_BYTE_2_3_3_REV; + fglDataFormat := GL_UNSIGNED_BYTE_3_3_2; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} end; -constructor TfdRGB4.Create; +procedure TfdRGBX4us1.SetValues; begin - inherited Create; - fFormat := tfRGB4; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGB4; - fRGBInverted := tfBGR4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fShift.r := 0; - fShift.g := 4; - fShift.b := 8; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGBX4us1; + fWithAlpha := tfRGBA4us1; + fWithoutAlpha := tfRGBX4us1; + fRGBInverted := tfBGRX4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 0); + fShift := glBitmapRec4ub(12, 8, 4, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfRGBX4us1; fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} +end; + +procedure TfdXRGB4us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfXRGB4us1; + fWithAlpha := tfARGB4us1; + fWithoutAlpha := tfXRGB4us1; + fRGBInverted := tfXBGR4us1; + fPrecision := glBitmapRec4ub(4, 4, 4, 0); + fShift := glBitmapRec4ub(8, 4, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfXRGB4us1; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} end; -constructor TfdR5G6B5.Create; +procedure TfdR5G6B5us1.SetValues; begin - inherited Create; - fFormat := tfR5G6B5; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfR5G6B5; - fRGBInverted := tfB5G6R5; - fRange.r := $1F; - fRange.g := $3F; - fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 11; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfR5G6B5us1; + fWithAlpha := tfRGB5A1us1; + fWithoutAlpha := tfR5G6B5us1; + fRGBInverted := tfB5G6R5us1; + fPrecision := glBitmapRec4ub( 5, 6, 5, 0); + fShift := glBitmapRec4ub(11, 5, 0, 0); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} + fOpenGLFormat := tfR5G6B5us1; fglFormat := GL_RGB; fglInternalFormat := GL_RGB565; - fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5; +{$ELSE} + fOpenGLFormat := tfRGB8ub3; +{$IFEND} end; -constructor TfdRGB5.Create; +procedure TfdRGB5X1us1.SetValues; begin - inherited Create; - fFormat := tfRGB5; - fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5; - fRGBInverted := tfBGR5; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 10; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGB5X1us1; + fWithAlpha := tfRGB5A1us1; + fWithoutAlpha := tfRGB5X1us1; + fRGBInverted := tfBGR5X1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub(11, 6, 1, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfRGB5X1us1; fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} +end; + +procedure TfdX1RGB5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfX1RGB5us1; + fWithAlpha := tfA1RGB5us1; + fWithoutAlpha := tfX1RGB5us1; + fRGBInverted := tfX1BGR5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub(10, 5, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfX1RGB5us1; + 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; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} end; -constructor TfdRGB8.Create; +procedure TfdRGB8ub3.SetValues; begin - inherited Create; - fFormat := tfRGB8; - fWithAlpha := tfRGBA8; - fWithoutAlpha := tfRGB8; - fRGBInverted := tfBGR8; - fglInternalFormat := GL_RGB8; + inherited SetValues; + fBitsPerPixel := 24; + fFormat := tfRGB8ub3; + fWithAlpha := tfRGBA8ub4; + fWithoutAlpha := tfRGB8ub3; + fRGBInverted := tfBGR8ub3; + fPrecision := glBitmapRec4ub(8, 8, 8, 0); + fShift := glBitmapRec4ub(0, 8, 16, 0); + fOpenGLFormat := tfRGB8ub3; + fglFormat := GL_RGB; + fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGB8{$ELSE}GL_RGB{$IFEND}; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdRGB10.Create; +procedure TfdRGBX8ui1.SetValues; begin - inherited Create; - fFormat := tfRGB10; - fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10; - fRGBInverted := tfBGR10; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - 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; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGBX8ui1; + fWithAlpha := tfRGBA8ui1; + fWithoutAlpha := tfRGBX8ui1; + fRGBInverted := tfBGRX8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub(24, 16, 8, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfRGBX8ui1; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +{$ELSE} + fOpenGLFormat := tfRGB8ub3; +{$ENDIF} end; -constructor TfdRGB12.Create; +procedure TfdXRGB8ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfXRGB8ui1; + fWithAlpha := tfXRGB8ui1; + fWithoutAlpha := tfXRGB8ui1; + fOpenGLFormat := tfXRGB8ui1; + fRGBInverted := tfXBGR8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub(16, 8, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfXRGB8ui1; + 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; +{$ELSE} + fOpenGLFormat := tfRGB8ub3; +{$ENDIF} +end; + +procedure TfdRGB10X2ui1.SetValues; begin - inherited Create; - fFormat := tfRGB12; - fWithAlpha := tfRGBA12; - fWithoutAlpha := tfRGB12; - fRGBInverted := tfBGR12; - fglInternalFormat := GL_RGB12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGB10X2ui1; + fWithAlpha := tfRGB10A2ui1; + fWithoutAlpha := tfRGB10X2ui1; + fRGBInverted := tfBGR10X2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub(22, 12, 2, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfRGB10X2ui1; + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB10; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; +{$ELSE} + fOpenGLFormat := tfRGB16us3; +{$ENDIF} end; -constructor TfdRGB16.Create; +procedure TfdX2RGB10ui1.SetValues; begin - inherited Create; - fFormat := tfRGB16; - fWithAlpha := tfRGBA16; - fWithoutAlpha := tfRGB16; - fRGBInverted := tfBGR16; - fglInternalFormat := GL_RGB16; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfX2RGB10ui1; + fWithAlpha := tfA2RGB10ui1; + fWithoutAlpha := tfX2RGB10ui1; + fRGBInverted := tfX2BGR10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub(20, 10, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfX2RGB10ui1; + 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; +{$ELSE} + fOpenGLFormat := tfRGB16us3; +{$ENDIF} end; -constructor TfdRGBA2.Create; +procedure TfdRGB16us3.SetValues; begin - inherited Create; - fFormat := tfRGBA2; - fWithAlpha := tfRGBA2; - fWithoutAlpha := tfR3G3B2; - fRGBInverted := tfBGRA2; - fglInternalFormat := GL_RGBA2; + inherited SetValues; + fBitsPerPixel := 48; + fFormat := tfRGB16us3; + fWithAlpha := tfRGBA16us4; + fWithoutAlpha := tfRGB16us3; + fRGBInverted := tfBGR16us3; + fPrecision := glBitmapRec4ub(16, 16, 16, 0); + fShift := glBitmapRec4ub( 0, 16, 32, 0); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + fOpenGLFormat := tfRGB16us3; + fglFormat := GL_RGB; + fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGB16{$ELSE}GL_RGB16UI{$ENDIF}; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfRGB8ub3; +{$IFEND} end; -constructor TfdRGBA4.Create; +procedure TfdRGBA4us1.SetValues; begin - inherited Create; - fFormat := tfRGBA4; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGB4; - fRGBInverted := tfBGRA4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fRange.a := $F; - fShift.r := 0; - fShift.g := 4; - fShift.b := 8; - fShift.a := 12; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGBA4us1; + fWithAlpha := tfRGBA4us1; + fWithoutAlpha := tfRGBX4us1; + fOpenGLFormat := tfRGBA4us1; + fRGBInverted := tfBGRA4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub(12, 8, 4, 0); fglFormat := GL_RGBA; + fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND}; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +procedure TfdARGB4us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfARGB4us1; + fWithAlpha := tfARGB4us1; + fWithoutAlpha := tfXRGB4us1; + fRGBInverted := tfABGR4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub( 8, 4, 0, 12); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfARGB4us1; + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; +{$ELSE} + fOpenGLFormat := tfRGBA4us1; +{$ENDIF} end; -constructor TfdRGB5A1.Create; +procedure TfdRGB5A1us1.SetValues; begin - inherited Create; - fFormat := tfRGB5A1; - fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5; - 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; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGB5A1us1; + fWithAlpha := tfRGB5A1us1; + fWithoutAlpha := tfRGB5X1us1; + fOpenGLFormat := tfRGB5A1us1; + fRGBInverted := tfBGR5A1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub(11, 6, 1, 0); fglFormat := GL_RGBA; + fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)}GL_RGB5_A1{$ELSE}GL_RGBA{$IFEND}; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +procedure TfdA1RGB5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfA1RGB5us1; + fWithAlpha := tfA1RGB5us1; + fWithoutAlpha := tfX1RGB5us1; + fRGBInverted := tfA1BGR5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub(10, 5, 0, 15); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfA1RGB5us1; + fglFormat := GL_BGRA; fglInternalFormat := GL_RGB5_A1; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; +{$ELSE} + fOpenGLFormat := tfRGB5A1us1; +{$ENDIF} end; -constructor TfdRGBA8.Create; +procedure TfdRGBA8ui1.SetValues; begin - inherited Create; - fFormat := tfRGBA8; - fWithAlpha := tfRGBA8; - fWithoutAlpha := tfRGB8; - fRGBInverted := tfBGRA8; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGBA8ui1; + fWithAlpha := tfRGBA8ui1; + fWithoutAlpha := tfRGBX8ui1; + fRGBInverted := tfBGRA8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub(24, 16, 8, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfRGBA8ui1; + fglFormat := GL_RGBA; fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +{$ELSE} + fOpenGLFormat := tfRGBA8ub4; +{$ENDIF} end; -constructor TfdRGB10A2.Create; +procedure TfdARGB8ui1.SetValues; begin - inherited Create; - fFormat := tfRGB10A2; - fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10; - 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; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfARGB8ui1; + fWithAlpha := tfARGB8ui1; + fWithoutAlpha := tfXRGB8ui1; + fRGBInverted := tfABGR8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub(16, 8, 0, 24); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfARGB8ui1; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; +{$ELSE} + fOpenGLFormat := tfRGBA8ub4; +{$ENDIF} +end; + +procedure TfdRGBA8ub4.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGBA8ub4; + fWithAlpha := tfRGBA8ub4; + fWithoutAlpha := tfRGB8ub3; + fOpenGLFormat := tfRGBA8ub4; + fRGBInverted := tfBGRA8ub4; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub( 0, 8, 16, 24); + fglFormat := GL_RGBA; + fglInternalFormat := {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)}GL_RGBA8{$ELSE}GL_RGBA{$IFEND}; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +procedure TfdRGB10A2ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGB10A2ui1; + fWithAlpha := tfRGB10A2ui1; + fWithoutAlpha := tfRGB10X2ui1; + fRGBInverted := tfBGR10A2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub(22, 12, 2, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfRGB10A2ui1; fglFormat := GL_RGBA; fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; +{$ELSE} + fOpenGLFormat := tfA2RGB10ui1; +{$ENDIF} +end; + +procedure TfdA2RGB10ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfA2RGB10ui1; + fWithAlpha := tfA2RGB10ui1; + fWithoutAlpha := tfX2RGB10ui1; + fRGBInverted := tfA2BGR10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub(20, 10, 0, 30); +{$IF NOT DEFINED(OPENGL_ES)} + fOpenGLFormat := tfA2RGB10ui1; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB10_A2; fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; +{$ELSEIF DEFINED(OPENGL_ES_3_0)} + fOpenGLFormat := tfA2RGB10ui1; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; +{$ELSE} + fOpenGLFormat := tfRGBA8ui1; +{$IFEND} end; -constructor TfdRGBA12.Create; +procedure TfdRGBA16us4.SetValues; begin - inherited Create; - fFormat := tfRGBA12; - fWithAlpha := tfRGBA12; - fWithoutAlpha := tfRGB12; - fRGBInverted := tfBGRA12; - fglInternalFormat := GL_RGBA12; + inherited SetValues; + fBitsPerPixel := 64; + fFormat := tfRGBA16us4; + fWithAlpha := tfRGBA16us4; + fWithoutAlpha := tfRGB16us3; + fRGBInverted := tfBGRA16us4; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 16, 32, 48); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + fOpenGLFormat := tfRGBA16us4; + fglFormat := GL_RGBA; + fglInternalFormat := {$IFNDEF OPENGL_ES}GL_RGBA16{$ELSE}GL_RGBA16UI{$ENDIF}; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfRGBA8ub4; +{$IFEND} end; -constructor TfdRGBA16.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdBGRX4us1.SetValues; begin - inherited Create; - fFormat := tfRGBA16; - fWithAlpha := tfRGBA16; - fWithoutAlpha := tfRGB16; - fRGBInverted := tfBGRA16; - fglInternalFormat := GL_RGBA16; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGRX4us1; + fWithAlpha := tfBGRA4us1; + fWithoutAlpha := tfBGRX4us1; + fRGBInverted := tfRGBX4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 0); + fShift := glBitmapRec4ub( 4, 8, 12, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGRX4us1; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} end; -constructor TfdBGR4.Create; +procedure TfdXBGR4us1.SetValues; begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGR4; - 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 + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfXBGR4us1; + fWithAlpha := tfABGR4us1; + fWithoutAlpha := tfXBGR4us1; + fRGBInverted := tfXRGB4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 0); + fShift := glBitmapRec4ub( 0, 4, 8, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfXBGR4us1; + 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; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TfdB5G6R5.Create; +procedure TfdB5G6R5us1.SetValues; begin - inherited Create; - fFormat := tfB5G6R5; - fWithAlpha := tfBGRA4; - fWithoutAlpha := 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; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfB5G6R5us1; + fWithAlpha := tfBGR5A1us1; + fWithoutAlpha := tfB5G6R5us1; + fRGBInverted := tfR5G6B5us1; + fPrecision := glBitmapRec4ub( 5, 6, 5, 0); + fShift := glBitmapRec4ub( 0, 5, 11, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfB5G6R5us1; + fglFormat := GL_RGB; + fglInternalFormat := GL_RGB565; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} end; -constructor TfdBGR5.Create; +procedure TfdBGR5X1us1.SetValues; begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGR5; - fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5; - fRGBInverted := tfRGB5; - 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 + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGR5X1us1; + fWithAlpha := tfBGR5A1us1; + fWithoutAlpha := tfBGR5X1us1; + fRGBInverted := tfRGB5X1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub( 1, 6, 11, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGR5X1us1; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} +end; + +procedure TfdX1BGR5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfX1BGR5us1; + fWithAlpha := tfA1BGR5us1; + fWithoutAlpha := tfX1BGR5us1; + fRGBInverted := tfX1RGB5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub( 0, 5, 10, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfX1BGR5us1; + 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; +{$ELSE} + fOpenGLFormat := tfR5G6B5us1; +{$ENDIF} end; -constructor TfdBGR8.Create; +procedure TfdBGR8ub3.SetValues; begin - inherited Create; - fFormat := tfBGR8; - fWithAlpha := tfBGRA8; - fWithoutAlpha := tfBGR8; - fRGBInverted := tfRGB8; + inherited SetValues; + fBitsPerPixel := 24; + fFormat := tfBGR8ub3; + fWithAlpha := tfBGRA8ub4; + fWithoutAlpha := tfBGR8ub3; + fRGBInverted := tfRGB8ub3; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub(16, 8, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGR8ub3; + fglFormat := GL_BGR; fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := tfRGB8ub3; +{$ENDIF} end; -constructor TfdBGR10.Create; +procedure TfdBGRX8ui1.SetValues; begin - inherited Create; - fFormat := tfBGR10; - 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; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGRX8ui1; + fWithAlpha := tfBGRA8ui1; + fWithoutAlpha := tfBGRX8ui1; + fRGBInverted := tfRGBX8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub( 8, 16, 24, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGRX8ui1; + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +{$ELSE} + fOpenGLFormat := tfRGB8ub3; +{$ENDIF} +end; + +procedure TfdXBGR8ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfXBGR8ui1; + fWithAlpha := tfABGR8ui1; + fWithoutAlpha := tfXBGR8ui1; + fRGBInverted := tfXRGB8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub( 0, 8, 16, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfXBGR8ui1; + 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; +{$ELSE} + fOpenGLFormat := tfRGB8ub3; +{$ENDIF} +end; + +procedure TfdBGR10X2ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGR10X2ui1; + fWithAlpha := tfBGR10A2ui1; + fWithoutAlpha := tfBGR10X2ui1; + fRGBInverted := tfRGB10X2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub( 2, 12, 22, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGR10X2ui1; 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; +{$ELSE} + fOpenGLFormat := tfRGB16us3; +{$ENDIF} end; -constructor TfdBGR12.Create; +procedure TfdX2BGR10ui1.SetValues; begin - inherited Create; - fFormat := tfBGR12; - fWithAlpha := tfBGRA12; - fWithoutAlpha := tfBGR12; - fRGBInverted := tfRGB12; - fglInternalFormat := GL_RGB12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfX2BGR10ui1; + fWithAlpha := tfA2BGR10ui1; + fWithoutAlpha := tfX2BGR10ui1; + fRGBInverted := tfX2RGB10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub( 0, 10, 20, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfX2BGR10ui1; + 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; +{$ELSE} + fOpenGLFormat := tfRGB16us3; +{$ENDIF} end; -constructor TfdBGR16.Create; +procedure TfdBGR16us3.SetValues; begin - inherited Create; - fFormat := tfBGR16; - fWithAlpha := tfBGRA16; - fWithoutAlpha := tfBGR16; - fRGBInverted := tfRGB16; + inherited SetValues; + fBitsPerPixel := 48; + fFormat := tfBGR16us3; + fWithAlpha := tfBGRA16us4; + fWithoutAlpha := tfBGR16us3; + fRGBInverted := tfRGB16us3; + fPrecision := glBitmapRec4ub(16, 16, 16, 0); + fShift := glBitmapRec4ub(32, 16, 0, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGR16us3; + fglFormat := GL_BGR; fglInternalFormat := GL_RGB16; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfRGB16us3; +{$ENDIF} end; -constructor TfdBGRA2.Create; +procedure TfdBGRA4us1.SetValues; begin - inherited Create; - fFormat := tfBGRA2; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGR4; - fRGBInverted := tfRGBA2; - fglInternalFormat := GL_RGBA2; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGRA4us1; + fWithAlpha := tfBGRA4us1; + fWithoutAlpha := tfBGRX4us1; + fRGBInverted := tfRGBA4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub( 4, 8, 12, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGRA4us1; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +{$ELSE} + fOpenGLFormat := tfRGBA4us1; +{$ENDIF} end; -constructor TfdBGRA4.Create; +procedure TfdABGR4us1.SetValues; 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; - fShift.g := 4; - fShift.b := 0; - fShift.a := 12; - fglFormat := GL_BGRA; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfABGR4us1; + fWithAlpha := tfABGR4us1; + fWithoutAlpha := tfXBGR4us1; + fRGBInverted := tfARGB4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub( 0, 4, 8, 12); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfABGR4us1; + fglFormat := GL_RGBA; fglInternalFormat := GL_RGBA4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; +{$ELSE} + fOpenGLFormat := tfRGBA4us1; +{$ENDIF} end; -constructor TfdBGR5A1.Create; +procedure TfdBGR5A1us1.SetValues; begin - inherited Create; - fFormat := tfBGR5A1; - fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5; - 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; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGR5A1us1; + fWithAlpha := tfBGR5A1us1; + fWithoutAlpha := tfBGR5X1us1; + fRGBInverted := tfRGB5A1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub( 1, 6, 11, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGR5A1us1; fglFormat := GL_BGRA; fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +{$ELSE} + fOpenGLFormat := tfRGB5A1us1; +{$ENDIF} +end; + +procedure TfdA1BGR5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfA1BGR5us1; + fWithAlpha := tfA1BGR5us1; + fWithoutAlpha := tfX1BGR5us1; + fRGBInverted := tfA1RGB5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub( 0, 5, 10, 15); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfA1BGR5us1; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB5_A1; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; +{$ELSE} + fOpenGLFormat := tfRGB5A1us1; +{$ENDIF} end; -constructor TfdBGRA8.Create; +procedure TfdBGRA8ui1.SetValues; begin - inherited Create; - fFormat := tfBGRA8; - fWithAlpha := tfBGRA8; - fWithoutAlpha := tfBGR8; - fRGBInverted := tfRGBA8; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGRA8ui1; + fWithAlpha := tfBGRA8ui1; + fWithoutAlpha := tfBGRX8ui1; + fRGBInverted := tfRGBA8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub( 8, 16, 24, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGRA8ui1; + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +{$ELSE} + fOpenGLFormat := tfRGBA8ub4; +{$ENDIF} end; -constructor TfdBGR10A2.Create; +procedure TfdABGR8ui1.SetValues; begin - inherited Create; - fFormat := tfBGR10A2; - fWithAlpha := tfBGR10A2; - fWithoutAlpha := tfBGR10; - 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; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfABGR8ui1; + fWithAlpha := tfABGR8ui1; + fWithoutAlpha := tfXBGR8ui1; + fRGBInverted := tfARGB8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub( 0, 8, 16, 24); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfABGR8ui1; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; +{$ELSE} + fOpenGLFormat := tfRGBA8ub4 +{$ENDIF} +end; + +procedure TfdBGRA8ub4.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGRA8ub4; + fWithAlpha := tfBGRA8ub4; + fWithoutAlpha := tfBGR8ub3; + fRGBInverted := tfRGBA8ub4; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub(16, 8, 0, 24); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGRA8ub4; + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := tfRGBA8ub4; +{$ENDIF} +end; + +procedure TfdBGR10A2ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGR10A2ui1; + fWithAlpha := tfBGR10A2ui1; + fWithoutAlpha := tfBGR10X2ui1; + fRGBInverted := tfRGB10A2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub( 2, 12, 22, 0); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGR10A2ui1; fglFormat := GL_BGRA; fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; +{$ELSE} + fOpenGLFormat := tfA2RGB10ui1; +{$ENDIF} end; -constructor TfdBGRA12.Create; +procedure TfdA2BGR10ui1.SetValues; begin - inherited Create; - fFormat := tfBGRA12; - fWithAlpha := tfBGRA12; - fWithoutAlpha := tfBGR12; - fRGBInverted := tfRGBA12; - fglInternalFormat := GL_RGBA12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfA2BGR10ui1; + fWithAlpha := tfA2BGR10ui1; + fWithoutAlpha := tfX2BGR10ui1; + fRGBInverted := tfA2RGB10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub( 0, 10, 20, 30); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfA2BGR10ui1; + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; +{$ELSE} + fOpenGLFormat := tfA2RGB10ui1; +{$ENDIF} end; -constructor TfdBGRA16.Create; +procedure TfdBGRA16us4.SetValues; begin - inherited Create; - fFormat := tfBGRA16; - fWithAlpha := tfBGRA16; - fWithoutAlpha := tfBGR16; - fRGBInverted := tfRGBA16; + inherited SetValues; + fBitsPerPixel := 64; + fFormat := tfBGRA16us4; + fWithAlpha := tfBGRA16us4; + fWithoutAlpha := tfBGR16us3; + fRGBInverted := tfRGBA16us4; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub(32, 16, 0, 48); +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfBGRA16us4; + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA16; + fglDataFormat := GL_UNSIGNED_SHORT; +{$ELSE} + fOpenGLFormat := tfRGBA16us4; +{$ENDIF} end; -constructor TfdDepth16.Create; +procedure TfdDepth16us1.SetValues; begin - inherited Create; - fFormat := tfDepth16; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfDepth16; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfDepth16us1; + fWithoutAlpha := tfDepth16us1; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 0, 0, 0); +{$IF NOT DEFINED (OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} + fOpenGLFormat := tfDepth16us1; + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT16; + fglDataFormat := GL_UNSIGNED_SHORT; +{$IFEND} end; -constructor TfdDepth24.Create; +procedure TfdDepth24ui1.SetValues; begin - inherited Create; - fFormat := tfDepth24; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfDepth24; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfDepth24ui1; + fWithoutAlpha := tfDepth24ui1; + fOpenGLFormat := tfDepth24ui1; + fPrecision := glBitmapRec4ub(32, 32, 32, 32); + fShift := glBitmapRec4ub( 0, 0, 0, 0); +{$IF NOT DEFINED (OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + fOpenGLFormat := tfDepth24ui1; + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT24; + fglDataFormat := GL_UNSIGNED_INT; +{$IFEND} end; -constructor TfdDepth32.Create; +procedure TfdDepth32ui1.SetValues; begin - inherited Create; - fFormat := tfDepth32; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfDepth32; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfDepth32ui1; + fWithoutAlpha := tfDepth32ui1; + fPrecision := glBitmapRec4ub(32, 32, 32, 32); + fShift := glBitmapRec4ub( 0, 0, 0, 0); +{$IF NOT DEFINED(OPENGL_ES)} + fOpenGLFormat := tfDepth32ui1; + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT32; + fglDataFormat := GL_UNSIGNED_INT; +{$ELSEIF DEFINED(OPENGL_ES_3_0)} + fOpenGLFormat := tfDepth24ui1; +{$ELSEIF DEFINED(OPENGL_ES_2_0)} + fOpenGLFormat := tfDepth16us1; +{$IFEND} end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3644,25 +4078,30 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; -constructor TfdS3tcDtx1RGBA.Create; +procedure TfdS3tcDtx1RGBA.SetValues; begin - inherited Create; + inherited SetValues; fFormat := tfS3tcDtx1RGBA; fWithAlpha := tfS3tcDtx1RGBA; - fUncompressed := tfRGB5A1; - fPixelSize := 0.5; + fUncompressed := tfRGB5A1us1; + fBitsPerPixel := 4; fIsCompressed := true; +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfS3tcDtx1RGBA; fglFormat := GL_COMPRESSED_RGBA; fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := fUncompressed; +{$ENDIF} end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3670,25 +4109,30 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; -constructor TfdS3tcDtx3RGBA.Create; +procedure TfdS3tcDtx3RGBA.SetValues; begin - inherited Create; + inherited SetValues; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; - fUncompressed := tfRGBA8; - fPixelSize := 1.0; + fUncompressed := tfRGBA8ub4; + fBitsPerPixel := 8; fIsCompressed := true; +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfS3tcDtx3RGBA; fglFormat := GL_COMPRESSED_RGBA; fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := fUncompressed; +{$ENDIF} end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3696,25 +4140,118 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; -constructor TfdS3tcDtx5RGBA.Create; +procedure TfdS3tcDtx5RGBA.SetValues; begin - inherited Create; + inherited SetValues; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; - fUncompressed := tfRGBA8; - fPixelSize := 1.0; + fUncompressed := tfRGBA8ub4; + fBitsPerPixel := 8; fIsCompressed := true; +{$IFNDEF OPENGL_ES} + fOpenGLFormat := tfS3tcDtx3RGBA; fglFormat := GL_COMPRESSED_RGBA; fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; fglDataFormat := GL_UNSIGNED_BYTE; +{$ELSE} + fOpenGLFormat := fUncompressed; +{$ENDIF} +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapFormatDescriptor.GetHasRed: Boolean; +begin + result := (fPrecision.r > 0); +end; + +function TglBitmapFormatDescriptor.GetHasGreen: Boolean; +begin + result := (fPrecision.g > 0); +end; + +function TglBitmapFormatDescriptor.GetHasBlue: Boolean; +begin + result := (fPrecision.b > 0); +end; + +function TglBitmapFormatDescriptor.GetHasAlpha: Boolean; +begin + result := (fPrecision.a > 0); +end; + +function TglBitmapFormatDescriptor.GetHasColor: Boolean; +begin + result := HasRed or HasGreen or HasBlue; +end; + +function TglBitmapFormatDescriptor.GetIsGrayscale: Boolean; +begin + result := (Mask.r = Mask.g) and (Mask.g = Mask.b) and (Mask.r > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapFormatDescriptor.SetValues; +begin + fFormat := tfEmpty; + fWithAlpha := tfEmpty; + fWithoutAlpha := tfEmpty; + fOpenGLFormat := tfEmpty; + fRGBInverted := tfEmpty; + fUncompressed := tfEmpty; + + fBitsPerPixel := 0; + fIsCompressed := false; + + fglFormat := 0; + fglInternalFormat := 0; + fglDataFormat := 0; + + FillChar(fPrecision, 0, SizeOf(fPrecision)); + FillChar(fShift, 0, SizeOf(fShift)); +end; + +procedure TglBitmapFormatDescriptor.CalcValues; +var + i: Integer; +begin + fBytesPerPixel := fBitsPerPixel / 8; + fChannelCount := 0; + for i := 0 to 3 do begin + if (fPrecision.arr[i] > 0) then + inc(fChannelCount); + fRange.arr[i] := (1 shl fPrecision.arr[i]) - 1; + fMask.arr[i] := fRange.arr[i] shl fShift.arr[i]; + end; +end; + +constructor TglBitmapFormatDescriptor.Create; +begin + inherited Create; + SetValues; + CalcValues; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3742,9 +4279,64 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -class function TFormatDescriptor.GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; -begin - result := Get(Get(aFormat).WithAlpha); +class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; +begin + result := Get(Get(aFormat).WithAlpha); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +class function TFormatDescriptor.GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer): TFormatDescriptor; +var + ft: TglBitmapFormat; +begin + // find matching format with OpenGL support + for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + result := Get(ft); + if (result.MaskMatch(aMask)) and + (result.glFormat <> 0) and + (result.glInternalFormat <> 0) and + ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) + then + exit; + end; + + // find matching format without OpenGL Support + for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + result := Get(ft); + if result.MaskMatch(aMask) and ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) then + exit; + end; + + result := TFormatDescriptor.Get(tfEmpty); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +class function TFormatDescriptor.GetFromPrecShift(const aPrec, aShift: TglBitmapRec4ub; const aBitCount: Integer): TFormatDescriptor; +var + ft: TglBitmapFormat; +begin + // find matching format with OpenGL support + for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + result := Get(ft); + if glBitmapRec4ubCompare(result.Shift, aShift) and + glBitmapRec4ubCompare(result.Precision, aPrec) and + (result.glFormat <> 0) and + (result.glInternalFormat <> 0) and + ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) + then + exit; + end; + + // find matching format without OpenGL Support + for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + result := Get(ft); + if glBitmapRec4ubCompare(result.Shift, aShift) and + glBitmapRec4ubCompare(result.Precision, aPrec) and + ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) then + exit; + end; + + result := TFormatDescriptor.Get(tfEmpty); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3771,209 +4363,149 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TBitfieldFormat///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetRedMask(const aValue: QWord); -begin - Update(aValue, fRange.r, fShift.r); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord); -begin - Update(aValue, fRange.g, fShift.g); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord); -begin - Update(aValue, fRange.b, fShift.b); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord); +procedure TbmpBitfieldFormat.SetCustomValues(const aBPP: Integer; aMask: TglBitmapRec4ul); +var + i: Integer; begin - Update(aValue, fRange.a, fShift.a); + for i := 0 to 3 do begin + fShift.arr[i] := 0; + while (aMask.arr[i] > 0) and (aMask.arr[i] and 1 > 0) do begin + aMask.arr[i] := aMask.arr[i] shr 1; + inc(fShift.arr[i]); + end; + fPrecision.arr[i] := CountSetBits(aMask.arr[i]); + end; + CalcValues; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out - aShift: Byte); +procedure TbmpBitfieldFormat.SetCustomValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub); begin - aShift := 0; - aRange := 0; - if (aMask = 0) then - exit; - while (aMask > 0) and ((aMask and 1) = 0) do begin - inc(aShift); - aMask := aMask shr 1; - end; - aRange := 1; - while (aMask > 0) do begin - aRange := aRange shl 1; - aMask := aMask shr 1; - end; - dec(aRange); - - fPixelSize := Round(GetTopMostBit(RedMask or GreenMask or BlueMask or AlphaMask) / 8); + fBitsPerPixel := aBBP; + fPrecision := aPrec; + fShift := aShift; + CalcValues; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var data: QWord; - s: Integer; begin data := - ((aPixel.Data.r and fRange.r) shl fShift.r) or - ((aPixel.Data.g and fRange.g) shl fShift.g) or - ((aPixel.Data.b and fRange.b) shl fShift.b) or - ((aPixel.Data.a and fRange.a) shl fShift.a); - s := Round(fPixelSize); - case s of - 1: aData^ := data; - 2: PWord(aData)^ := data; - 4: PCardinal(aData)^ := data; - 8: PQWord(aData)^ := data; + ((aPixel.Data.r and Range.r) shl Shift.r) or + ((aPixel.Data.g and Range.g) shl Shift.g) or + ((aPixel.Data.b and Range.b) shl Shift.b) or + ((aPixel.Data.a and Range.a) shl Shift.a); + case BitsPerPixel of + 8: aData^ := data; + 16: PWord(aData)^ := data; + 32: PCardinal(aData)^ := data; + 64: PQWord(aData)^ := data; else - raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]); end; - inc(aData, s); + inc(aData, Round(BytesPerPixel)); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var data: QWord; - s, i: Integer; -begin - s := Round(fPixelSize); - case s of - 1: data := aData^; - 2: data := PWord(aData)^; - 4: data := PCardinal(aData)^; - 8: data := PQWord(aData)^; + i: Integer; +begin + case BitsPerPixel of + 8: data := aData^; + 16: data := PWord(aData)^; + 32: data := PCardinal(aData)^; + 64: data := PQWord(aData)^; else - raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]); end; for i := 0 to 3 do - aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i]; - inc(aData, s); + aPixel.Data.arr[i] := (data shr fShift.arr[i]) and Range.arr[i]; + inc(aData, Round(BytesPerPixel)); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TColorTableFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpColorTableFormat.CreateColorTable; -var - i: Integer; +procedure TbmpColorTableFormat.SetValues; begin - if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmapException.Create(UNSUPPORTED_FORMAT); + inherited SetValues; + fShift := glBitmapRec4ub(8, 8, 8, 0); +end; - if (Format = tfLuminance4) then - SetLength(fColorTable, 16) - else - SetLength(fColorTable, 256); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); +begin + fFormat := aFormat; + fBitsPerPixel := aBPP; + fPrecision := aPrec; + fShift := aShift; + CalcValues; +end; - case Format of - tfLuminance4: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := 16 * i; - fColorTable[i].g := 16 * i; - fColorTable[i].b := 16 * i; - fColorTable[i].a := 0; - end; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.CalcValues; +begin + inherited CalcValues; +end; - tfLuminance8: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := i; - fColorTable[i].g := i; - fColorTable[i].b := i; - fColorTable[i].a := 0; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.CreateColorTable; +var + i: Integer; +begin + SetLength(fColorTable, 256); + if not HasColor then begin + // alpha + for i := 0 to High(fColorTable) do begin + fColorTable[i].r := Round(((i shr Shift.a) and Range.a) / Range.a * 255); + fColorTable[i].g := Round(((i shr Shift.a) and Range.a) / Range.a * 255); + fColorTable[i].b := Round(((i shr Shift.a) and Range.a) / Range.a * 255); + fColorTable[i].a := 0; end; - - tfR3G3B2: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255); - fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255); - fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255); - fColorTable[i].a := 0; - end; + end else begin + // normal + for i := 0 to High(fColorTable) do begin + fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255); + fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255); + fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255); + fColorTable[i].a := 0; end; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -var - d: Byte; begin - if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmapException.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 - {%H-}PtrUInt(aMapData))); - inc(aMapData, 4); - if ({%H-}PtrUInt(aMapData) >= 8) then begin - inc(aData); - aMapData := nil; - end; - end; - - tfLuminance8: begin - aData^ := LuminanceWeight(aPixel) and Range.r; - inc(aData); - end; - - tfR3G3B2: begin - aData^ := Round( - ((aPixel.Data.r and Range.r) shl Shift.r) or - ((aPixel.Data.g and Range.g) shl Shift.g) or - ((aPixel.Data.b and Range.b) shl Shift.b)); - inc(aData); - end; - end; + if (BitsPerPixel <> 8) then + raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats'); + if not HasColor then + // alpha + aData^ := aPixel.Data.a + else + // normal + aData^ := Round( + ((aPixel.Data.r and Range.r) shl Shift.r) or + ((aPixel.Data.g and Range.g) shl Shift.g) or + ((aPixel.Data.b and Range.b) shl Shift.b)); + inc(aData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); -var - idx: QWord; - s: Integer; - bits: Byte; - f: Single; -begin - s := Trunc(fPixelSize); - f := fPixelSize - s; - bits := Round(8 * f); - case s of - 0: idx := (aData^ shr (8 - bits - {%H-}PtrUInt(aMapData))) and ((1 shl bits) - 1); - 1: idx := aData^; - 2: idx := PWord(aData)^; - 4: idx := PCardinal(aData)^; - 8: idx := PQWord(aData)^; - else - raise EglBitmapException.CreateFmt('invalid pixel size: %.3f', [fPixelSize]); - end; - if (idx >= Length(fColorTable)) then - raise EglBitmapException.CreateFmt('invalid color index: %d', [idx]); - with fColorTable[idx] do begin +begin + if (BitsPerPixel <> 8) then + raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats'); + with fColorTable[aData^] do begin aPixel.Data.r := r; aPixel.Data.g := g; aPixel.Data.b := b; aPixel.Data.a := a; end; - inc(aMapData, bits); - if ({%H-}PtrUInt(aMapData) >= 8) then begin - inc(aData, 1); - dec(aMapData, 8); - end; - inc(aData, s); + inc(aData, 1); end; destructor TbmpColorTableFormat.Destroy; @@ -3994,7 +4526,7 @@ begin if (aSourceFD.Range.arr[i] > 0) then aPixel.Data.arr[i] := Round(aPixel.Data.arr[i] / aSourceFD.Range.arr[i] * aDestFD.Range.arr[i]) else - aPixel.Data.arr[i] := aDestFD.Range.arr[i]; + aPixel.Data.arr[i] := 0; end; end; end; @@ -4144,6 +4676,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 @@ -4198,6 +4736,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 @@ -4210,9 +4756,9 @@ procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat); begin if fFormat = aValue then exit; - if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then + if TFormatDescriptor.Get(Format).BitsPerPixel <> TFormatDescriptor.Get(aValue).BitsPerPixel then raise EglBitmapUnsupportedFormat.Create(Format); - SetDataPointer(Data, aValue, Width, Height); + SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4249,11 +4795,14 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SetAnisotropic(const aValue: Integer); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)} var MaxAnisotropic: Integer; +{$IFEND} begin fAnisotropic := aValue; if (ID > 0) then begin +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)} if GL_EXT_texture_filter_anisotropic then begin if fAnisotropic > 0 then begin Bind(false); @@ -4265,6 +4814,9 @@ begin end else begin fAnisotropic := 0; end; +{$ELSE} + fAnisotropic := 0; +{$IFEND} end; end; @@ -4278,14 +4830,20 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetupParameters(out aBuildWithGlu: Boolean); +procedure TglBitmap.SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF}); begin // Set Up Parameters SetWrap(fWrapS, fWrapT, fWrapR); SetFilter(fFilterMin, fFilterMag); SetAnisotropic(fAnisotropic); + +{$IFNDEF OPENGL_ES} 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]); +{$ENDIF} +{$IFNDEF OPENGL_ES} // Mip Maps Generation Mode aBuildWithGlu := false; if (MipMap = mmMipmap) then begin @@ -4295,10 +4853,14 @@ begin aBuildWithGlu := true; end else if (MipMap = mmMipmapGlu) then aBuildWithGlu := true; +{$ELSE} + if (MipMap = mmMipmap) then + glTexParameteri(Target, GL_GENERATE_MIPMAP, GL_TRUE); +{$ENDIF} 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; @@ -4309,12 +4871,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; @@ -4325,7 +4886,7 @@ begin fDimension.Y := aHeight; end; - s := TFormatDescriptor.Get(aFormat).PixelSize; + s := TFormatDescriptor.Get(aFormat).BytesPerPixel; fFormat := aFormat; fPixelSize := Ceil(s); fRowSize := Ceil(s * aWidth); @@ -4353,33 +4914,54 @@ begin fID := 0; fTarget := 0; +{$IFNDEF OPENGL_ES} fIsResident := false; +{$ENDIF} - fFormat := glBitmapGetDefaultFormat; fMipMap := glBitmapDefaultMipmap; fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture; fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree; glBitmapGetDefaultFilter (fFilterMin, fFilterMag); glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR); +{$IFNDEF OPENGL_ES} + glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); +{$ENDIF} 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 @@ -4402,7 +4984,8 @@ 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.'); + if not LoadRAW(aStream) then + raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.'); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4416,32 +4999,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 @@ -4450,18 +5023,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); @@ -4490,6 +5062,7 @@ begin ftDDS: SaveDDS(aStream); ftTGA: SaveTGA(aStream); ftBMP: SaveBMP(aStream); + ftRAW: SaveRAW(aStream); end; end; @@ -4519,8 +5092,13 @@ 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 + if (SourceFD.BitsPerPixel <> DestFD.BitsPerPixel) then aCreateTemp := true; // Values @@ -4532,7 +5110,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; @@ -4563,7 +5141,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; @@ -4573,7 +5151,7 @@ begin DestFD.FreeMappingData(DestMD); end; except - if aCreateTemp then + if aCreateTemp and Assigned(TmpData) then FreeMem(TmpData); raise; end; @@ -4634,7 +5212,8 @@ var pSource, pData, pTempData: PByte; Row, RowSize, TempWidth, TempHeight: Integer; IntFormat: TglBitmapFormat; - FormatDesc: TFormatDescriptor; + fd: TFormatDescriptor; + Mask: TglBitmapMask; function GetRowPointer(Row: Integer): pByte; begin @@ -4646,18 +5225,19 @@ begin result := false; 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; + Mask.r := RMask; + Mask.g := GMask; + Mask.b := BMask; + Mask.a := AMask; + IntFormat := TFormatDescriptor.GetFromMask(Mask).Format; if (IntFormat = tfEmpty) then - raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.'); + raise EglBitmap.Create('AssignFromSurface - Invalid Pixelformat.'); end; + fd := TFormatDescriptor.Get(IntFormat); TempWidth := aSurface^.w; TempHeight := aSurface^.h; - RowSize := FormatDesc.GetSize(TempWidth, 1); + RowSize := fd.GetSize(TempWidth, 1); GetMem(pData, TempHeight * RowSize); try pTempData := pData; @@ -4668,10 +5248,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; @@ -4692,14 +5273,14 @@ var begin result := false; if Assigned(Data) then begin - if Format in [tfAlpha8, tfLuminance8Alpha8, tfBGRA8, tfRGBA8] then begin + if Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfBGRA8ub4, tfRGBA8ub4] then begin aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0); AlphaInterleave := 0; case Format of - tfLuminance8Alpha8: + tfLuminance8Alpha8ub2: AlphaInterleave := 1; - tfBGRA8, tfRGBA8: + tfBGRA8ub4, tfRGBA8ub4: AlphaInterleave := 3; end; @@ -4736,7 +5317,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 @@ -4750,35 +5351,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.'); + tfAlpha8ub1, tfLuminance8ub1: begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + end; + tfRGB5A1us1: + aBitmap.PixelFormat := pf15bit; + tfR5G6B5us1: + aBitmap.PixelFormat := pf16bit; + tfRGB8ub3, tfBGR8ub3: + aBitmap.PixelFormat := pf24bit; + tfRGBA8ub4, tfBGRA8ub4: + 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 [tfRGB8ub3, tfRGBA8ub4]) then // swap RGB(A) to BGR(A) + SwapRGB(pData, FileWidth, Format = tfRGBA8ub4); end; - result := true; end; end; @@ -4789,49 +5385,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 := tfLuminance8ub1; pf15bit: - IntFormat := ifRGB5A1; + IntFormat := tfRGB5A1us1; pf16bit: - IntFormat := ifR5G6B5; + IntFormat := tfR5G6B5us1; pf24bit: - IntFormat := ifBGR8; + IntFormat := tfBGR8ub3; pf32bit: - IntFormat := ifBGRA8; - else - raise EglBitmapException.Create('AssignFromBitmap - Invalid Pixelformat.'); + IntFormat := tfBGRA8ub4; + 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; @@ -4846,17 +5437,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 [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfRGBA8ub4, tfBGRA8ub4]) then begin + if Assigned(aBitmap) then begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + aBitmap.Width := Width; + aBitmap.Height := Height; + + case Format of + tfLuminance8Alpha8ub2: AlphaInterleave := 1; - ifRGBA8, ifBGRA8: + tfRGBA8ub4, tfBGRA8ub4: AlphaInterleave := 3; else AlphaInterleave := 0; @@ -4866,8 +5457,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); @@ -4877,7 +5467,6 @@ begin end; end; end; - result := true; end; end; @@ -4885,62 +5474,283 @@ 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 + if not Assigned(Data) then + raise EglBitmap.Create('no pixel data assigned. load data before save'); + + 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 FormatDesc.IsGrayscale 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 := FormatDesc.BitsPerPixel; + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := FormatDesc.BitsPerPixel; + 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; + + if not Assigned(aImage.PixelData) then + raise EglBitmap.Create('error while creating LazIntfImage'); + 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; + Mask: TglBitmapRec4ul; + + procedure CopyConvert; + var + bfFormat: TbmpBitfieldFormat; + pSourceLine, pDestLine: PByte; + pSourceMD, pDestMD: Pointer; + Shift, Prec: TglBitmapRec4ub; + x, y: Integer; + pixel: TglBitmapPixelData; + begin + bfFormat := TbmpBitfieldFormat.Create; + with aImage.DataDescription do begin + Prec.r := RedPrec; + Prec.g := GreenPrec; + Prec.b := BluePrec; + Prec.a := AlphaPrec; + Shift.r := RedShift; + Shift.g := GreenShift; + Shift.b := BlueShift; + Shift.a := AlphaShift; + bfFormat.SetCustomValues(BitsPerPixel, Prec, Shift); + 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.BytesPerPixel * 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; + + with aImage.DataDescription do begin + Mask.r := (QWord(1 shl RedPrec )-1) shl RedShift; + Mask.g := (QWord(1 shl GreenPrec)-1) shl GreenShift; + Mask.b := (QWord(1 shl BluePrec )-1) shl BlueShift; + Mask.a := (QWord(1 shl AlphaPrec)-1) shl AlphaShift; + end; + FormatDesc := TFormatDescriptor.GetFromMask(Mask); + f := FormatDesc.Format; + if (f = tfEmpty) then + exit; + + CanCopy := + (FormatDesc.BitsPerPixel = 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; - RS := TResourceStream.Create(Instance, Resource, TempResType); + 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 - result := AddAlphaFromStream(RS, Func, CustomData); + 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 - RS.Free; + FormatDesc.FreeMappingData(srcMD); end; + result := true; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; - const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var - RS: TResourceStream; + tex: TglBitmap2D; begin - RS := TResourceStream.CreateFromID(Instance, ResourceID, ResType); + tex := TglBitmap2D.Create; try - result := AddAlphaFromStream(RS, Func, CustomData); + tex.AssignFromLazIntfImage(aImage); + result := AddAlphaFromglBitmap(tex, aFunc, aArgs); finally - RS.Free; + tex.Free; end; end; {$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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, aFunc, aArgs); + finally + rs.Free; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; + const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + rs: TResourceStream; +begin + rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); + try + result := AddAlphaFromStream(rs, aFunc, aArgs); + finally + rs.Free; + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; begin if TFormatDescriptor.Get(Format).IsCompressed then @@ -4953,7 +5763,7 @@ function TglBitmap.AddAlphaFromFile(const aFileName: String; const aFunc: TglBit var FS: TFileStream; begin - FS := TFileStream.Create(FileName, fmOpenRead); + FS := TFileStream.Create(aFileName, fmOpenRead); try result := AddAlphaFromStream(FS, aFunc, aArgs); finally @@ -5053,7 +5863,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, @@ -5069,7 +5879,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; @@ -5097,7 +5907,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; @@ -5106,7 +5916,7 @@ function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean; var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); with PixelData do Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha))); result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a); @@ -5142,13 +5952,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; @@ -5183,6 +5996,11 @@ var SourcePD, DestPD: TglBitmapPixelData; ShiftData: TShiftData; + function DataIsIdentical: Boolean; + begin + result := SourceFD.MaskMatch(DestFD.Mask); + end; + function CanCopyDirect: Boolean; begin result := @@ -5215,6 +6033,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); @@ -5237,10 +6061,11 @@ procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean); begin if aUseRGB or aUseAlpha then AddFunc(glBitmapInvertFunc, false, {%H-}Pointer( - ((PtrInt(aUseAlpha) and 1) shl 1) or - (PtrInt(aUseRGB) and 1) )); + ((Byte(aUseAlpha) and 1) shl 1) or + (Byte(aUseRGB) and 1) )); end; +{$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); begin @@ -5253,11 +6078,15 @@ begin glTexParameterfv(Target, GL_TEXTURE_BORDER_COLOR, @fBorderColor[0]); end; end; +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5272,7 +6101,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, @@ -5296,7 +6125,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFilter(const aMin, aMag: Cardinal); +procedure TglBitmap.SetFilter(const aMin, aMag: GLenum); begin //check MIN filter case aMin of @@ -5313,7 +6142,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 @@ -5323,7 +6152,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 @@ -5331,7 +6160,7 @@ begin Bind(false); glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag); - if (MipMap = mmNone) or (Target = GL_TEXTURE_RECTANGLE) then begin + if (MipMap = mmNone) {$IFNDEF OPENGL_ES}or (Target = GL_TEXTURE_RECTANGLE){$ENDIF} then begin case fFilterMin of GL_NEAREST, GL_LINEAR: glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin); @@ -5346,39 +6175,51 @@ 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 case aValue of +{$IFNDEF OPENGL_ES} GL_CLAMP: aTarget := GL_CLAMP; +{$ENDIF} GL_REPEAT: aTarget := GL_REPEAT; GL_CLAMP_TO_EDGE: begin - if GL_VERSION_1_2 or GL_EXT_texture_edge_clamp then - aTarget := GL_CLAMP_TO_EDGE +{$IFNDEF OPENGL_ES} + if not GL_VERSION_1_2 and not GL_EXT_texture_edge_clamp then + aTarget := GL_CLAMP else - aTarget := GL_CLAMP; +{$ENDIF} + aTarget := GL_CLAMP_TO_EDGE; end; +{$IFNDEF OPENGL_ES} GL_CLAMP_TO_BORDER: begin if GL_VERSION_1_3 or GL_ARB_texture_border_clamp then aTarget := GL_CLAMP_TO_BORDER else aTarget := GL_CLAMP; end; +{$ENDIF} +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} GL_MIRRORED_REPEAT: begin + {$IFNDEF OPENGL_ES} if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then + {$ELSE} + if GL_VERSION_2_0 then + {$ENDIF} 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; +{$IFEND} else - raise EglBitmapException.Create('SetWrap - Unknow Texturewrap (S).'); + raise EglBitmap.Create('SetWrap - Unknow Texturewrap'); end; end; @@ -5391,9 +6232,52 @@ begin Bind(false); glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS); glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + {$IFDEF OPENGL_ES} if GL_VERSION_3_0 then{$ENDIF} glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR); +{$IFEND} + end; +end; + +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum); + + procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer); + begin + if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or + (aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then + fSwizzle[aIndex] := aValue + else + raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value'); + end; + +begin +{$IFNDEF OPENGL_ES} + 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'); +{$ELSE} + if not GL_VERSION_3_0 then + raise EglBitmapNotSupported.Create('texture swizzle is not supported'); +{$ENDIF} + CheckAndSetValue(r, 0); + CheckAndSetValue(g, 1); + CheckAndSetValue(b, 2); + CheckAndSetValue(a, 3); + + if (ID > 0) then begin + Bind(false); +{$IFNDEF OPENGL_ES} + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0])); +{$ELSE} + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_R, PGLint(@fSwizzle[0])); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_G, PGLint(@fSwizzle[1])); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_B, PGLint(@fSwizzle[2])); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_A, PGLint(@fSwizzle[3])); +{$ENDIF} end; end; +{$IFEND} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean); @@ -5415,19 +6299,21 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TglBitmap.Create; begin + if (ClassType = TglBitmap) then + raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.'); {$IFDEF GLB_NATIVE_OGL} glbReadOpenGLExtensions; {$ENDIF} - if (ClassType = TglBitmap) then - raise EglBitmapException.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.'); inherited Create; + fFormat := glBitmapGetDefaultFormat; + fFreeDataOnDestroy := true; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TglBitmap.Create(const aFileName: String); begin Create; - LoadFromFile(FileName); + LoadFromFile(aFileName); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5438,32 +6324,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; - ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize); - GetMem(Image, ImageSize); - try - FillChar(Image^, ImageSize, #$FF); - SetDataPointer(Image, aFormat, aSize.X, aSize.Y); - except - FreeMem(Image); - raise; + if not Assigned(aData) then begin + ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize); + GetMem(aData, ImageSize); + try + FillChar(aData^, ImageSize, #$FF); + SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method + except + if Assigned(aData) then + FreeMem(aData); + raise; + end; + end else begin + SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method + fFreeDataOnDestroy := false; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; - const aFunc: TglBitmapFunction; const aArgs: Pointer); +constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); begin Create; LoadFromFunc(aSize, aFunc, aFormat, aArgs); end; -{$IFDEF GLB_DELPHI} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar); begin @@ -5477,14 +6366,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; @@ -5558,20 +6486,20 @@ begin // read informations png_read_info(png, png_info); - // size + // size TempHeight := png_get_image_height(png, png_info); TempWidth := png_get_image_width(png, png_info); // format case png_get_color_type(png, png_info) of PNG_COLOR_TYPE_GRAY: - Format := tfLuminance8; + Format := tfLuminance8ub1; PNG_COLOR_TYPE_GRAY_ALPHA: - Format := tfLuminance8Alpha8; + Format := tfLuminance8Alpha8us1; PNG_COLOR_TYPE_RGB: - Format := tfRGB8; + Format := tfRGB8ub3; PNG_COLOR_TYPE_RGB_ALPHA: - Format := tfRGBA8; + Format := tfRGBA8ub4; else raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); end; @@ -5606,11 +6534,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; @@ -5625,42 +6554,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 := tfLuminance8ub1; COLOR_GRAYSCALEALPHA: - Format := ifLuminanceAlpha; + PngFormat := tfLuminance8Alpha8us1; COLOR_RGB: - Format := ifBGR8; + PngFormat := tfBGR8ub3; COLOR_RGBALPHA: - Format := ifBGRA8; + PngFormat := tfBGRA8ub4; 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 @@ -5697,11 +6628,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 @@ -5721,7 +6653,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 @@ -5741,13 +6695,13 @@ begin try case Format of - tfAlpha8, tfLuminance8: + tfAlpha8ub1, tfLuminance8ub1: ColorType := PNG_COLOR_TYPE_GRAY; - tfLuminance8Alpha8: + tfLuminance8Alpha8us1: ColorType := PNG_COLOR_TYPE_GRAY_ALPHA; - tfBGR8, tfRGB8: + tfBGR8ub3, tfRGB8ub3: ColorType := PNG_COLOR_TYPE_RGB; - tfBGRA8, tfRGBA8: + tfBGRA8ub4, tfRGBA8ub4: ColorType := PNG_COLOR_TYPE_RGBA; else raise EglBitmapUnsupportedFormat.Create(Format); @@ -5782,7 +6736,7 @@ begin // set compression png_set_compression_level(png, 6); - if Format in [tfBGR8, tfBGRA8] then + if Format in [tfBGR8ub3, tfBGRA8ub4] 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); @@ -5812,32 +6766,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 + tfAlpha8ub1, tfLuminance8ub1: begin ColorType := COLOR_GRAYSCALE; - PixSize := 1; - Alpha := false; + PixSize := 1; + Alpha := false; end; - ifLuminanceAlpha: begin + tfLuminance8Alpha8us1: begin ColorType := COLOR_GRAYSCALEALPHA; - PixSize := 1; - Alpha := true; + PixSize := 1; + Alpha := true; end; - ifBGR8, ifRGB8: begin + tfBGR8ub3, tfRGB8ub3: begin ColorType := COLOR_RGB; - PixSize := 3; - Alpha := false; + PixSize := 3; + Alpha := false; end; - ifBGRA8, ifRGBA8: begin + tfBGRA8ub4, tfRGBA8ub4: 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); @@ -5857,7 +6811,7 @@ begin end; // convert RGB line to BGR - if InternalFormat in [ifRGB8, ifRGBA8] then begin + if Format in [tfRGB8ub3, tfRGBA8ub4] then begin pTemp := png.ScanLine[Y]; for X := 0 to Width -1 do begin Temp := pByteArray(pTemp)^[0]; @@ -5870,7 +6824,7 @@ begin // Save to Stream Png.CompressionLevel := 6; - Png.SaveToStream(Stream); + Png.SaveToStream(aStream); finally FreeAndNil(Png); end; @@ -6011,7 +6965,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 @@ -6107,11 +7101,11 @@ begin JCS_GRAYSCALE: begin jpeg.out_color_space := JCS_GRAYSCALE; - IntFormat := tfLuminance8; + IntFormat := tfLuminance8ub1; end; else jpeg.out_color_space := JCS_RGB; - IntFormat := tfRGB8; + IntFormat := tfRGB8ub3; end; // reading image @@ -6138,11 +7132,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; @@ -6163,9 +7158,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 @@ -6173,7 +7168,7 @@ begin try jpg := TJPEGImage.Create; try - jpg.LoadFromStream(Stream); + jpg.LoadFromStream(aStream); bmp.Assign(jpg); result := AssignFromBitmap(bmp); finally @@ -6188,7 +7183,29 @@ end; {$ENDIF} {$IFDEF GLB_SUPPORT_JPEG_WRITE} -{$IF DEFINED(GLB_LIB_JPEG)} +{$IF DEFINED(GLB_LAZ_JPEG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SaveJPEG(const aStream: TStream); +var + jpeg: TJPEGImage; + intf: TLazIntfImage; + raw: TRawImage; +begin + jpeg := TJPEGImage.Create; + intf := TLazIntfImage.Create(0, 0); + try + if not AssignToLazIntfImage(intf) then + raise EglBitmap.Create('unable to create LazIntfImage from glBitmap'); + intf.GetRawImage(raw); + jpeg.LoadFromRawImage(raw, false); + jpeg.SaveToStream(aStream); + finally + intf.Free; + jpeg.Free; + end; +end; + +{$ELSEIF DEFINED(GLB_LIB_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.SaveJPEG(const aStream: TStream); var @@ -6249,11 +7266,11 @@ begin jpeg.image_width := Width; jpeg.image_height := Height; case Format of - tfAlpha8, tfLuminance8: begin + tfAlpha8ub1, tfLuminance8ub1: begin jpeg.input_components := 1; jpeg.in_color_space := JCS_GRAYSCALE; end; - tfRGB8, tfBGR8: begin + tfRGB8ub3, tfBGR8ub3: begin jpeg.input_components := 3; jpeg.in_color_space := JCS_RGB; end; @@ -6264,7 +7281,7 @@ begin jpeg_start_compress(@jpeg, true); pTemp := Data; - if Format = tfBGR8 then + if Format = tfBGR8ub3 then GetMem(pTemp2, fRowSize) else pTemp2 := pTemp; @@ -6272,7 +7289,7 @@ begin try for Row := 0 to jpeg.image_height -1 do begin // prepare row - if Format = tfBGR8 then + if Format = tfBGR8ub3 then CopyRow(pTemp2, pTemp) else pTemp2 := pTemp; @@ -6283,7 +7300,7 @@ begin end; finally // free memory - if Format = tfBGR8 then + if Format = tfBGR8ub3 then FreeMem(pTemp2); end; jpeg_finish_compress(@jpeg); @@ -6295,25 +7312,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 [tfAlpha8ub1, tfLuminance8ub1]) then begin + Jpg.Grayscale := true; Jpg.PixelFormat := jf8Bit; end; Jpg.Assign(Bmp); - Jpg.SaveToStream(Stream); + Jpg.SaveToStream(aStream); finally FreeAndNil(Jpg); end; @@ -6321,8 +7338,67 @@ begin FreeAndNil(Bmp); end; end; +{$IFEND} {$ENDIF} -{$ENDIF} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//RAW///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +type + RawHeader = packed record + Magic: String[5]; + Version: Byte; + Width: Integer; + Height: Integer; + DataSize: Integer; + BitsPerPixel: Integer; + Precision: TglBitmapRec4ub; + Shift: TglBitmapRec4ub; + end; + +function TglBitmap.LoadRAW(const aStream: TStream): Boolean; +var + header: RawHeader; + StartPos: Int64; + fd: TFormatDescriptor; + buf: PByte; +begin + result := false; + StartPos := aStream.Position; + aStream.Read(header{%H-}, SizeOf(header)); + if (header.Magic <> 'glBMP') then begin + aStream.Position := StartPos; + exit; + end; + + fd := TFormatDescriptor.GetFromPrecShift(header.Precision, header.Shift, header.BitsPerPixel); + if (fd.Format = tfEmpty) then + raise EglBitmapUnsupportedFormat.Create('no supported format found'); + + buf := GetMemory(header.DataSize); + aStream.Read(buf^, header.DataSize); + SetDataPointer(buf, fd.Format, header.Width, header.Height); + + result := true; +end; + +procedure TglBitmap.SaveRAW(const aStream: TStream); +var + header: RawHeader; + fd: TFormatDescriptor; +begin + fd := TFormatDescriptor.Get(Format); + header.Magic := 'glBMP'; + header.Version := 1; + header.Width := Width; + header.Height := Height; + header.DataSize := fd.GetSize(fDimension); + header.BitsPerPixel := fd.BitsPerPixel; + header.Precision := fd.Precision; + header.Shift := fd.Shift; + aStream.Write(header, SizeOf(header)); + aStream.Write(Data^, header.DataSize); +end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //BMP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -6362,7 +7438,7 @@ type function TglBitmap.LoadBMP(const aStream: TStream): Boolean; ////////////////////////////////////////////////////////////////////////////////////////////////// - function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapColorRec): TglBitmapFormat; + function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapRec4ul): TglBitmapFormat; begin result := tfEmpty; aStream.Read(aInfo{%H-}, SizeOf(aInfo)); @@ -6372,7 +7448,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean; case aInfo.biCompression of BMP_COMP_RLE4, BMP_COMP_RLE8: begin - raise EglBitmapException.Create('RLE compression is not supported'); + raise EglBitmap.Create('RLE compression is not supported'); end; BMP_COMP_BITFIELDS: begin if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin @@ -6381,16 +7457,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; + 8: result := tfLuminance8ub1; + 16: result := tfX1RGB5us1; + 24: result := tfBGR8ub3; + 32: result := tfXRGB8ui1; end; end; @@ -6402,7 +7478,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean; result := nil; if (aInfo.biBitCount >= 16) then exit; - aFormat := tfLuminance8; + aFormat := tfLuminance8ub1; c := aInfo.biClrUsed; if (c = 0) then c := 1 shl aInfo.biBitCount; @@ -6410,43 +7486,33 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean; for i := 0 to c-1 do begin aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty)); if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then - aFormat := tfRGB8; + aFormat := tfRGB8ub3; end; result := TbmpColorTableFormat.Create; - result.PixelSize := aInfo.biBitCount / 8; - result.ColorTable := ColorTable; - result.Range := glBitmapColorRec($FF, $FF, $FF, $00); + result.BitsPerPixel := aInfo.biBitCount; + result.ColorTable := ColorTable; + result.CalcValues; end; ////////////////////////////////////////////////////////////////////////////////////////////////// - function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapColorRec; - const aInfo: TBMPInfo): TbmpBitfieldFormat; + function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapRec4ul; const aInfo: TBMPInfo): TbmpBitfieldFormat; var - TmpFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; begin result := nil; if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin - for TmpFormat := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin - FormatDesc := TFormatDescriptor.Get(TmpFormat); - if FormatDesc.MaskMatch(aMask.r, aMask.g, aMask.b, aMask.a) then begin - aFormat := FormatDesc.Format; - exit; - end; - end; - + FormatDesc := TFormatDescriptor.GetFromMask(aMask); + if (FormatDesc.Format = tfEmpty) then + exit; + aFormat := FormatDesc.Format; if (aMask.a = 0) and TFormatDescriptor.Get(aFormat).HasAlpha then aFormat := TFormatDescriptor.Get(aFormat).WithoutAlpha; if (aMask.a <> 0) and not TFormatDescriptor.Get(aFormat).HasAlpha then aFormat := TFormatDescriptor.Get(aFormat).WithAlpha; result := TbmpBitfieldFormat.Create; - result.PixelSize := aInfo.biBitCount / 8; - result.RedMask := aMask.r; - result.GreenMask := aMask.g; - result.BlueMask := aMask.b; - result.AlphaMask := aMask.a; + result.SetCustomValues(aInfo.biBitCount, aMask); end; end; @@ -6460,7 +7526,7 @@ var BmpFormat: TglBitmapFormat; //records - Mask: TglBitmapColorRec; + Mask: TglBitmapRec4ul; Header: TBMPHeader; Info: TBMPInfo; @@ -6506,7 +7572,7 @@ begin if (BmpFormat <> tfEmpty) then begin FormatDesc := TFormatDescriptor.Get(BmpFormat); rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize - wbLineSize := Trunc(Info.biWidth * FormatDesc.PixelSize); + wbLineSize := Trunc(Info.biWidth * FormatDesc.BytesPerPixel); Padding := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize; //get Memory @@ -6535,7 +7601,7 @@ begin inc(TmpData, wbLineSize); 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 @@ -6545,11 +7611,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; @@ -6566,7 +7633,7 @@ procedure TglBitmap.SaveBMP(const aStream: TStream); var Header: TBMPHeader; Info: TBMPInfo; - Converter: TbmpColorTableFormat; + Converter: TFormatDescriptor; FormatDesc: TFormatDescriptor; SourceFD, DestFD: Pointer; pData, srcData, dstData, ConvertBuffer: pByte; @@ -6607,44 +7674,36 @@ begin try case Format of - tfLuminance4: 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; - end; - - tfR3G3B2, tfLuminance8: begin + tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1: + 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 + SetCustomValues(fFormat, 1, FormatDesc.Precision, FormatDesc.Shift); + CreateColorTable; + end; end; - tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4, - tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4: begin + tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, + tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1, + tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1: + begin Info.biBitCount := 16; Info.biCompression := BMP_COMP_BITFIELDS; end; - tfBGR8, tfRGB8: begin + tfBGR8ub3, tfRGB8ub3: + begin Info.biBitCount := 24; + if (Format = tfRGB8ub3) then + Converter := TfdBGR8ub3.Create; //use BGR8 Format Descriptor to Swap RGB Values end; - tfRGB10, tfRGB10A2, tfRGBA8, - tfBGR10, tfBGR10A2, tfBGRA8: begin + tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1, + tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1: + begin Info.biBitCount := 32; Info.biCompression := BMP_COMP_BITFIELDS; end; @@ -6659,10 +7718,10 @@ begin Header.bfSize := Header.bfSize + 4 * SizeOf(Cardinal); Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal); - RedMask := FormatDesc.RedMask; - GreenMask := FormatDesc.GreenMask; - BlueMask := FormatDesc.BlueMask; - AlphaMask := FormatDesc.AlphaMask; + RedMask := FormatDesc.Mask.r; + GreenMask := FormatDesc.Mask.g; + BlueMask := FormatDesc.Mask.b; + AlphaMask := FormatDesc.Mask.a; end; // headers @@ -6670,9 +7729,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 @@ -6683,7 +7743,7 @@ begin end; // image data - rbLineSize := Round(Info.biWidth * FormatDesc.PixelSize); + rbLineSize := Round(Info.biWidth * FormatDesc.BytesPerPixel); wbLineSize := Round(Info.biWidth * Info.biBitCount / 8); Padding := GetLineWidth - wbLineSize; PaddingBuff := 0; @@ -6788,13 +7848,15 @@ const 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^; @@ -6825,9 +7887,10 @@ const 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; @@ -6905,9 +7968,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 @@ -6956,33 +8020,37 @@ 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; - 8: tgaFormat := tfAlpha8; + 0: tgaFormat := tfLuminance8ub1; + 8: tgaFormat := tfAlpha8ub1; end; 16: if IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfLuminance16; - 8: tgaFormat := tfLuminance8Alpha8; + 0: tgaFormat := tfLuminance16us1; + 8: tgaFormat := tfLuminance8Alpha8ub2; end else case (Header.ImageDesc and $F) of - 0: tgaFormat := tfBGR5; - 1: tgaFormat := tfBGR5A1; - 4: tgaFormat := tfBGRA4; + 0: tgaFormat := tfX1RGB5us1; + 1: tgaFormat := tfA1RGB5us1; + 4: tgaFormat := tfARGB4us1; end; 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfBGR8; + 0: tgaFormat := tfBGR8ub3; end; - 32: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 2: tgaFormat := tfBGR10A2; - 8: tgaFormat := tfBGRA8; + 32: if IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfDepth32ui1; + end else case (Header.ImageDesc and $F) of + 0: tgaFormat := tfX2RGB10ui1; + 2: tgaFormat := tfA2RGB10ui1; + 8: tgaFormat := tfARGB8ui1; 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); @@ -7020,10 +8088,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 @@ -7037,89 +8106,29 @@ end; procedure TglBitmap.SaveTGA(const aStream: TStream); var Header: TTGAHeader; - LineSize, Size, x, y: Integer; - Pixel: TglBitmapPixelData; - LineBuf, SourceData, DestData: PByte; - SourceMD, DestMD: Pointer; + Size: Integer; FormatDesc: TFormatDescriptor; - Converter: TFormatDescriptor; begin if not (ftTGA in FormatGetSupportedFiles(Format)) then raise EglBitmapUnsupportedFormat.Create(Format); //prepare header + FormatDesc := TFormatDescriptor.Get(Format); FillChar(Header{%H-}, SizeOf(Header), 0); - - //set ImageType - if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8, - tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8]) then - Header.ImageType := TGA_UNCOMPRESSED_GRAY - else - Header.ImageType := TGA_UNCOMPRESSED_RGB; - - //set BitsPerPixel - 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 - Header.Bpp := 16 - else if (Format in [tfBGR8, tfRGB8]) then - Header.Bpp := 24 - else - Header.Bpp := 32; - - //set AlphaBitCount - case Format of - tfRGB5A1, tfBGR5A1: - Header.ImageDesc := 1 and $F; - tfRGB10A2, tfBGR10A2: - Header.ImageDesc := 2 and $F; - tfRGBA4, tfBGRA4: - Header.ImageDesc := 4 and $F; - tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8: - Header.ImageDesc := 8 and $F; - end; - + Header.ImageDesc := CountSetBits(FormatDesc.Range.a) and $F; + Header.Bpp := FormatDesc.BitsPerPixel; Header.Width := Width; Header.Height := Height; Header.ImageDesc := Header.ImageDesc or $20; //flip y + if FormatDesc.IsGrayscale or (not FormatDesc.IsGrayscale and not FormatDesc.HasRed and FormatDesc.HasAlpha) then + Header.ImageType := TGA_UNCOMPRESSED_GRAY + else + Header.ImageType := TGA_UNCOMPRESSED_RGB; aStream.Write(Header, SizeOf(Header)); - // convert RGB(A) to BGR(A) - Converter := nil; - FormatDesc := TFormatDescriptor.Get(Format); - Size := FormatDesc.GetSize(Dimension); - if Format in [tfRGB5, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin - if (FormatDesc.RGBInverted = tfEmpty) then - raise EglBitmapException.Create('inverted RGB format is empty'); - 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'); - end; - - if Assigned(Converter) then begin - LineSize := FormatDesc.GetSize(Width, 1); - LineBuf := GetMem(LineSize); - SourceMD := FormatDesc.CreateMappingData; - DestMD := Converter.CreateMappingData; - try - SourceData := Data; - for y := 0 to Height-1 do begin - DestData := LineBuf; - for x := 0 to Width-1 do begin - FormatDesc.Unmap(SourceData, Pixel, SourceMD); - Converter.Map(Pixel, DestData, DestMD); - end; - aStream.Write(LineBuf^, LineSize); - end; - finally - FreeMem(LineBuf); - FormatDesc.FreeMappingData(SourceMD); - FormatDesc.FreeMappingData(DestMD); - end; - end else - aStream.Write(Data^, Size); + // write Data + Size := FormatDesc.GetSize(Dimension); + aStream.Write(Data^, Size); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -7194,7 +8203,8 @@ var var fd: TFormatDescriptor; i: Integer; - Range: TglBitmapColorRec; + Mask: TglBitmapRec4ul; + Range: TglBitmapRec4ui; match: Boolean; begin result := tfEmpty; @@ -7206,25 +8216,31 @@ var D3DFMT_DXT3: result := tfS3tcDtx3RGBA; D3DFMT_DXT5: result := tfS3tcDtx5RGBA; end; - end else if ((Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0) then begin + end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE or DDPF_ALPHA)) > 0) then begin + // prepare masks + if ((dwFlags and DDPF_LUMINANCE) = 0) then begin + Mask.r := dwRBitMask; + Mask.g := dwGBitMask; + Mask.b := dwBBitMask; + end else begin + Mask.r := dwRBitMask; + Mask.g := dwRBitMask; + Mask.b := dwRBitMask; + end; + if (dwFlags and DDPF_ALPHAPIXELS > 0) then + Mask.a := dwABitMask + else + Mask.a := 0;; //find matching format - for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin - fd := TFormatDescriptor.Get(result); - if fd.MaskMatch(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask) and - (8 * fd.PixelSize = dwRGBBitCount) then - exit; - end; + fd := TFormatDescriptor.GetFromMask(Mask, dwRGBBitCount); + result := fd.Format; + if (result <> tfEmpty) then + exit; //find format with same Range - Range.r := dwRBitMask; - Range.g := dwGBitMask; - Range.b := dwBBitMask; - Range.a := dwABitMask; - for i := 0 to 3 do begin - while ((Range.arr[i] and 1) = 0) and (Range.arr[i] > 0) do - Range.arr[i] := Range.arr[i] shr 1; - end; + for i := 0 to 3 do + Range.arr[i] := (2 shl CountSetBits(Mask.arr[i])) - 1; for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin fd := TFormatDescriptor.Get(result); match := true; @@ -7240,17 +8256,13 @@ var //no format with same range found -> use default if (result = tfEmpty) then begin if (dwABitMask > 0) then - result := tfBGRA8 + result := tfRGBA8ui1 else - result := tfBGR8; + result := tfRGB8ub3; end; Converter := TbmpBitfieldFormat.Create; - Converter.RedMask := dwRBitMask; - Converter.GreenMask := dwGBitMask; - Converter.BlueMask := dwBBitMask; - Converter.AlphaMask := dwABitMask; - Converter.PixelSize := dwRGBBitCount / 8; + Converter.SetCustomValues(dwRGBBitCount, glBitmapRec4ul(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask)); end; end; end; @@ -7287,15 +8299,15 @@ begin end; if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then - raise EglBitmapException.Create('LoadDDS - CubeMaps are not supported'); + raise EglBitmap.Create('LoadDDS - CubeMaps are not supported'); ddsFormat := GetDDSFormat; try if (ddsFormat = tfEmpty) then - raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.'); + raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); FormatDesc := TFormatDescriptor.Get(ddsFormat); - LineSize := Trunc(Header.dwWidth * FormatDesc.PixelSize); + LineSize := Trunc(Header.dwWidth * FormatDesc.BytesPerPixel); GetMem(NewImage, Header.dwHeight * LineSize); try TmpData := NewImage; @@ -7308,7 +8320,8 @@ begin DestMD := FormatDesc.CreateMappingData; try for y := 0 to Header.dwHeight-1 do begin - TmpData := NewImage + y * LineSize; + TmpData := NewImage; + inc(TmpData, y * LineSize); SrcData := RowData; aStream.Read(SrcData^, RowSize); for x := 0 to Header.dwWidth-1 do begin @@ -7341,12 +8354,13 @@ begin Inc(TmpData, LineSize); end; end else - raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.'); + raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); - SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); + SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method result := true; except - FreeMem(NewImage); + if Assigned(NewImage) then + FreeMem(NewImage); raise; end; finally @@ -7365,51 +8379,164 @@ begin 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; + // 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 not FormatDesc.HasColor and FormatDesc.HasAlpha then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; + end else if FormatDesc.IsGrayscale then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; + end else begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; + Header.PixelFormat.dwGBitMask := FormatDesc.Mask.g; + Header.PixelFormat.dwBBitMask := FormatDesc.Mask.b; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; + 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; + +{$IFNDEF OPENGL_ES} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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 + FormatDesc: TFormatDescriptor; +begin + // Upload data + FormatDesc := TFormatDescriptor.Get(Format); + if (FormatDesc.glInternalFormat = 0) or (FormatDesc.glDataFormat = 0) then + raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data'); + + 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); + + // Free Data + if (FreeDataAfterGenTexture) then + FreeData; +end; - Header.dwWidth := Max(1, Width); - Header.dwHeight := Max(1, Height); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean); +var + BuildWithGlu, TexRec: Boolean; + TexSize: Integer; +begin + if Assigned(Data) then begin + // Check Texture Size + if (aTestTextureSize) then begin + glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); - // Caps - Header.Caps.dwCaps1 := DDSCAPS_TEXTURE; + 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.'); - // 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; + 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; - 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; + CreateId; + SetupParameters(BuildWithGlu); + UploadData(BuildWithGlu); + glAreTexturesResident(1, @fID, @fIsResident); + end; +end; - aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC)); - aStream.Write(Header, SizeOf(Header)); - aStream.Write(Data^, FormatDesc.GetSize(Dimension)); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.AfterConstruction; +begin + inherited; + Target := GL_TEXTURE_1D; end; +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TglBitmap2D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -7423,7 +8550,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; @@ -7431,16 +8558,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); + LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).BytesPerPixel); - 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; @@ -7448,36 +8571,29 @@ 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{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF}); var FormatDesc: TFormatDescriptor; begin + FormatDesc := TFormatDescriptor.Get(Format); + if (FormatDesc.glInternalFormat = 0) or (FormatDesc.glDataFormat = 0) then + raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data'); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - 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) +{$IFNDEF OPENGL_ES} end else if aBuildWithGlu then begin - gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height, + gluBuild2DMipmaps(aTarget, FormatDesc.ChannelCount, Width, Height, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) +{$ENDIF} end else begin glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data); @@ -7502,9 +8618,9 @@ var Size, w, h: Integer; FormatDesc: TFormatDescriptor; begin - FormatDesc := TFormatDescriptor.Get(Format); + FormatDesc := TFormatDescriptor.Get(aFormat); if FormatDesc.IsCompressed then - raise EglBitmapUnsupportedFormat.Create(Format); + raise EglBitmapUnsupportedFormat.Create(aFormat); w := aRight - aLeft; h := aBottom - aTop; @@ -7513,21 +8629,23 @@ 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; +{$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap2D.GetDataFromTexture; var Temp: PByte; TempWidth, TempHeight: Integer; - TempIntFormat: Cardinal; - IntFormat, f: TglBitmapFormat; + TempIntFormat: GLint; + IntFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; begin Bind; @@ -7537,34 +8655,35 @@ begin glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_HEIGHT, @TempHeight); glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_INTERNAL_FORMAT, @TempIntFormat); - IntFormat := tfEmpty; - for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin - FormatDesc := TFormatDescriptor.Get(f); - if (FormatDesc.glInternalFormat = TempIntFormat) then begin - IntFormat := FormatDesc.Format; - break; - end; - end; + 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; +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap2D.GenTexture(const aTestTextureSize: Boolean); var - BuildWithGlu, PotTex, TexRec: Boolean; + {$IFNDEF OPENGL_ES} + BuildWithGlu, TexRec: Boolean; + {$ENDIF} + PotTex: Boolean; TexSize: Integer; begin if Assigned(Data) then begin @@ -7573,19 +8692,28 @@ 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); +{$IF NOT DEFINED(OPENGL_ES)} 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.'); +{$ELSEIF DEFINED(OPENGL_ES_EXT)} + if not PotTex and not GL_OES_texture_npot then + raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); +{$ELSE} + if not PotTex then + raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); +{$IFEND} end; CreateId; - SetupParameters(BuildWithGlu); - UploadData(Target, BuildWithGlu); + SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF}); + UploadData(Target{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF}); +{$IFNDEF OPENGL_ES} glAreTexturesResident(1, @fID, @fIsResident); +{$ENDIF} end; end; @@ -7612,10 +8740,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; @@ -7639,10 +8768,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; @@ -7871,228 +9001,104 @@ begin 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; +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//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; +{$IFNDEF OPENGL_ES} 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.'); +{$ELSE} + if not (GL_VERSION_2_0) then + raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.'); +{$ENDIF} - SetWrap; // set all to GL_CLAMP_TO_EDGE - Target := GL_TEXTURE_CUBE_MAP; + SetWrap; + Target := GL_TEXTURE_CUBE_MAP; +{$IFNDEF OPENGL_ES} fGenMode := GL_REFLECTION_MAP; +{$ENDIF} 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; + {$IFNDEF OPENGL_ES} BuildWithGlu: Boolean; + {$ENDIF} 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 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 (Height > TexSize) or (Width > TexSize) then + raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenerateCubeMap - The size for the Cubemap is to large. It''s may be not conform with the Hardware.'); + +{$IF NOT DEFINED(OPENGL_ES)} + 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.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.'); +{$ELSEIF DEFINED(OPENGL_ES_EXT)} + if not (IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) and not GL_OES_texture_npot then + raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.'); +{$ELSE} + if not (IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) then + raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.'); +{$IFEND} 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({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF}); + UploadData(aCubeTarget{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF}); end; - -procedure TglBitmapCubeMap.GenTexture(TestTextureSize: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Bind({$IFNDEF OPENGL_ES}const aEnableTexCoordsGen: Boolean;{$ENDIF} const aEnableTextureUnit: Boolean); begin - Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); + inherited Bind (aEnableTextureUnit); +{$IFNDEF OPENGL_ES} + 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; +{$ENDIF} end; - -procedure TglBitmapCubeMap.Unbind(DisableTexCoordsGen, - DisableTextureUnit: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Unbind({$IFNDEF OPENGL_ES}const aDisableTexCoordsGen: Boolean;{$ENDIF} const aDisableTextureUnit: Boolean); begin - inherited Unbind (DisableTextureUnit); - - if DisableTexCoordsGen then begin + inherited Unbind(aDisableTextureUnit); +{$IFNDEF OPENGL_ES} + if aDisableTexCoordsGen then begin glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); end; +{$ENDIF} end; +{$IFEND} - -{ TglBitmapNormalMap } - +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//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 @@ -8100,62 +9106,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 @@ -8173,72 +9180,73 @@ 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; - +{$IFNDEF OPENGL_ES} fGenMode := GL_NORMAL_MAP; +{$ENDIF} 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, tfBGR8ub3, @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, tfBGR8ub3, @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, tfBGR8ub3, @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, tfBGR8ub3, @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, tfBGR8ub3, @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, tfBGR8ub3, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize); end; -*) +{$IFEND} 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); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA); +{$IFEND} glBitmapSetDefaultFreeDataAfterGenTexture(true); glBitmapSetDefaultDeleteTextureOnFree (true); @@ -8253,9 +9261,15 @@ initialization finalization TFormatDescriptor.Finalize; +{$IFDEF GLB_NATIVE_OGL} + if Assigned(GL_LibHandle) then + glbFreeLibrary(GL_LibHandle); + {$IFDEF GLB_NATIVE_OGL_DYNAMIC} + if Assigned(GLU_LibHandle) then + glbFreeLibrary(GLU_LibHandle); FreeAndNil(InitOpenGLCS); {$ENDIF} +{$ENDIF} end. -