X-Git-Url: https://git.delphigl.com/?a=blobdiff_plain;f=glBitmap.pas;h=1a2f7d6be7fc60e81e30ae41c8a18cc118672321;hb=e406e4032c083428590a055600e5946e892674d4;hp=5bfb8e7993d8cad0eaf1609c616483eb9dd84a12;hpb=77bababf6dbb72075657d5c12282462a96f7b854;p=LazOpenGLCore.git diff --git a/glBitmap.pas b/glBitmap.pas index 5bfb8e7..1a2f7d6 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.0 unstable ------------------------------------------------------------ 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 @@ -218,9 +219,9 @@ 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 warn 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -233,33 +234,39 @@ 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) {.$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} -// activate to enable png support with the unit pngimage. You can download it from http://pngdelphi.sourceforge.net/ + + +// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/ // if you enable pngimage the libPNG will be ignored {.$DEFINE GLB_PNGIMAGE} -// activate to use the libPNG http://www.libpng.org/ -// You will need an aditional header. -// http://www.opengl24.de/index.php?cat=header&file=libpng -{$DEFINE GLB_LIB_PNG} +// activate to use the libPNG -> http://www.libpng.org/ +// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng +{.$DEFINE GLB_LIB_PNG} + + // if you enable delphi jpegs the libJPEG will be ignored {.$DEFINE GLB_DELPHI_JPEG} -// activateto use the libJPEG http://www.ijg.org/ -// You will need an aditional header. -// http://www.opengl24.de/index.php?cat=header&file=libjpeg +// 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} @@ -281,7 +288,7 @@ 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} @@ -357,7 +364,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 +377,30 @@ unit glBitmap; interface uses - {$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF} + {$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF} {$IF DEFINED(GLB_WIN) AND - DEFINED(GLB_NATIVE_OGL)} windows, {$IFEND} - - {$IFDEF GLB_SDL} SDL, {$ENDIF} - {$IFDEF GLB_DELPHI} Dialogs, Graphics, {$ENDIF} + DEFINED(GLB_NATIVE_OGL)} windows, {$IFEND} - {$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF} + {$IFDEF GLB_SDL} SDL, {$ENDIF} + {$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, {$ENDIF} + {$IFDEF GLB_DELPHI} Dialogs, Graphics, {$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 +408,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 +537,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 +566,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 +581,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 +604,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 +612,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 +634,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 +649,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 +658,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 +681,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,22 +703,7 @@ 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 @@ -764,11 +790,13 @@ 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) + constructor Create(const aFormat: TglBitmapFormat); overload; + constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload; end; //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -792,6 +820,23 @@ type Y : Word; end; + TglBitmapFormatDescriptor = class(TObject) + protected + function GetIsCompressed: Boolean; virtual; abstract; + function GetHasAlpha: Boolean; virtual; abstract; + + function GetglDataFormat: GLenum; virtual; abstract; + function GetglFormat: GLenum; virtual; abstract; + function GetglInternalFormat: GLenum; virtual; abstract; + public + property IsCompressed: Boolean read GetIsCompressed; + property HasAlpha: Boolean read GetHasAlpha; + + property glFormat: GLenum read GetglFormat; + property glInternalFormat: GLenum read GetglInternalFormat; + property glDataFormat: GLenum read GetglDataFormat; + end; + //////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap = class; TglBitmapFunctionRec = record @@ -806,6 +851,8 @@ type ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap = class + private + function GetFormatDesc: TglBitmapFormatDescriptor; protected fID: GLuint; fTarget: GLuint; @@ -825,13 +872,16 @@ type fRowSize: Integer; // Filtering - fFilterMin: Cardinal; - fFilterMag: Cardinal; + fFilterMin: GLenum; + fFilterMag: GLenum; // TexturWarp - fWrapS: Cardinal; - fWrapT: Cardinal; - fWrapR: Cardinal; + fWrapS: GLenum; + fWrapT: GLenum; + fWrapR: GLenum; + + //Swizzle + fSwizzle: array[0..3] of GLenum; // CustomData fFilename: String; @@ -860,8 +910,8 @@ type 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 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,6 +930,8 @@ 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; @@ -895,15 +947,15 @@ type 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 +981,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; @@ -963,11 +1024,12 @@ type procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1); //TexParameters - procedure SetFilter(const aMin, aMag: Cardinal); + procedure SetFilter(const aMin, aMag: GLenum); procedure SetWrap( - const S: Cardinal = GL_CLAMP_TO_EDGE; - const T: Cardinal = GL_CLAMP_TO_EDGE; - const R: Cardinal = GL_CLAMP_TO_EDGE); + const S: GLenum = GL_CLAMP_TO_EDGE; + const T: GLenum = GL_CLAMP_TO_EDGE; + const R: GLenum = GL_CLAMP_TO_EDGE); + procedure SetSwizzle(const r, g, b, a: GLenum); procedure Bind(const aEnableTextureUnit: Boolean = true); virtual; procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual; @@ -978,10 +1040,8 @@ type constructor Create(const aStream: TStream); overload; constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat); overload; constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: 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} @@ -1000,24 +1060,26 @@ type end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmap1D = class(TglBitmap) + protected + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; + procedure UploadData(const aBuildWithGlu: Boolean); + public + property Width; + procedure AfterConstruction; override; + function FlipHorz: Boolean; override; + procedure GenTexture(const aTestTextureSize: Boolean = true); override; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmap2D = class(TglBitmap) protected - // Bildeinstellungen fLines: array of PByte; - - (* TODO - procedure GetDXTColorBlock(pData: pByte; relX, relY: Integer; var Pixel: TglBitmapPixelData); - procedure GetPixel2DDXT1(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure GetPixel2DDXT3(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure GetPixel2DDXT5(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure GetPixel2DUnmap(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - procedure SetPixel2DUnmap(const Pos: TglBitmapPixelPosition; const Pixel: TglBitmapPixelData); - *) - function GetScanline(const aIndex: Integer): Pointer; - procedure SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat; + procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; - procedure UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean); + procedure UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); public property Width; property Height; @@ -1036,50 +1098,24 @@ type const aScale: Single = 2; const aUseAlpha: Boolean = false); end; -(* TODO +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapCubeMap = class(TglBitmap2D) protected fGenMode: Integer; - - // Hide GenTexture - procedure GenTexture(TestTextureSize: Boolean = true); reintroduce; + procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce; public procedure AfterConstruction; override; - - procedure GenerateCubeMap(CubeTarget: Cardinal; TestTextureSize: Boolean = true); - - procedure Unbind(DisableTexCoordsGen: Boolean = true; DisableTextureUnit: Boolean = true); reintroduce; virtual; - procedure Bind(EnableTexCoordsGen: Boolean = true; EnableTextureUnit: Boolean = true); reintroduce; virtual; + procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true); + procedure Bind(const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true); reintroduce; virtual; + procedure Unbind(const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true); reintroduce; virtual; end; - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TglBitmapNormalMap = class(TglBitmapCubeMap) public procedure AfterConstruction; override; - - procedure GenerateNormalMap(Size: Integer = 32; TestTextureSize: Boolean = true); - end; - - - TglBitmap1D = class(TglBitmap) - protected - procedure GetPixel1DUnmap(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData); - - procedure SetDataPointer(Data: pByte; Format: TglBitmapInternalFormat; Width: Integer = -1; Height: Integer = -1); override; - procedure UploadData (Target, Format, InternalFormat, Typ: Cardinal; BuildWithGlu: Boolean); - public - // propertys - property Width; - - procedure AfterConstruction; override; - - // Other - function FlipHorz: Boolean; override; - - // Generation - procedure GenTexture(TestTextureSize: Boolean = true); override; + procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true); end; -*) const NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0); @@ -1115,6 +1151,7 @@ var glBitmapDefaultWrapS: Cardinal; glBitmapDefaultWrapT: Cardinal; glBitmapDefaultWrapR: Cardinal; + glDefaultSwizzle: array[0..3] of GLenum; {$IFDEF GLB_DELPHI} function CreateGrayPalette: HPALETTE; @@ -1122,19 +1159,18 @@ 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; type +{$IFNDEF fpc} + QWord = System.UInt64; + PQWord = ^QWord; + + PtrInt = Longint; + PtrUInt = DWord; +{$ENDIF} + //////////////////////////////////////////////////////////////////////////////////////////////////// TShiftRec = packed record case Integer of @@ -1142,7 +1178,7 @@ type 1: (arr: array[0..3] of Byte); end; - TFormatDescriptor = class(TObject) + TFormatDescriptor = class(TglBitmapFormatDescriptor) private function GetRedMask: QWord; function GetGreenMask: QWord; @@ -1160,9 +1196,16 @@ type fRange: TglBitmapColorRec; fShift: TShiftRec; - fglFormat: Cardinal; - fglInternalFormat: Cardinal; - fglDataFormat: Cardinal; + fglFormat: GLenum; + fglInternalFormat: GLenum; + fglDataFormat: GLenum; + + function GetIsCompressed: Boolean; override; + function GetHasAlpha: Boolean; override; + + function GetglFormat: GLenum; override; + function GetglInternalFormat: GLenum; override; + function GetglDataFormat: GLenum; override; function GetComponents: Integer; virtual; public @@ -1172,11 +1215,6 @@ type 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; @@ -1189,14 +1227,13 @@ type 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; procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual; @@ -1660,7 +1697,13 @@ 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; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1777,17 +1820,10 @@ begin result := result + [ftPNG]; {$ENDIF} -(* TODO {$IFDEF GLB_SUPPORT_JPEG_WRITE} - if Format in [ - tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16, - tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16, - tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16, - tfDepth16, tfDepth24, tfDepth32] - then + if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] then result := result + [ftJPEG]; {$ENDIF} - *) end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1846,8 +1882,6 @@ var function glbGetProcAddress(aProcName: PChar; aLibHandle: Pointer = nil): Pointer; begin - result := nil; - if not Assigned(aLibHandle) then aLibHandle := GL_LibHandle; @@ -1872,9 +1906,9 @@ begin end; result := dlsym(aLibHandle, aProcName); -{$ENDIF} +{$IFEND} if not Assigned(result) then - raise EglBitmapException.Create('unable to load procedure form library: ' + aProcName); + raise EglBitmap.Create('unable to load procedure form library: ' + aProcName); end; {$IFDEF GLB_NATIVE_OGL_DYNAMIC} @@ -1895,7 +1929,7 @@ procedure glbInitOpenGL; result := dlopen(Name, RTLD_LAZY); {$ELSE} result := nil; - {$ENDIF} + {$IFEND} end; //////////////////////////////////////////////////////////////////////////////// @@ -1909,7 +1943,7 @@ procedure glbInitOpenGL; Result := FreeLibrary({%H-}HINST(aLibHandle)); {$ELSEIF DEFINED(GLB_LINUX)} Result := dlclose(aLibHandle) = 0; - {$ENDIF} + {$IFEND} end; begin @@ -1921,30 +1955,32 @@ 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} + glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB'); + {$IFEND} glEnable := glbGetProcAddress('glEnable'); glDisable := glbGetProcAddress('glDisable'); glGetString := glbGetProcAddress('glGetString'); glGetIntegerv := glbGetProcAddress('glGetIntegerv'); glTexParameteri := glbGetProcAddress('glTexParameteri'); + glTexParameteriv := glbGetProcAddress('glTexParameteriv'); glTexParameterfv := glbGetProcAddress('glTexParameterfv'); glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv'); glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv'); glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv'); glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv'); + glTexGeni := glbGetProcAddress('glTexGeni'); glGenTextures := glbGetProcAddress('glGenTextures'); glBindTexture := glbGetProcAddress('glBindTexture'); glDeleteTextures := glbGetProcAddress('glDeleteTextures'); @@ -1967,9 +2003,6 @@ end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glbReadOpenGLExtensions; var - {$IFDEF GLB_DELPHI} - Context: HGLRC; - {$ENDIF} Buffer: AnsiString; MajorVersion, MinorVersion: Integer; @@ -2015,6 +2048,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; @@ -2028,99 +2067,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'); + glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB'); + glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB'); end; - - {$IFDEF GLB_TEMPRANGECHECK} - {$UNDEF GLB_TEMPRANGECHECK} - {$R+} - {$ENDIF} - - result := CreatePalette(Pal^); - - FreeMem(Pal); end; {$ENDIF} -*) {$IFDEF GLB_SDL_IMAGE} ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2161,127 +2145,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 @@ -2322,6 +2185,15 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA); +begin + glDefaultSwizzle[0] := r; + glDefaultSwizzle[1] := g; + glDefaultSwizzle[2] := b; + glDefaultSwizzle[3] := a; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmapGetDefaultDeleteTextureOnFree: Boolean; begin result := glBitmapDefaultDeleteTextureOnFree; @@ -2346,14 +2218,14 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal); +procedure glBitmapGetDefaultFilter(var aMin, aMag: GLenum); begin aMin := glBitmapDefaultFilterMin; aMag := glBitmapDefaultFilterMag; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal); +procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum); begin S := glBitmapDefaultWrapS; T := glBitmapDefaultWrapT; @@ -2361,6 +2233,15 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum); +begin + r := glDefaultSwizzle[0]; + g := glDefaultSwizzle[1]; + b := glDefaultSwizzle[2]; + a := glDefaultSwizzle[3]; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.GetRedMask: QWord; @@ -2387,25 +2268,55 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetComponents: Integer; -var - i: Integer; +function TFormatDescriptor.GetIsCompressed: Boolean; begin - result := 0; - for i := 0 to 3 do - if (fRange.arr[i] > 0) then - inc(result); + result := fIsCompressed; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer; -var - w, h: Integer; +function TFormatDescriptor.GetHasAlpha: Boolean; begin - if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin - w := Max(1, aSize.X); - h := Max(1, aSize.Y); - result := GetSize(w, h); + result := (fRange.a > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglFormat: GLenum; +begin + result := fglFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglInternalFormat: GLenum; +begin + result := fglInternalFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetglDataFormat: GLenum; +begin + result := fglDataFormat; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetComponents: Integer; +var + i: Integer; +begin + result := 0; + for i := 0 to 3 do + if (fRange.arr[i] > 0) then + inc(result); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer; +var + w, h: Integer; +begin + if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin + w := Max(1, aSize.X); + h := Max(1, aSize.Y); + result := GetSize(w, h); end else result := 0; end; @@ -2438,19 +2349,11 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.HasAlpha: Boolean; -begin - result := (fRange.a > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; begin result := false; - if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then - raise EglBitmapException.Create('FormatCheckFormat - All Masks are 0'); - + raise EglBitmap.Create('FormatCheckFormat - All Masks are 0'); if (aRedMask <> RedMask) then exit; if (aGreenMask <> GreenMask) then @@ -2507,7 +2410,7 @@ begin aPixel.Data.g := 0; aPixel.Data.b := 0; aPixel.Data.a := aData^; - inc(aData^); + inc(aData); end; constructor TfdAlpha_UB1.Create; @@ -3651,12 +3554,12 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; constructor TfdS3tcDtx1RGBA.Create; @@ -3677,12 +3580,12 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; constructor TfdS3tcDtx3RGBA.Create; @@ -3703,12 +3606,12 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin - raise EglBitmapException.Create('mapping for compressed formats is not supported'); + raise EglBitmap.Create('mapping for compressed formats is not supported'); end; constructor TfdS3tcDtx5RGBA.Create; @@ -3841,7 +3744,7 @@ begin 4: PCardinal(aData)^ := data; 8: PQWord(aData)^ := data; else - raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); end; inc(aData, s); end; @@ -3859,7 +3762,7 @@ begin 4: data := PCardinal(aData)^; 8: data := PQWord(aData)^; else - raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); end; for i := 0 to 3 do aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i]; @@ -3874,7 +3777,7 @@ var i: Integer; begin if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmapException.Create(UNSUPPORTED_FORMAT); + raise EglBitmap.Create(UNSUPPORTED_FORMAT); if (Format = tfLuminance4) then SetLength(fColorTable, 16) @@ -3917,7 +3820,7 @@ var d: Byte; begin if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmapException.Create(UNSUPPORTED_FORMAT); + raise EglBitmap.Create(UNSUPPORTED_FORMAT); case Format of tfLuminance4: begin @@ -3925,7 +3828,7 @@ begin aData^ := 0; d := LuminanceWeight(aPixel) and Range.r; aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData))); - inc(aMapData, 4); + inc(PByte(aMapData), 4); if ({%H-}PtrUInt(aMapData) >= 8) then begin inc(aData); aMapData := nil; @@ -3959,26 +3862,26 @@ begin f := fPixelSize - s; bits := Round(8 * f); case s of - 0: idx := (aData^ shr (8 - bits - {%H-}PtrUInt(aMapData))) and ((1 shl bits) - 1); + 0: idx := (aData^ shr (8 - bits - {%H-}PtrInt(aMapData))) and ((1 shl bits) - 1); 1: idx := aData^; 2: idx := PWord(aData)^; 4: idx := PCardinal(aData)^; 8: idx := PQWord(aData)^; else - raise EglBitmapException.CreateFmt('invalid pixel size: %.3f', [fPixelSize]); + raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]); end; if (idx >= Length(fColorTable)) then - raise EglBitmapException.CreateFmt('invalid color index: %d', [idx]); + raise EglBitmap.CreateFmt('invalid color index: %d', [idx]); with fColorTable[idx] do begin aPixel.Data.r := r; aPixel.Data.g := g; aPixel.Data.b := b; aPixel.Data.a := a; end; - inc(aMapData, bits); + inc(PByte(aMapData), bits); if ({%H-}PtrUInt(aMapData) >= 8) then begin inc(aData, 1); - dec(aMapData, 8); + dec(PByte(aMapData), 8); end; inc(aData, s); end; @@ -4151,6 +4054,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 @@ -4219,7 +4128,7 @@ begin exit; if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize 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; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4293,6 +4202,9 @@ begin SetAnisotropic(fAnisotropic); SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]); + if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then + SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); + // Mip Maps Generation Mode aBuildWithGlu := false; if (MipMap = mmMipmap) then begin @@ -4305,7 +4217,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat; +procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer; const aHeight: Integer); var s: Single; @@ -4369,24 +4281,40 @@ begin glBitmapGetDefaultFilter (fFilterMin, fFilterMag); glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR); + glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.BeforeDestruction; +var + NewData: PByte; begin - SetDataPointer(nil, tfEmpty); + NewData := nil; + SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method 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 @@ -4409,7 +4337,7 @@ begin if not LoadDDS(aStream) then if not LoadTGA(aStream) then if not LoadBMP(aStream) then - raise EglBitmapException.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.'); + raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.'); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -4423,32 +4351,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); 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 @@ -4457,18 +4375,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); @@ -4526,6 +4443,11 @@ begin SourceFD := TFormatDescriptor.Get(aSource.Format); DestFD := TFormatDescriptor.Get(aFormat); + if (SourceFD.IsCompressed) then + raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format); + if (DestFD.IsCompressed) then + raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format); + // inkompatible Formats so CreateTemp if (SourceFD.PixelSize <> DestFD.PixelSize) then aCreateTemp := true; @@ -4539,7 +4461,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; @@ -4570,7 +4492,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; @@ -4580,7 +4502,7 @@ begin DestFD.FreeMappingData(DestMD); end; except - if aCreateTemp then + if aCreateTemp and Assigned(TmpData) then FreeMem(TmpData); raise; end; @@ -4675,10 +4597,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; @@ -4743,7 +4666,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 @@ -4757,35 +4700,30 @@ begin aBitmap.Height := Height; case Format of - tfAlpha8, ifLuminance, ifDepth8: - begin - Bitmap.PixelFormat := pf8bit; - Bitmap.Palette := CreateGrayPalette; - end; - ifRGB5A1: - Bitmap.PixelFormat := pf15bit; - ifR5G6B5: - Bitmap.PixelFormat := pf16bit; - ifRGB8, ifBGR8: - Bitmap.PixelFormat := pf24bit; - ifRGBA8, ifBGRA8: - Bitmap.PixelFormat := pf32bit; - else - raise EglBitmapException.Create('AssignToBitmap - Invalid Pixelformat.'); + tfAlpha8, tfLuminance8: begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + end; + tfRGB5A1: + aBitmap.PixelFormat := pf15bit; + tfR5G6B5: + aBitmap.PixelFormat := pf16bit; + tfRGB8, tfBGR8: + aBitmap.PixelFormat := pf24bit; + tfRGBA8, tfBGRA8: + aBitmap.PixelFormat := pf32bit; + else + raise EglBitmapException.Create('AssignToBitmap - Invalid Pixelformat.'); end; pSource := Data; for Row := 0 to FileHeight -1 do begin - pData := Bitmap.Scanline[Row]; - + pData := aBitmap.Scanline[Row]; Move(pSource^, pData^, fRowSize); Inc(pSource, fRowSize); - - // swap RGB(A) to BGR(A) - if InternalFormat in [ifRGB8, ifRGBA8] then - SwapRGB(pData, FileWidth, InternalFormat = ifRGBA8); + if (Format in [tfRGB8, tfRGBA8]) then // swap RGB(A) to BGR(A) + SwapRGB(pData, FileWidth, Format = tfRGBA8); end; - result := true; end; end; @@ -4796,49 +4734,44 @@ function TglBitmap.AssignFromBitmap(const aBitmap: TBitmap): Boolean; var pSource, pData, pTempData: PByte; Row, RowSize, TempWidth, TempHeight: Integer; - IntFormat: TglBitmapInternalFormat; + IntFormat: TglBitmapFormat; begin result := false; - if (Assigned(Bitmap)) then begin - case Bitmap.PixelFormat of + if (Assigned(aBitmap)) then begin + case aBitmap.PixelFormat of pf8bit: - IntFormat := ifLuminance; + IntFormat := tfLuminance8; pf15bit: - IntFormat := ifRGB5A1; + IntFormat := tfRGB5A1; pf16bit: - IntFormat := ifR5G6B5; + IntFormat := tfR5G6B5; pf24bit: - IntFormat := ifBGR8; + IntFormat := tfBGR8; pf32bit: - IntFormat := ifBGRA8; - else - raise EglBitmapException.Create('AssignFromBitmap - Invalid Pixelformat.'); + IntFormat := tfBGRA8; + else + raise EglBitmapException.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; @@ -4853,17 +4786,17 @@ begin result := false; if Assigned(Data) then begin - if InternalFormat in [ifAlpha, ifLuminanceAlpha, ifRGBA8, ifBGRA8] then begin - if Assigned(Bitmap) then begin - Bitmap.PixelFormat := pf8bit; - Bitmap.Palette := CreateGrayPalette; - Bitmap.Width := Width; - Bitmap.Height := Height; - - case InternalFormat of - ifLuminanceAlpha: + if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin + if Assigned(aBitmap) then begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + aBitmap.Width := Width; + aBitmap.Height := Height; + + case Format of + tfLuminance8Alpha8: AlphaInterleave := 1; - ifRGBA8, ifBGRA8: + tfRGBA8, tfBGRA8: AlphaInterleave := 3; else AlphaInterleave := 0; @@ -4873,8 +4806,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); @@ -4883,8 +4815,7 @@ begin Inc(pSource); end; end; - end; - + end; result := true; end; end; @@ -4892,60 +4823,232 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var tex: TglBitmap2D; begin tex := TglBitmap2D.Create; try - tex.AssignFromBitmap(Bitmap); - result := AddAlphaFromglBitmap(tex, Func, CustomData); + tex.AssignFromBitmap(ABitmap); + result := AddAlphaFromglBitmap(tex, aFunc, aArgs); finally tex.Free; end; end; +{$ENDIF} +{$IFDEF GLB_LAZARUS} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromResource(const aInstance: Cardinal; const aResource: String; const aResType: PChar; - const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean; +function TglBitmap.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; var - RS: TResourceStream; - TempPos: Integer; - ResTypeStr: String; - TempResType: PChar; + rid: TRawImageDescription; + FormatDesc: TFormatDescriptor; begin - if Assigned(ResType) then - TempResType := ResType + result := false; + if not Assigned(aImage) or (Format = tfEmpty) then + exit; + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed then + exit; + + FillChar(rid{%H-}, SizeOf(rid), 0); + if (Format in [ + tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16, + tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16, + tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16]) then + rid.Format := ricfGray else - begin - TempPos := Pos('.', Resource); - ResTypeStr := UpperCase(Copy(Resource, TempPos + 1, Length(Resource) - TempPos)); - Resource := UpperCase(Copy(Resource, 0, TempPos -1)); - TempResType := PChar(ResTypeStr); - end; + rid.Format := ricfRGBA; + + rid.Width := Width; + rid.Height := Height; + rid.Depth := CountSetBits(FormatDesc.Range.r or FormatDesc.Range.g or FormatDesc.Range.b or FormatDesc.Range.a); + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := Round(8 * FormatDesc.PixelSize); + rid.RedPrec := CountSetBits(FormatDesc.Range.r); + rid.GreenPrec := CountSetBits(FormatDesc.Range.g); + rid.BluePrec := CountSetBits(FormatDesc.Range.b); + rid.AlphaPrec := CountSetBits(FormatDesc.Range.a); + rid.RedShift := FormatDesc.Shift.r; + rid.GreenShift := FormatDesc.Shift.g; + rid.BlueShift := FormatDesc.Shift.b; + rid.AlphaShift := FormatDesc.Shift.a; + + rid.MaskBitsPerPixel := 0; + rid.PaletteColorCount := 0; + + aImage.DataDescription := rid; + aImage.CreateData; + + Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension)); + + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; +var + f: TglBitmapFormat; + FormatDesc: TFormatDescriptor; + ImageData: PByte; + ImageSize: Integer; +begin + result := false; + if not Assigned(aImage) then + exit; + for f := High(f) downto Low(f) do begin + FormatDesc := TFormatDescriptor.Get(f); + with aImage.DataDescription do + if FormatDesc.MaskMatch( + (QWord(1 shl RedPrec )-1) shl RedShift, + (QWord(1 shl GreenPrec)-1) shl GreenShift, + (QWord(1 shl BluePrec )-1) shl BlueShift, + (QWord(1 shl AlphaPrec)-1) shl AlphaShift) then + break; + end; + + if (f = tfEmpty) then + exit; + + ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height); + ImageData := GetMem(ImageSize); + try + Move(aImage.PixelData^, ImageData^, (aImage.Width * aImage.Height * aImage.DataDescription.BitsPerPixel) shr 3); + SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method + except + if Assigned(ImageData) then + FreeMem(ImageData); + raise; + end; + + result := true; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; +var + rid: TRawImageDescription; + FormatDesc: TFormatDescriptor; + Pixel: TglBitmapPixelData; + x, y: Integer; + srcMD: Pointer; + src, dst: PByte; +begin + result := false; + if not Assigned(aImage) or (Format = tfEmpty) then + exit; + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then + exit; + + FillChar(rid{%H-}, SizeOf(rid), 0); + rid.Format := ricfGray; + rid.Width := Width; + rid.Height := Height; + rid.Depth := CountSetBits(FormatDesc.Range.a); + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8); + rid.RedPrec := CountSetBits(FormatDesc.Range.a); + rid.GreenPrec := 0; + rid.BluePrec := 0; + rid.AlphaPrec := 0; + rid.RedShift := 0; + rid.GreenShift := 0; + rid.BlueShift := 0; + rid.AlphaShift := 0; + + rid.MaskBitsPerPixel := 0; + rid.PaletteColorCount := 0; + + aImage.DataDescription := rid; + aImage.CreateData; + + srcMD := FormatDesc.CreateMappingData; + try + FormatDesc.PreparePixel(Pixel); + src := Data; + dst := aImage.PixelData; + for y := 0 to Height-1 do + for x := 0 to Width-1 do begin + FormatDesc.Unmap(src, Pixel, srcMD); + case rid.BitsPerPixel of + 8: begin + dst^ := Pixel.Data.a; + inc(dst); + end; + 16: begin + PWord(dst)^ := Pixel.Data.a; + inc(dst, 2); + end; + 24: begin + PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0]; + PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1]; + PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2]; + inc(dst, 3); + end; + 32: begin + PCardinal(dst)^ := Pixel.Data.a; + inc(dst, 4); + end; + else + raise EglBitmapUnsupportedFormat.Create(Format); + end; + end; + finally + FormatDesc.FreeMappingData(srcMD); + end; + result := true; +end; - RS := TResourceStream.Create(Instance, Resource, TempResType); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + tex: TglBitmap2D; +begin + 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: PtrInt): Boolean; + const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; var - RS: TResourceStream; + rs: TResourceStream; begin - RS := TResourceStream.CreateFromID(Instance, ResourceID, ResType); + rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); try - result := AddAlphaFromStream(RS, Func, CustomData); + result := AddAlphaFromStream(rs, aFunc, aArgs); finally - RS.Free; + rs.Free; end; end; -{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; @@ -4960,7 +5063,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 @@ -5149,13 +5252,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; @@ -5263,8 +5369,11 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.FreeData; +var + TempPtr: PByte; begin - SetDataPointer(nil, tfEmpty); + TempPtr := nil; + SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5303,7 +5412,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFilter(const aMin, aMag: Cardinal); +procedure TglBitmap.SetFilter(const aMin, aMag: GLenum); begin //check MIN filter case aMin of @@ -5320,7 +5429,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 @@ -5330,7 +5439,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 @@ -5353,7 +5462,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetWrap(const S: Cardinal; const T: Cardinal; const R: Cardinal); +procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum); procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal); begin @@ -5382,10 +5491,10 @@ procedure TglBitmap.SetWrap(const S: Cardinal; const T: Cardinal; const R: Cardi if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then aTarget := GL_MIRRORED_REPEAT else - raise EglBitmapException.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).'); + raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).'); end; else - raise EglBitmapException.Create('SetWrap - Unknow Texturewrap (S).'); + raise EglBitmap.Create('SetWrap - Unknow Texturewrap'); end; end; @@ -5403,6 +5512,32 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum); + + procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer); + begin + if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or + (aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then + fSwizzle[aIndex] := aValue + else + raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value'); + end; + +begin + if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then + raise EglBitmapNotSupported.Create('texture swizzle is not supported'); + CheckAndSetValue(r, 0); + CheckAndSetValue(g, 1); + CheckAndSetValue(b, 2); + CheckAndSetValue(a, 3); + + if (ID > 0) then begin + Bind(false); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, @fSwizzle[0]); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean); begin if aEnableTextureUnit then @@ -5422,11 +5557,11 @@ 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; end; @@ -5434,7 +5569,7 @@ end; constructor TglBitmap.Create(const aFileName: String); begin Create; - LoadFromFile(FileName); + LoadFromFile(aFileName); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -5455,9 +5590,10 @@ begin GetMem(Image, ImageSize); try FillChar(Image^, ImageSize, #$FF); - SetDataPointer(Image, aFormat, aSize.X, aSize.Y); + SetDataPointer(Image, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method except - FreeMem(Image); + if Assigned(Image) then + FreeMem(Image); raise; end; end; @@ -5470,7 +5606,6 @@ begin LoadFromFunc(aSize, aFunc, aFormat, aArgs); end; -{$IFDEF GLB_DELPHI} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar); begin @@ -5484,7 +5619,6 @@ begin Create; LoadFromResourceID(aInstance, aResourceID, aResType); end; -{$ENDIF} {$IFDEF GLB_SUPPORT_PNG_READ} {$IF DEFINED(GLB_SDL_IMAGE)} @@ -5543,7 +5677,7 @@ begin try // signature StreamPos := aStream.Position; - aStream.Read(signature, 8); + aStream.Read(signature{%H-}, 8); aStream.Position := StreamPos; if png_check_sig(@signature, 8) <> 0 then begin @@ -5613,11 +5747,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; @@ -5632,42 +5767,44 @@ function TglBitmap.LoadPNG(const aStream: TStream): Boolean; var StreamPos: Int64; Png: TPNGObject; - Header: Array[0..7] of Byte; + Header: String[8]; Row, Col, PixSize, LineSize: Integer; NewImage, pSource, pDest, pAlpha: pByte; - Format: TglBitmapInternalFormat; + PngFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; const - PngHeader: Array[0..7] of Byte = (#137, #80, #78, #71, #13, #10, #26, #10); + PngHeader: String[8] = #137#80#78#71#13#10#26#10; begin result := false; - StreamPos := Stream.Position; - Stream.Read(Header[0], SizeOf(Header)); - Stream.Position := StreamPos; + StreamPos := aStream.Position; + aStream.Read(Header[0], SizeOf(Header)); + aStream.Position := StreamPos; {Test if the header matches} if Header = PngHeader then begin Png := TPNGObject.Create; try - Png.LoadFromStream(Stream); + Png.LoadFromStream(aStream); case Png.Header.ColorType of COLOR_GRAYSCALE: - Format := ifLuminance; + PngFormat := tfLuminance8; COLOR_GRAYSCALEALPHA: - Format := ifLuminanceAlpha; + PngFormat := tfLuminance8Alpha8; COLOR_RGB: - Format := ifBGR8; + PngFormat := tfBGR8; COLOR_RGBALPHA: - Format := ifBGRA8; + PngFormat := tfBGRA8; else raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); end; - PixSize := Trunc(FormatGetSize(Format)); - LineSize := Integer(Png.Header.Width) * PixSize; + FormatDesc := TFormatDescriptor.Get(PngFormat); + PixSize := Round(FormatDesc.PixelSize); + LineSize := FormatDesc.GetSize(Png.Header.Width, 1); GetMem(NewImage, LineSize * Integer(Png.Header.Height)); try @@ -5704,11 +5841,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 @@ -5819,32 +5957,32 @@ var pTemp: pByte; Temp: Byte; begin - if not (ftPNG in FormatGetSupportedFiles (InternalFormat)) then - raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT); + if not (ftPNG in FormatGetSupportedFiles (Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); - case FInternalFormat of - ifAlpha, ifLuminance, ifDepth8: begin + case Format of + tfAlpha8, tfLuminance8: begin ColorType := COLOR_GRAYSCALE; - PixSize := 1; - Alpha := false; + PixSize := 1; + Alpha := false; end; - ifLuminanceAlpha: begin + tfLuminance8Alpha8: begin ColorType := COLOR_GRAYSCALEALPHA; - PixSize := 1; - Alpha := true; + PixSize := 1; + Alpha := true; end; - ifBGR8, ifRGB8: begin + tfBGR8, tfRGB8: begin ColorType := COLOR_RGB; - PixSize := 3; - Alpha := false; + PixSize := 3; + Alpha := false; end; - ifBGRA8, ifRGBA8: begin + tfBGRA8, tfRGBA8: begin ColorType := COLOR_RGBALPHA; - PixSize := 3; - Alpha := true + PixSize := 3; + Alpha := true end; else - raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); end; Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height); @@ -5864,7 +6002,7 @@ begin end; // convert RGB line to BGR - if InternalFormat in [ifRGB8, ifRGBA8] then begin + if Format in [tfRGB8, tfRGBA8] then begin pTemp := png.ScanLine[Y]; for X := 0 to Width -1 do begin Temp := pByteArray(pTemp)^[0]; @@ -5877,7 +6015,7 @@ begin // Save to Stream Png.CompressionLevel := 6; - Png.SaveToStream(Stream); + Png.SaveToStream(aStream); finally FreeAndNil(Png); end; @@ -5906,6 +6044,35 @@ type DestBuffer: array [1..4096] of byte; end; +procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl; +begin + //DUMMY +end; + + +procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl; +begin + //DUMMY +end; + + +procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl; +begin + //DUMMY +end; + +procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl; +begin + //DUMMY +end; + + +procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl; +begin + //DUMMY +end; + + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl; var @@ -6024,12 +6191,14 @@ var jpeg: jpeg_decompress_struct; jpeg_err: jpeg_error_mgr; - IntFormat: TglBitmapInternalFormat; + IntFormat: TglBitmapFormat; pImage: pByte; TempHeight, TempWidth: Integer; pTemp: pByte; Row: Integer; + + FormatDesc: TFormatDescriptor; begin result := false; @@ -6038,18 +6207,18 @@ begin try // reading first two bytes to test file and set cursor back to begin - StreamPos := Stream.Position; - Stream.Read(Temp[0], 2); - Stream.Position := StreamPos; + StreamPos := aStream.Position; + aStream.Read({%H-}Temp[0], 2); + aStream.Position := StreamPos; // if Bitmap then read file. if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin - FillChar(jpeg, SizeOf(jpeg_decompress_struct), $00); - FillChar(jpeg_err, SizeOf(jpeg_error_mgr), $00); + FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00); + FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); // error managment jpeg.err := jpeg_std_error(@jpeg_err); - jpeg_err.error_exit := glBitmap_libJPEG_error_exit; + jpeg_err.error_exit := glBitmap_libJPEG_error_exit; jpeg_err.output_message := glBitmap_libJPEG_output_message; // decompression struct @@ -6069,7 +6238,7 @@ begin pub.bytes_in_buffer := 0; // forces fill_input_buffer on first read pub.next_input_byte := nil; // until buffer loaded - SrcStream := Stream; + SrcStream := aStream; end; // set global decoding state @@ -6083,11 +6252,11 @@ begin JCS_GRAYSCALE: begin jpeg.out_color_space := JCS_GRAYSCALE; - IntFormat := ifLuminance; + IntFormat := tfLuminance8; end; else jpeg.out_color_space := JCS_RGB; - IntFormat := ifRGB8; + IntFormat := tfRGB8; end; // reading image @@ -6096,14 +6265,16 @@ begin TempHeight := jpeg.output_height; TempWidth := jpeg.output_width; + FormatDesc := TFormatDescriptor.Get(IntFormat); + // creating new image - GetMem(pImage, FormatGetImageSize(glBitmapPosition(TempWidth, TempHeight), IntFormat)); + GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight)); try pTemp := pImage; for Row := 0 to TempHeight -1 do begin jpeg_read_scanlines(@jpeg, @pTemp, 1); - Inc(pTemp, Trunc(FormatGetSize(IntFormat) * TempWidth)); + Inc(pTemp, FormatDesc.GetSize(TempWidth, 1)); end; // finish decompression @@ -6112,11 +6283,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; @@ -6137,9 +6309,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 @@ -6147,7 +6319,7 @@ begin try jpg := TJPEGImage.Create; try - jpg.LoadFromStream(Stream); + jpg.LoadFromStream(aStream); bmp.Assign(jpg); result := AssignFromBitmap(bmp); finally @@ -6162,9 +6334,9 @@ end; {$ENDIF} {$IFDEF GLB_SUPPORT_JPEG_WRITE} -{$IF DEFEFINED(GLB_LIB_JPEG)} +{$IF DEFINED(GLB_LIB_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveJPEG(Stream: TStream); +procedure TglBitmap.SaveJPEG(const aStream: TStream); var jpeg: jpeg_compress_struct; jpeg_err: jpeg_error_mgr; @@ -6186,18 +6358,18 @@ var begin if not (ftJPEG in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedInternalFormat.Create('SaveJpg - ' + UNSUPPORTED_INTERNAL_FORMAT); + raise EglBitmapUnsupportedFormat.Create(Format); if not init_libJPEG then raise Exception.Create('SaveJPG - unable to initialize libJPEG.'); try - FillChar(jpeg, SizeOf(jpeg_compress_struct), $00); - FillChar(jpeg_err, SizeOf(jpeg_error_mgr), $00); + FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00); + FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); // error managment jpeg.err := jpeg_std_error(@jpeg_err); - jpeg_err.error_exit := glBitmap_libJPEG_error_exit; + jpeg_err.error_exit := glBitmap_libJPEG_error_exit; jpeg_err.output_message := glBitmap_libJPEG_output_message; // compression struct @@ -6215,21 +6387,21 @@ begin pub.next_output_byte := @DestBuffer[1]; pub.free_in_buffer := Length(DestBuffer); - DestStream := Stream; + DestStream := aStream; end; // very important state jpeg.global_state := CSTATE_START; jpeg.image_width := Width; jpeg.image_height := Height; - case InternalFormat of - ifAlpha, ifLuminance, ifDepth8: begin + case Format of + tfAlpha8, tfLuminance8: begin jpeg.input_components := 1; - jpeg.in_color_space := JCS_GRAYSCALE; + jpeg.in_color_space := JCS_GRAYSCALE; end; - ifRGB8, ifBGR8: begin + tfRGB8, tfBGR8: begin jpeg.input_components := 3; - jpeg.in_color_space := JCS_RGB; + jpeg.in_color_space := JCS_RGB; end; end; @@ -6238,7 +6410,7 @@ begin jpeg_start_compress(@jpeg, true); pTemp := Data; - if InternalFormat = ifBGR8 then + if Format = tfBGR8 then GetMem(pTemp2, fRowSize) else pTemp2 := pTemp; @@ -6246,7 +6418,7 @@ begin try for Row := 0 to jpeg.image_height -1 do begin // prepare row - if InternalFormat = ifBGR8 then + if Format = tfBGR8 then CopyRow(pTemp2, pTemp) else pTemp2 := pTemp; @@ -6257,7 +6429,7 @@ begin end; finally // free memory - if InternalFormat = ifBGR8 then + if Format = tfBGR8 then FreeMem(pTemp2); end; jpeg_finish_compress(@jpeg); @@ -6269,25 +6441,25 @@ end; {$ELSEIF DEFINED(GLB_DELPHI_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveJPEG(Stream: TStream); +procedure TglBitmap.SaveJPEG(const aStream: TStream); var Bmp: TBitmap; Jpg: TJPEGImage; begin - if not (ftJPEG in FormatGetSupportedFiles (InternalFormat)) then - raise EglBitmapUnsupportedInternalFormat.Create('SaveJpg - ' + UNSUPPORTED_INTERNAL_FORMAT); + if not (ftJPEG in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); Bmp := TBitmap.Create; try Jpg := TJPEGImage.Create; try AssignToBitmap(Bmp); - if FInternalFormat in [ifAlpha, ifLuminance, ifDepth8] then begin - Jpg.Grayscale := true; + if (Format in [tfAlpha8, tfLuminance8]) then begin + Jpg.Grayscale := true; Jpg.PixelFormat := jf8Bit; end; Jpg.Assign(Bmp); - Jpg.SaveToStream(Stream); + Jpg.SaveToStream(aStream); finally FreeAndNil(Jpg); end; @@ -6295,7 +6467,7 @@ begin FreeAndNil(Bmp); end; end; -{$ENDIF} +{$IFEND} {$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -6346,7 +6518,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 @@ -6355,7 +6527,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean; aStream.Read(aMask.b, SizeOf(aMask.b)); aStream.Read(aMask.a, SizeOf(aMask.a)); end else - raise EglBitmapException.Create('Bitfields are only supported for 16bit and 32bit formats'); + raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats'); end; end; @@ -6509,7 +6681,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 @@ -6519,11 +6691,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; @@ -6762,13 +6935,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^; @@ -6799,9 +6974,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; @@ -6879,9 +7055,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 @@ -6930,6 +7107,7 @@ begin if Header.ImageID <> 0 then // skip image ID aStream.Position := aStream.Position + Header.ImageID; + tgaFormat := tfEmpty; case Header.Bpp of 8: if IsGrayFormat then case (Header.ImageDesc and $F) of 0: tgaFormat := tfLuminance8; @@ -6956,7 +7134,7 @@ begin end; if (tgaFormat = tfEmpty) then - raise EglBitmapException.Create('LoadTga - unsupported format'); + raise EglBitmap.Create('LoadTga - unsupported format'); FormatDesc := TFormatDescriptor.Get(tgaFormat); PixelSize := FormatDesc.GetSize(1, 1); @@ -6994,10 +7172,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 @@ -7065,16 +7244,16 @@ begin Size := FormatDesc.GetSize(Dimension); if Format in [tfRGB5, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin if (FormatDesc.RGBInverted = tfEmpty) then - raise EglBitmapException.Create('inverted RGB format is empty'); + raise EglBitmap.Create('inverted RGB format is empty'); Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted); if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or (Converter.PixelSize <> FormatDesc.PixelSize) then - raise EglBitmapException.Create('invalid inverted RGB format'); + raise EglBitmap.Create('invalid inverted RGB format'); end; if Assigned(Converter) then begin LineSize := FormatDesc.GetSize(Width, 1); - LineBuf := GetMem(LineSize); + GetMem(LineBuf, LineSize); SourceMD := FormatDesc.CreateMappingData; DestMD := Converter.CreateMappingData; try @@ -7261,12 +7440,12 @@ begin end; if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then - raise EglBitmapException.Create('LoadDDS - CubeMaps are not supported'); + raise EglBitmap.Create('LoadDDS - CubeMaps are not supported'); ddsFormat := GetDDSFormat; try if (ddsFormat = tfEmpty) then - raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.'); + raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); FormatDesc := TFormatDescriptor.Get(ddsFormat); LineSize := Trunc(Header.dwWidth * FormatDesc.PixelSize); @@ -7282,7 +7461,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 @@ -7315,12 +7495,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 @@ -7386,6 +7567,112 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap1D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer; const aHeight: Integer); +var + pTemp: pByte; + Size: Integer; +begin + if (aHeight > 1) then begin + Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1); + GetMem(pTemp, Size); + try + Move(aData^, pTemp^, Size); + FreeMem(aData); + aData := nil; + except + FreeMem(pTemp); + raise; + end; + end else + pTemp := aData; + inherited SetDataPointer(pTemp, aFormat, aWidth); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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.IsCompressed then + glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data) + 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; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +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); + + 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.'); + + 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; + + CreateId; + SetupParameters(BuildWithGlu); + UploadData(BuildWithGlu); + glAreTexturesResident(1, @fID, @fIsResident); + end; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.AfterConstruction; +begin + inherited; + Target := GL_TEXTURE_1D; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TglBitmap2D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer; @@ -7397,7 +7684,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; @@ -7405,16 +7692,12 @@ begin inherited SetDataPointer(aData, aFormat, aWidth, aHeight); if not TFormatDescriptor.Get(aFormat).IsCompressed then begin - (* TODO PixelFuncs - fGetPixelFunc := GetPixel2DUnmap; - fSetPixelFunc := SetPixel2DUnmap; - *) // Assigning Data if Assigned(Data) then begin SetLength(fLines, GetHeight); LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).PixelSize); - for Idx := 0 to GetHeight -1 do begin + for Idx := 0 to GetHeight-1 do begin fLines[Idx] := Data; Inc(fLines[Idx], Idx * LineWidth); end; @@ -7422,25 +7705,11 @@ begin else SetLength(fLines, 0); end else begin SetLength(fLines, 0); - (* - fSetPixelFunc := nil; - - case Format of - ifDXT1: - fGetPixelFunc := GetPixel2DDXT1; - ifDXT3: - fGetPixelFunc := GetPixel2DDXT3; - ifDXT5: - fGetPixelFunc := GetPixel2DDXT5; - else - fGetPixelFunc := nil; - end; - *) end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean); +procedure TglBitmap2D.UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean); var FormatDesc: TFormatDescriptor; begin @@ -7448,7 +7717,7 @@ begin FormatDesc := TFormatDescriptor.Get(Format); if FormatDesc.IsCompressed then begin - glCompressedTexImage2D(Target, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) + glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) end else if aBuildWithGlu then begin gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) @@ -7476,9 +7745,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; @@ -7487,10 +7756,11 @@ begin try glPixelStorei(GL_PACK_ALIGNMENT, 1); glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp); - SetDataPointer(Temp, Format, w, h); + SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method FlipVert; except - FreeMem(Temp); + if Assigned(Temp) then + FreeMem(Temp); raise; end; end; @@ -7528,9 +7798,10 @@ begin glGetCompressedTexImage(Target, 0, Temp) else glGetTexImage(Target, 0, FormatDesc.glInternalFormat, FormatDesc.glDataFormat, Temp); - SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); + 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; @@ -7547,13 +7818,12 @@ begin glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); if ((Height > TexSize) or (Width > TexSize)) then - raise EglBitmapSizeToLargeException.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.'); + raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.'); PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width); TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE); - if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then - raise EglBitmapNonPowerOfTwoException.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); + raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); end; CreateId; @@ -7586,10 +7856,11 @@ begin Dec(TempDestData, fPixelSize); end; end; - SetDataPointer(DestData, Format); + SetDataPointer(DestData, Format); //be careful, Data could be freed by this method result := true; except - FreeMem(DestData); + if Assigned(DestData) then + FreeMem(DestData); raise; end; end; @@ -7613,10 +7884,11 @@ begin Dec(TempDestData, fRowSize); Inc(SourceData, fRowSize); end; - SetDataPointer(DestData, Format); + SetDataPointer(DestData, Format); //be careful, Data could be freed by this method result := true; except - FreeMem(DestData); + if Assigned(DestData) then + FreeMem(DestData); raise; end; end; @@ -7845,228 +8117,80 @@ 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; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapCubeMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean); begin - inherited; - - Target := GL_TEXTURE_1D; + Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); end; - -{ TglBitmapCubeMap } - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmapCubeMap.AfterConstruction; begin inherited; if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then - raise EglBitmapException.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.'); + raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.'); - SetWrap; // set all to GL_CLAMP_TO_EDGE - Target := GL_TEXTURE_CUBE_MAP; + SetWrap; + Target := GL_TEXTURE_CUBE_MAP; fGenMode := GL_REFLECTION_MAP; end; - -procedure TglBitmapCubeMap.Bind(EnableTexCoordsGen, EnableTextureUnit: Boolean); -begin - inherited Bind (EnableTextureUnit); - - if EnableTexCoordsGen then begin - glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode); - glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode); - glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode); - glEnable(GL_TEXTURE_GEN_S); - glEnable(GL_TEXTURE_GEN_T); - glEnable(GL_TEXTURE_GEN_R); - end; -end; - - -procedure TglBitmapCubeMap.GenerateCubeMap(CubeTarget: Cardinal; TestTextureSize: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean); var - glFormat, glInternalFormat, glType: Cardinal; BuildWithGlu: Boolean; TexSize: Integer; begin - // Check Texture Size - if (TestTextureSize) then begin + if (aTestTextureSize) then begin glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize); - if ((Height > TexSize) or (Width > TexSize)) then - raise EglBitmapSizeToLargeException.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.'); + if (Height > TexSize) or (Width > TexSize) then + raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.'); - if not ((IsPowerOfTwo (Height) and IsPowerOfTwo (Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then - raise EglBitmapNonPowerOfTwoException.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.'); + if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then + raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.'); end; - // create Texture - if ID = 0 then begin + if (ID = 0) then CreateID; - SetupParameters(BuildWithGlu); - end; - - SelectFormat(InternalFormat, glFormat, glInternalFormat, glType); - - UploadData (CubeTarget, glFormat, glInternalFormat, glType, BuildWithGlu); + SetupParameters(BuildWithGlu); + UploadData(aCubeTarget, BuildWithGlu); end; - -procedure TglBitmapCubeMap.GenTexture(TestTextureSize: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Bind(const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean); begin - Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); + inherited Bind (aEnableTextureUnit); + if aEnableTexCoordsGen then begin + glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode); + glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode); + glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode); + glEnable(GL_TEXTURE_GEN_S); + glEnable(GL_TEXTURE_GEN_T); + glEnable(GL_TEXTURE_GEN_R); + end; end; - -procedure TglBitmapCubeMap.Unbind(DisableTexCoordsGen, - DisableTextureUnit: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.Unbind(const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean); begin - inherited Unbind (DisableTextureUnit); - - if DisableTexCoordsGen then begin + inherited Unbind(aDisableTextureUnit); + if aDisableTexCoordsGen then begin glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); end; end; - -{ TglBitmapNormalMap } - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapNormalMap////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// type TVec = Array[0..2] of Single; - TglBitmapNormalMapGetVectorFunc = procedure (var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer); + TglBitmapNormalMapGetVectorFunc = procedure (out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer); PglBitmapNormalMapRec = ^TglBitmapNormalMapRec; TglBitmapNormalMapRec = record @@ -8074,62 +8198,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 @@ -8147,72 +8272,69 @@ begin end; // Set Color - Dest.Red := Round(Vec[0] * 255); - Dest.Green := Round(Vec[1] * 255); - Dest.Blue := Round(Vec[2] * 255); + for i := 0 to 2 do + Dest.Data.arr[i] := Round(Vec[i] * 255); end; end; - +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmapNormalMap.AfterConstruction; begin inherited; - fGenMode := GL_NORMAL_MAP; end; - -procedure TglBitmapNormalMap.GenerateNormalMap(Size: Integer; - TestTextureSize: Boolean); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean); var Rec: TglBitmapNormalMapRec; SizeRec: TglBitmapPixelPosition; begin - Rec.HalfSize := Size div 2; - + Rec.HalfSize := aSize div 2; FreeDataAfterGenTexture := false; SizeRec.Fields := [ffX, ffY]; - SizeRec.X := Size; - SizeRec.Y := Size; + SizeRec.X := aSize; + SizeRec.Y := aSize; // Positive X Rec.Func := glBitmapNormalMapPosX; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize); // Negative X Rec.Func := glBitmapNormalMapNegX; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize); // Positive Y Rec.Func := glBitmapNormalMapPosY; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize); // Negative Y Rec.Func := glBitmapNormalMapNegY; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize); // Positive Z Rec.Func := glBitmapNormalMapPosZ; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize); // Negative Z Rec.Func := glBitmapNormalMapNegZ; - LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, TestTextureSize); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize); end; -*) + initialization - glBitmapSetDefaultFormat(tfEmpty); - glBitmapSetDefaultMipmap(mmMipmap); - glBitmapSetDefaultFilter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR); - glBitmapSetDefaultWrap (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE); + glBitmapSetDefaultFormat (tfEmpty); + glBitmapSetDefaultMipmap (mmMipmap); + glBitmapSetDefaultFilter (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR); + glBitmapSetDefaultWrap (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE); + glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA); glBitmapSetDefaultFreeDataAfterGenTexture(true); glBitmapSetDefaultDeleteTextureOnFree (true);