*)
type
- EglBitmapException = class(Exception);
- EglBitmapSizeToLargeException = class(EglBitmapException);
- EglBitmapNonPowerOfTwoException = class(EglBitmapException);
- EglBitmapUnsupportedInternalFormat = class(EglBitmapException);
+////////////////////////////////////////////////////////////////////////////////////////////////////
+ EglBitmapException = class(Exception);
+ EglBitmapSizeToLargeException = class(EglBitmapException);
+ EglBitmapNonPowerOfTwoException = class(EglBitmapException);
+ EglBitmapUnsupportedFormatFormat = class(EglBitmapException);
+////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmapPixelDesc = packed record
RedRange: Cardinal;
- GreenRange: Cardinal;
- BlueRange: Cardinal;
- AlphaRange: Cardinal;
-
RedShift: Shortint;
+ GreenRange: Cardinal;
GreenShift: Shortint;
+ BlueRange: Cardinal;
BlueShift: Shortint;
+ AlphaRange: Cardinal;
AlphaShift: Shortint;
end;
+////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmapPixelData = packed record
Red: Cardinal;
Green: Cardinal;
PixelDesc: TglBitmapPixelDesc;
end;
+////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglBitmapFormatDesc = packed record
+ Format: Cardinal;
+ InternalFormat: Cardinal;
+ DataType: Cardinal;
+ end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmapPixelPositionFields = set of (ffX, ffY);
TglBitmapPixelPosition = record
Fields : TglBitmapPixelPositionFields;
Y : Word;
end;
-const
- NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0);
-
-type
+////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmap = class;
-
TglBitmapFunctionRec = record
Sender : TglBitmap;
Size: TglBitmapPixelPosition;
Dest: TglBitmapPixelData;
CustomData: Pointer;
end;
-
TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
- TglBitmapGetPixel = procedure (
- const Pos: TglBitmapPixelPosition;
- var Pixel: TglBitmapPixelData) of object;
-
- TglBitmapSetPixel = procedure (
- const Pos: TglBitmapPixelPosition;
- const Pixel: TglBitmapPixelData) of object;
-
+////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmapFileType = (
{$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG, {$ENDIF}
{$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF}
mmNone,
mmMipmap,
mmMipmapGlu);
+
TglBitmapNormalMapFunc = (
nm4Samples,
nmSobel,
nm3x3,
nm5x5);
+
TglBitmapFormat = (
- tfRed = GL_RED,
- tfGreen = GL_GREEN,
- tfBlue = GL_BLUE,
- tfAlpha = GL_ALPHA,
- tfRGB = GL_RGB,
- tfBGR = GL_BGR,
- tfRGBA = GL_RGBA,
- tfBGRA = GL_BGRA,
- tfLuminance = GL_LUMINANCE,
- tfLuminanceAlpha = GL_LUMINANCE_ALPHA
- );
- TglBitmapInternalFormat = (
- ifAlpha4 = GL_ALPHA4,
- ifAlpha8 = GL_ALPHA8,
- ifAlpha12 = GL_ALPHA12,
- ifAlpha16 = GL_ALPHA16,
-
- ifLuminance4 = GL_LUMINANCE4,
- ifLuminance8 = GL_LUMINANCE8,
- ifLuminance12 = GL_LUMINANCE12,
- ifLuminance16 = GL_LUMINANCE16,
-
- ifLuminance4Alpha4 = GL_LUMINANCE4_ALPHA4,
- ifLuminance6Alpha2 = GL_LUMINANCE6_ALPHA2,
- ifLuminance8Alpha8 = GL_LUMINANCE8_ALPHA8,
- ifLuminance12Alpha4 = GL_LUMINANCE12_ALPHA4,
- ifLuminance12Alpha12 = GL_LUMINANCE12_ALPHA12,
- ifLuminance16Alpha16 = GL_LUMINANCE16_ALPHA16,
-
- ifR3G3B2 = GL_R3_G3_B2,
- ifRGB4 = GL_RGB4,
- ifRGB5 = GL_RGB5,
- ifRGB8 = GL_RGB8,
- ifRGB10 = GL_RGB10,
- ifRGB12 = GL_RGB12,
- ifRGB16 = GL_RGB16,
-
- ifRGBA2 = GL_RGBA2,
- ifRGBA4 = GL_RGBA4,
- ifRGB5A1 = GL_RGB5_A1,
- ifRGBA8 = GL_RGBA8,
- ifRGB10A2 = GL_RGB10_A2,
- ifRGBA12 = GL_RGBA12,
- ifRGBA16 = GL_RGBA16,
-
- ifDepth16 = GL_DEPTH_COMPONENT16,
- ifDepth24 = GL_DEPTH_COMPONENT24,
- ifDepth32 = GL_DEPTH_COMPONENT32
+ tfEmpty = 0,
+ { TODO
+ tfAlpha4,
+ tfAlpha8,
+ tfAlpha12,
+ tfAlpha16,
+
+ tfLuminance4, }
+ tfLuminance8,
+{ tfLuminance12,
+ tfLuminance16,
+
+ tfuminance4Alpha4,
+ tfLuminance6Alpha2,}
+ tfLuminance8Alpha8,
+{ tfLuminance12Alpha4,
+ tfLuminance12Alpha12,
+ tfLuminance16Alpha16,
+
+ tfR3G3B2,
+ tfRGB4,
+ tfRGB5, }
+ tfRGB8,
+{ tfRGB10,
+ tfRGB12,
+ tfRGB16,
+
+ tfRGBA2,
+ tfRGBA4,
+ tfRGB5A1, }
+ tfRGBA8,
+{ tfRGB10A2,
+ tfRGBA12,
+ tfRGBA16,
+ }
+ tfBGR8,
+ tfBGRA8,
+ {
+ tfDepth16,
+ tfDepth24,
+ tfDepth32 }
);
- // Pixelmapping
+////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglBitmapGetPixel = procedure(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData) of object;
+ TglBitmapSetPixel = procedure(const Pos: TglBitmapPixelPosition; const Pixel: TglBitmapPixelData) of object;
+
TglBitmapMapFunc = procedure(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
TglBitmapUnMapFunc = procedure(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
+////////////////////////////////////////////////////////////////////////////////////////////////////
+ TglBitmapFormatDescriptor = class(TObject)
+ public
+ //virtual abstract
+ class function GetFormat: TglBitmapFormat; virtual; abstract;
+ class function GetPixelDesc: TglBitmapPixelDesc; virtual; abstract;
+ class function GetFormatDesc: TglBitmapFormatDesc; virtual; abstract;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); virtual; abstract;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); virtual; abstract;
+
+ //virtual
+ class function WithoutAlpha: TglBitmapFormat; virtual;
+ class function WithAlpha: TglBitmapFormat; virtual;
+
+ class function IsEmpty: Boolean; virtual;
+ class function HasAlpha: Boolean; virtual;
+ class function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: UInt64): Boolean; virtual;
+
+ class procedure PreparePixel(var aPixel: TglBitmapPixelData); virtual;
+
+ (* 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;
+ *)
+ end;
+ TglBitmapFormatDescClass = class of TglBitmapFormatDescriptor;
+
// Base Class
TglBitmap = class
protected
fDimension: TglBitmapPixelPosition;
fMipMap: TglBitmapMipMap;
fFormat: TglBitmapFormat;
- fInternalFormat: TglBitmapInternalFormat;
// Mapping
fPixelSize: Integer;
procedure SetMipMap(const aValue: TglBitmapMipMap);
procedure SetTarget(const aValue: Cardinal);
procedure SetAnisotropic(const aValue: Integer);
- procedure SetInternalFormat(const aValue: TglBitmapInternalFormat);
//Load
{$IFDEF GLB_SUPPORT_PNG_READ}
procedure SaveBMP(Stream: TStream); virtual;
procedure CreateID;
- procedure SetupParameters(var BuildWithGlu: Boolean);
- procedure SelectFormat(DataFormat: TglBitmapInternalFormat; var glFormat, glInternalFormat, glType: Cardinal; CanConvertImage: Boolean = True);
+ procedure SetupParameters(var aBuildWithGlu: Boolean);
+ procedure SelectFormat(const aFormat: TglBitmapFormat; var glFormat, glInternalFormat, glType: Cardinal);
- procedure SetDataPointer(NewData: pByte; Format: TglBitmapInternalFormat; Width: Integer = -1; Height: Integer = -1); virtual;
+ procedure SetDataPointer(NewData: pByte; Format: TglBitmapFormat; Width: Integer = -1; Height: Integer = -1); virtual;
procedure GenTexture(TestTextureSize: Boolean = True); virtual; abstract;
function FlipHorz: Boolean; virtual;
property Width: Integer read GetWidth;
property Height: Integer read GetHeight;
public
- property ID: Cardinal read fID write SetID;
- property Target: Cardinal read fTarget write SetTarget;
- property Format: TglBitmapFormat read fFormat write SetFormat;
- property InternalFormat: TglBitmapInternalFormat read fInternalFormat write SetInternalFormat;
- property MipMap: TglBitmapMipMap read fMipMap write SetMipMap;
- property Anisotropic: Integer read fAnisotropic write SetAnisotropic;
+ property ID: Cardinal read fID write SetID;
+ property Target: Cardinal read fTarget write SetTarget;
+ property Format: TglBitmapFormat read fFormat write SetFormat;
+ property MipMap: TglBitmapMipMap read fMipMap write SetMipMap;
+ property Anisotropic: Integer read fAnisotropic write SetAnisotropic;
property Filename: String read fFilename;
property CustomName: String read fCustomName write SetCustomName;
procedure LoadFromFile(const aFileName: String);
procedure LoadFromStream(const aStream: TStream); virtual;
procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction;
- const aFormat: TglBitmapFormat; const aInternalFormat: TglBitmapInternalFormat;
- const aArgs: PtrInt = 0);
+ const aFormat: TglBitmapFormat; const aArgs: PtrInt = 0);
{$IFDEF GLB_DELPHI}
- procedure LoadFromResource(Instance: Cardinal; Resource: String; ResType: PChar = nil);
- procedure LoadFromResourceID(Instance: Cardinal; ResourceID: Integer; ResType: PChar);
+ procedure LoadFromResource(const aInstance: Cardinal; aResource: String; const aResType: PChar = nil);
+ procedure LoadFromResourceID(const sInstance: Cardinal; aResourceID: Integer; const aResType: PChar);
{$ENDIF}
procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType);
procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
- //function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; Format: TglBitmapInternalFormat; CustomData: Pointer = nil): boolean; overload;
+ //function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; Format: TglBitmapFormat; CustomData: Pointer = nil): boolean; overload;
//function AddFunc(const aFunc: TglBitmapFunction; CreateTemp: Boolean; CustomData: Pointer = nil): boolean; overload;
(* TODO
{$IFDEF GLB_SDL}
function RemoveAlpha: Boolean; virtual;
function Clone: TglBitmap;
- function ConvertTo(const aFormat: TglBitmapFormat; const aInternalFormat: TglBitmapInternalFormat): Boolean; virtual;
+ function ConvertTo(const aFormat: TglBitmapFormat; const aInternalFormat: TglBitmapFormat): Boolean; virtual;
procedure SetBorderColor(Red, Green, Blue, Alpha: Single);
procedure Invert(const aUseRGB: Boolean = true; aUseAlpha: Boolean = false);
procedure FreeData;
constructor Create(Instance: Cardinal; Resource: String; ResType: PChar = nil); overload;
constructor Create(Instance: Cardinal; ResourceID: Integer; ResType: PChar); overload;
{$ENDIF}
- constructor Create(Size: TglBitmapPixelPosition; Format: TglBitmapInternalFormat); overload;
- constructor Create(Size: TglBitmapPixelPosition; Format: TglBitmapInternalFormat; Func: TglBitmapFunction; CustomData: Pointer = nil); overload;
+ constructor Create(Size: TglBitmapPixelPosition; Format: TglBitmapFormat); overload;
+ constructor Create(Size: TglBitmapPixelPosition; Format: TglBitmapFormat; Func: TglBitmapFunction; CustomData: Pointer = nil); overload;
end;
procedure SetPixel2DUnmap(const Pos: TglBitmapPixelPosition; const Pixel: TglBitmapPixelData);
- procedure SetDataPointer(Data: pByte; Format: TglBitmapInternalFormat; Width: Integer = -1; Height: Integer = -1); override;
+ procedure SetDataPointer(Data: pByte; Format: TglBitmapFormat; Width: Integer = -1; Height: Integer = -1); override;
procedure UploadData (Target, Format, InternalFormat, Typ: Cardinal; BuildWithGlu: Boolean);
public
property Width;
procedure AfterConstruction; override;
- procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aInternalFormat: TglBitmapInternalFormat);
+ procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);
procedure GetDataFromTexture;
procedure ToNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = False);
procedure GenTexture(TestTextureSize: Boolean = True); override;
end;
*)
+const
+ NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0);
+
procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
+procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
-procedure glBitmapSetDefaultInternalFormat(const aInternalFormat: TglBitmapInternalFormat);
procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
procedure glBitmapSetDefaultWrap(
const S: Cardinal = GL_CLAMP_TO_EDGE;
function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
+function glBitmapGetDefaultMipmap: TglBitmapMipMap;
function glBitmapGetDefaultFormat: TglBitmapFormat;
-function glBitmapGetDefaultInternalFormat: TglBitmapInternalFormat;
procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
-// position / size
function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
// Formatfunctions
-function FormatGetSize(Format: TglBitmapInternalFormat): Single;
-function FormatIsCompressed(Format: TglBitmapInternalFormat): boolean;
-function FormatIsUncompressed(Format: TglBitmapInternalFormat): boolean;
-function FormatIsEmpty(Format: TglBitmapInternalFormat): boolean;
-function FormatHasAlpha(Format: TglBitmapInternalFormat): Boolean;
-procedure FormatPreparePixel(var Pixel: TglBitmapPixelData; Format: TglBitmapInternalFormat);
-function FormatGetWithoutAlpha(Format: TglBitmapInternalFormat): TglBitmapInternalFormat;
-function FormatGetWithAlpha(Format: TglBitmapInternalFormat): TglBitmapInternalFormat;
-function FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask: Cardinal; Format: TglBitmapInternalFormat): boolean;
-
-
-(* TODO
-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;
-*)
+function FormatGetSize(const aFormat: TglBitmapFormat): Single;
var
glBitmapDefaultDeleteTextureOnFree: Boolean;
glBitmapDefaultFreeDataAfterGenTextures: Boolean;
glBitmapDefaultFormat: TglBitmapFormat;
- glBitmapDefaultInternalFormat: TglBitmapInternalFormat;
+ glBitmapDefaultMipmap: TglBitmapMipMap;
glBitmapDefaultFilterMin: Cardinal;
glBitmapDefaultFilterMag: Cardinal;
glBitmapDefaultWrapS: Cardinal;
uses
Math;
-(* TODO
+type
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdEmpty = class(TglBitmapFormatDescriptor)
+ public
+ class function GetFormat: TglBitmapFormat; override;
+ class function GetPixelDesc: TglBitmapPixelDesc; override;
+ class function GetFormatDesc: TglBitmapFormatDesc; override;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); override;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdLuminance8 = class(TglBitmapFormatDescriptor)
+ public
+ class function GetFormat: TglBitmapFormat; override;
+ class function GetPixelDesc: TglBitmapPixelDesc; override;
+ class function GetFormatDesc: TglBitmapFormatDesc; override;
+ class function WithAlpha: TglBitmapFormat; override;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); override;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdLuminance8Alpha8 = class(TglBitmapFormatDescriptor)
+ public
+ class function GetFormat: TglBitmapFormat; override;
+ class function GetPixelDesc: TglBitmapPixelDesc; override;
+ class function GetFormatDesc: TglBitmapFormatDesc; override;
+ class function WithoutAlpha: TglBitmapFormat; override;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); override;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdRGB8 = class(TglBitmapFormatDescriptor)
+ public
+ class function GetFormat: TglBitmapFormat; override;
+ class function GetPixelDesc: TglBitmapPixelDesc; override;
+ class function GetFormatDesc: TglBitmapFormatDesc; override;
+ class function WithAlpha: TglBitmapFormat; override;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); override;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdRGBA8 = class(TglBitmapFormatDescriptor)
+ public
+ class function GetFormat: TglBitmapFormat; override;
+ class function GetPixelDesc: TglBitmapPixelDesc; override;
+ class function GetFormatDesc: TglBitmapFormatDesc; override;
+ class function WithoutAlpha: TglBitmapFormat; override;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); override;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdBGR8 = class(TglBitmapFormatDescriptor)
+ public
+ class function GetFormat: TglBitmapFormat; override;
+ class function GetPixelDesc: TglBitmapPixelDesc; override;
+ class function GetFormatDesc: TglBitmapFormatDesc; override;
+ class function WithAlpha: TglBitmapFormat; override;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); override;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); override;
+ end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ TfdBGRA8 = class(TglBitmapFormatDescriptor)
+ public
+ class function GetFormat: TglBitmapFormat; override;
+ class function GetPixelDesc: TglBitmapPixelDesc; override;
+ class function GetFormatDesc: TglBitmapFormatDesc; override;
+ class function WithoutAlpha: TglBitmapFormat; override;
+
+ class procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte); override;
+ class procedure Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData); override;
+ end;
+
+const
+ LUMINANCE_WEIGHT_R = 0.30;
+ LUMINANCE_WEIGHT_G = 0.59;
+ LUMINANCE_WEIGHT_B = 0.11;
+ UNSUPPORTED_INTERNAL_FORMAT = 'the given format isn''t supported by this function.';
+
+{$REGION Private Helper}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition;
+begin
+ Result.Fields := [];
+
+ if X >= 0 then
+ Result.Fields := Result.Fields + [ffX];
+ if Y >= 0 then
+ Result.Fields := Result.Fields + [ffY];
+
+ Result.X := Max(0, X);
+ Result.Y := Max(0, Y);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function FormatGetImageSize(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat): Integer;
+begin
+ if (aSize.X = 0) and (aSize.Y = 0) then
+ Result := 0
+ else
+ Result := Ceil(Max(aSize.Y, 1) * Max(aSize.X, 1) * FormatGetSize(aFormat));
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function FormatGetSupportedFiles(const aFormat: TglBitmapFormat): TglBitmapFileTypes;
+begin
+ //TODO check Formats!
+ result := [];
+
+ {$IFDEF GLB_SUPPORT_PNG_WRITE}
+ if aFormat in [
+ tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16,
+ tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16,
+ tfuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16,
+ tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16,
+ tfRGBA2, tfRGBA4, tfRGB5A1, tfRGBA8, tfRGB10A2, tfRGBA12, tfRGBA16,
+ tfDepth16, tfDepth24, tfDepth32]
+ then
+ result := result + [ftPNG];
+ {$ENDIF}
+
+ {$IFDEF GLB_SUPPORT_JPEG_WRITE}
+ if Format in [
+ tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16,
+ tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16,
+ tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16,
+ tfDepth16, tfDepth24, tfDepth32]
+ then
+ result := result + [ftJPEG];
+ {$ENDIF}
+
+ if aFormat in [
+ tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16,
+ tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16,
+ tfuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16,
+ tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16,
+ tfRGBA2, tfRGBA4, tfRGB5A1, tfRGBA8, tfRGB10A2, tfRGBA12, tfRGBA16,
+ tfDepth16, tfDepth24, tfDepth32]
+ then
+ result := result + [ftDDS, ftTGA, ftBMP];
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function IsPowerOfTwo(aNumber: Integer): Boolean;
+begin
+ while (aNumber and 1) = 0 do
+ aNumber := aNumber shr 1;
+ result := aNumber = 1;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function GetBitSize(aBitSet: Cardinal): Integer;
+begin
+ result := 0;
+ while aBitSet > 0 do begin
+ if (aBitSet and 1) = 1 then
+ inc(result);
+ aBitSet := aBitSet shr 1;
+ end;
+end;
+{$ENDREGION}
+
+(* GLB_NO_NATIVE_GL
{$IFNDEF GLB_NO_NATIVE_GL}
procedure ReadOpenGLExtensions;
var
{$ENDIF}
*)
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition;
+(* TODO GLB_DELPHI
+{$IFDEF GLB_DELPHI}
+function CreateGrayPalette: HPALETTE;
+var
+ Idx: Integer;
+ Pal: PLogPalette;
begin
- Result.Fields := [];
-
- if X >= 0 then
- Result.Fields := Result.Fields + [ffX];
- if Y >= 0 then
- Result.Fields := Result.Fields + [ffY];
-
- Result.X := Max(0, X);
- Result.Y := Max(0, Y);
-end;
+ GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256));
+ Pal.palVersion := $300;
+ Pal.palNumEntries := 256;
-const
- LUMINANCE_WEIGHT_R = 0.30;
- LUMINANCE_WEIGHT_G = 0.59;
- LUMINANCE_WEIGHT_B = 0.11;
- UNSUPPORTED_INTERNAL_FORMAT = 'the given format isn''t supported by this function.';
+ {$IFOPT R+}
+ {$DEFINE GLB_TEMPRANGECHECK}
+ {$R-}
+ {$ENDIF}
-{$REGION PixelDescription}
-const
- //ifAlpha4////////////////////////////////////////////////////////////////////////////////////////
- PIXEL_DESC_ALPHA4: TglBitmapPixelDesc = (
- RedRange: $00000000; RedShift: 0;
- GreenRange: $00000000; GreenShift: 0;
- BlueRange: $00000000; BlueShift: 0;
- AlphaRange: $0000000F; AlphaShift: 0);
-
- //ifAlpha8
- PIXEL_DESC_ALPHA8: TglBitmapPixelDesc = (
- RedRange: $00000000; RedShift: 0;
- GreenRange: $00000000; GreenShift: 0;
- BlueRange: $00000000; BlueShift: 0;
- AlphaRange: $000000FF; AlphaShift: 0);
-
- //ifAlpha12
- PIXEL_DESC_ALPHA12: TglBitmapPixelDesc = (
- RedRange: $00000000; RedShift: 0;
- GreenRange: $00000000; GreenShift: 0;
- BlueRange: $00000000; BlueShift: 0;
- AlphaRange: $00000FFF; AlphaShift: 0);
-
- //ifAlpha16
- PIXEL_DESC_ALPHA16: TglBitmapPixelDesc = (
- RedRange: $00000000; RedShift: 0;
- GreenRange: $00000000; GreenShift: 0;
- BlueRange: $00000000; BlueShift: 0;
- AlphaRange: $0000FFFF; AlphaShift: 0);
-
- //ifLuminance4////////////////////////////////////////////////////////////////////////////////////
- PIXEL_DESC_LUMINANCE4: TglBitmapPixelDesc = (
- RedRange: $0000000F; RedShift: 0;
- GreenRange: $0000000F; GreenShift: 0;
- BlueRange: $0000000F; BlueShift: 0;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifLuminance8
- PIXEL_DESC_LUMINANCE8: TglBitmapPixelDesc = (
- RedRange: $000000FF; RedShift: 0;
- GreenRange: $000000FF; GreenShift: 0;
- BlueRange: $000000FF; BlueShift: 0;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifLuminance12
- PIXEL_DESC_LUMINANCE12: TglBitmapPixelDesc = (
- RedRange: $00000FFF; RedShift: 0;
- GreenRange: $00000FFF; GreenShift: 0;
- BlueRange: $00000FFF; BlueShift: 0;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifLuminance16
- PIXEL_DESC_LUMINANCE16: TglBitmapPixelDesc = (
- RedRange: $0000FFFF; RedShift: 0;
- GreenRange: $0000FFFF; GreenShift: 0;
- BlueRange: $0000FFFF; BlueShift: 0;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifLuminance4Alpha4//////////////////////////////////////////////////////////////////////////////
- PIXEL_DESC_LUMINANCE4_ALPHA4: TglBitmapPixelDesc = (
- RedRange: $0000000F; RedShift: 0;
- GreenRange: $0000000F; GreenShift: 0;
- BlueRange: $0000000F; BlueShift: 0;
- AlphaRange: $0000000F; AlphaShift: 4);
- //ifLuminance6Alpha2
- PIXEL_DESC_LUMINANCE6_ALPHA2: TglBitmapPixelDesc = (
- RedRange: $0000003F; RedShift: 0;
- GreenRange: $0000003F; GreenShift: 0;
- BlueRange: $0000003F; BlueShift: 0;
- AlphaRange: $00000003; AlphaShift: 6);
-
- //ifLuminance8Alpha8
- PIXEL_DESC_LUMINANCE8_ALPHA8: TglBitmapPixelDesc = (
- RedRange: $000000FF; RedShift: 0;
- GreenRange: $000000FF; GreenShift: 0;
- BlueRange: $000000FF; BlueShift: 0;
- AlphaRange: $000000FF; AlphaShift: 8);
-
- //ifLuminance12Alpha4
- PIXEL_DESC_LUMINANCE12_ALPHA4: TglBitmapPixelDesc = (
- RedRange: $00000FFF; RedShift: 0;
- GreenRange: $00000FFF; GreenShift: 0;
- BlueRange: $00000FFF; BlueShift: 0;
- AlphaRange: $0000000F; AlphaShift: 12);
-
- //ifLuminance12Alpha12
- PIXEL_DESC_LUMINANCE12_ALPHA12: TglBitmapPixelDesc = (
- RedRange: $00000FFF; RedShift: 0;
- GreenRange: $00000FFF; GreenShift: 0;
- BlueRange: $00000FFF; BlueShift: 0;
- AlphaRange: $00000FFF; AlphaShift: 12);
-
- //ifLuminance16Alpha16
- PIXEL_DESC_LUMINANCE16_ALPHA16: TglBitmapPixelDesc = (
- RedRange: $0000FFFF; RedShift: 0;
- GreenRange: $0000FFFF; GreenShift: 0;
- BlueRange: $0000FFFF; BlueShift: 0;
- AlphaRange: $0000FFFF; AlphaShift: 16);
-
- //ifR3G3B2////////////////////////////////////////////////////////////////////////////////////////
- PIXEL_DESC_R3_G3_B2: TglBitmapPixelDesc = (
- RedRange: $00000007; RedShift: 0;
- GreenRange: $00000007; GreenShift: 3;
- BlueRange: $00000003; BlueShift: 6;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifRGB4
- PIXEL_DESC_RGB4: TglBitmapPixelDesc = (
- RedRange: $0000000F; RedShift: 0;
- GreenRange: $0000000F; GreenShift: 4;
- BlueRange: $0000000F; BlueShift: 8;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifRGB5
- PIXEL_DESC_RGB5: TglBitmapPixelDesc = (
- RedRange: $0000001F; RedShift: 0;
- GreenRange: $0000001F; GreenShift: 5;
- BlueRange: $0000001F; BlueShift: 10;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifRGB8
- PIXEL_DESC_RGB8: TglBitmapPixelDesc = (
- RedRange: $000000FF; RedShift: 0;
- GreenRange: $000000FF; GreenShift: 8;
- BlueRange: $000000FF; BlueShift: 16;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifRGB10
- PIXEL_DESC_RGB10: TglBitmapPixelDesc = (
- RedRange: $000003FF; RedShift: 0;
- GreenRange: $000003FF; GreenShift: 10;
- BlueRange: $000003FF; BlueShift: 20;
- AlphaRange: $000003FF; AlphaShift: 0);
-
- //ifRGB12
- PIXEL_DESC_RGB12: TglBitmapPixelDesc = (
- RedRange: $00000000; RedShift: 0;
- GreenRange: $00000000; GreenShift: 0;
- BlueRange: $00000000; BlueShift: 0;
- AlphaRange: $00000000; AlphaShift: 0);
-
- //ifRGB16
- PIXEL_DESC_RGB16: TglBitmapPixelDesc = (
- RedRange: $0000FFFF; RedShift: 0;
- GreenRange: $0000FFFF; GreenShift: 16;
- BlueRange: $0000FFFF; BlueShift: 32;
- AlphaRange: $0000FFFF; AlphaShift: 0);
-
- //ifRGBA2/////////////////////////////////////////////////////////////////////////////////////////
- PIXEL_DESC_RGBA2: TglBitmapPixelDesc = (
- RedRange: $00000003; RedShift: 0;
- GreenRange: $00000003; GreenShift: 2;
- BlueRange: $00000003; BlueShift: 4;
- AlphaRange: $00000003; AlphaShift: 6);
-
- //ifRGBA4
- PIXEL_DESC_RGBA4: TglBitmapPixelDesc = (
- RedRange: $0000000F; RedShift: 0;
- GreenRange: $0000000F; GreenShift: 4;
- BlueRange: $0000000F; BlueShift: 8;
- AlphaRange: $0000000F; AlphaShift: 12);
-
- //ifRGB5A1
- PIXEL_DESC_RGB5_A1: TglBitmapPixelDesc = (
- RedRange: $0000001F; RedShift: 0;
- GreenRange: $0000001F; GreenShift: 5;
- BlueRange: $0000001F; BlueShift: 10;
- AlphaRange: $00000001; AlphaShift: 11);
-
- //ifRGBA8
- PIXEL_DESC_RGBA8: TglBitmapPixelDesc = (
- RedRange: $000000FF; RedShift: 0;
- GreenRange: $000000FF; GreenShift: 8;
- BlueRange: $000000FF; BlueShift: 16;
- AlphaRange: $000000FF; AlphaShift: 24);
-
- //ifRGB10A2
- PIXEL_DESC_RGB10_A2: TglBitmapPixelDesc = (
- RedRange: $000003FF; RedShift: 0;
- GreenRange: $000003FF; GreenShift: 10;
- BlueRange: $000003FF; BlueShift: 20;
- AlphaRange: $00000003; AlphaShift: 22);
-
- //ifRGBA12
- PIXEL_DESC_RGBA12: TglBitmapPixelDesc = (
- RedRange: $00000FFF; RedShift: 0;
- GreenRange: $00000FFF; GreenShift: 12;
- BlueRange: $00000FFF; BlueShift: 24;
- AlphaRange: $00000FFF; AlphaShift: 36);
-
- //ifRGBA16
- PIXEL_DESC_RGBA16: TglBitmapPixelDesc = (
- RedRange: $0000FFFF; RedShift: 0;
- GreenRange: $0000FFFF; GreenShift: 16;
- BlueRange: $0000FFFF; BlueShift: 32;
- AlphaRange: $0000FFFF; AlphaShift: 48);
-
- //ifDepthComponent16//////////////////////////////////////////////////////////////////////////////
- PIXEL_DESC_DEPTH16: TglBitmapPixelDesc = (
- RedRange: $0000FFFF; RedShift: 0;
- GreenRange: $0000FFFF; GreenShift: 0;
- BlueRange: $0000FFFF; BlueShift: 0;
- AlphaRange: $0000FFFF; AlphaShift: 0);
-
- //ifDepthComponent24
- PIXEL_DESC_DEPTH24: TglBitmapPixelDesc = (
- RedRange: $00FFFFFF; RedShift: 0;
- GreenRange: $00FFFFFF; GreenShift: 0;
- BlueRange: $00FFFFFF; BlueShift: 0;
- AlphaRange: $00FFFFFF; AlphaShift: 0);
-
- //ifDepthComponent32
- PIXEL_DESC_DEPTH32: TglBitmapPixelDesc = (
- RedRange: $FFFFFFFF; RedShift: 0;
- GreenRange: $FFFFFFFF; GreenShift: 0;
- BlueRange: $FFFFFFFF; BlueShift: 0;
- AlphaRange: $00000000; AlphaShift: 0);
-{$ENDREGION}
+ 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;
+ end;
-{$REGION MapFunctions}
-//ALPHA/////////////////////////////////////////////////////////////////////////////////////////////
-procedure MapAlpha4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- //TODO
-end;
+ {$IFDEF GLB_TEMPRANGECHECK}
+ {$UNDEF GLB_TEMPRANGECHECK}
+ {$R+}
+ {$ENDIF}
-procedure MapAlpha8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- aData^ := aPixel.Alpha;
- inc(aData);
-end;
+ Result := CreatePalette(Pal^);
-procedure MapAlpha12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- //TODO
+ FreeMem(Pal);
end;
+{$ENDIF}
+*)
-procedure MapAlpha16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+(* TODO GLB_SDL_IMAGE
+{$IFDEF GLB_SDL_IMAGE}
+function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
begin
- PWord(aData)^ := aPixel.Alpha;
- inc(aData, 2);
+ Result := TStream(context^.unknown.data1).Seek(offset, whence);
end;
-//LUMINANCE/////////////////////////////////////////////////////////////////////////////////////////
-procedure MapLuminance4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+function glBitmapRWread(context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer): Integer; cdecl;
begin
- //TODO
+ Result := TStream(context^.unknown.data1).Read(Ptr^, size * maxnum);
end;
-procedure MapLuminance8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+function glBitmapRWwrite(context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer): Integer; cdecl;
begin
- aData^ := Trunc(
- aPixel.Red * LUMINANCE_WEIGHT_R +
- aPixel.Green * LUMINANCE_WEIGHT_G +
- aPixel.Blue * LUMINANCE_WEIGHT_B);
- inc(aData);
+ Result := TStream(context^.unknown.data1).Write(Ptr^, size * num);
end;
-procedure MapLuminance12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+function glBitmapRWclose(context: PSDL_RWops): Integer; cdecl;
begin
- //TODO
+ Result := 0;
end;
-procedure MapLuminance16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+function glBitmapCreateRWops(Stream: TStream): PSDL_RWops;
begin
- PWord(aData)^ := Trunc(
- aPixel.Red * LUMINANCE_WEIGHT_R +
- aPixel.Green * LUMINANCE_WEIGHT_G +
- aPixel.Blue * LUMINANCE_WEIGHT_B);
- inc(aData, 2);
-end;
+ Result := SDL_AllocRW;
-//LUMINANCE_ALPHA///////////////////////////////////////////////////////////////////////////////////
-procedure MapLuminance4Alpha4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- aData^ :=
- ((Trunc(aPixel.Red * LUMINANCE_WEIGHT_R +
- aPixel.Green * LUMINANCE_WEIGHT_G +
- aPixel.Blue * LUMINANCE_WEIGHT_B) and
- aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift;
- inc(aData);
-end;
+ if Result = nil then
+ raise EglBitmapException.Create('glBitmapCreateRWops - SDL_AllocRW failed.');
-procedure MapLuminance6Alpha2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- MapLuminance4Alpha4(aPixel, aData, aBitOffset);
+ Result^.seek := glBitmapRWseek;
+ Result^.read := glBitmapRWread;
+ Result^.write := glBitmapRWwrite;
+ Result^.close := glBitmapRWclose;
+ Result^.unknown.data1 := Stream;
end;
+{$ENDIF}
+*)
-procedure MapLuminance8Alpha8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+(* TODO LoadFuncs
+function LoadTexture(Filename: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal{$ENDIF}): Boolean;
+var
+ glBitmap: TglBitmap2D;
begin
- PWord(aData)^ :=
- ((Trunc(aPixel.Red * LUMINANCE_WEIGHT_R +
- aPixel.Green * LUMINANCE_WEIGHT_G +
- aPixel.Blue * LUMINANCE_WEIGHT_B) and
- aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift;
- inc(aData, 2);
-end;
+ Result := false;
+ Texture := 0;
-procedure MapLuminance12Alpha4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- MapLuminance8Alpha8(aPixel, aData, aBitOffset);
-end;
+ {$IFDEF GLB_DELPHI}
+ if Instance = 0 then
+ Instance := HInstance;
-procedure MapLuminance12Alpha12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- //TODO
-end;
+ if (LoadFromRes) then
+ glBitmap := TglBitmap2D.CreateFromResourceName(Instance, FileName)
+ else
+ {$ENDIF}
+ glBitmap := TglBitmap2D.Create(FileName);
-procedure MapLuminance16Alpha16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- PCardinal(aData)^ :=
- ((Trunc(aPixel.Red * LUMINANCE_WEIGHT_R +
- aPixel.Green * LUMINANCE_WEIGHT_G +
- aPixel.Blue * LUMINANCE_WEIGHT_B) and
- aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift;
- inc(aData, 4);
+ 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;
-//RGB///////////////////////////////////////////////////////////////////////////////////////////////
-procedure MapR3G3B2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+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
- aData^ :=
- ((aPixel.Red and aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Green and aPixel.PixelDesc.GreenRange) shl aPixel.PixelDesc.GreenShift) or
- ((aPixel.Blue and aPixel.PixelDesc.BlueRange) shl aPixel.PixelDesc.BlueShift);
- inc(aData);
-end;
+ Texture := 0;
-procedure MapRGB4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- //TODO
-end;
+ {$IFDEF GLB_DELPHI}
+ if Instance = 0 then
+ Instance := HInstance;
+ {$ENDIF}
-procedure MapRGB5(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- //TODO
-end;
+ CM := TglBitmapCubeMap.Create;
+ try
+ CM.DeleteTextureOnFree := False;
-procedure MapRGB8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- PCardinal(aData)^ :=
- ((aPixel.Red and aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Green and aPixel.PixelDesc.GreenRange) shl aPixel.PixelDesc.GreenShift) or
- ((aPixel.Blue and aPixel.PixelDesc.BlueRange) shl aPixel.PixelDesc.BlueShift);
- inc(aData, 3);
-end;
+ // Maps
+ {$IFDEF GLB_DELPHI}
+ if (LoadFromRes) then
+ CM.LoadFromResource(Instance, PositiveX)
+ else
+ {$ENDIF}
+ CM.LoadFromFile(PositiveX);
+ CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X);
-procedure MapRGB10(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
-begin
- //TODO
+ {$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;
-procedure MapRGB12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+function LoadNormalMap(Size: Integer; var Texture: Cardinal): Boolean;
+var
+ NM: TglBitmapNormalMap;
begin
- //TODO
+ Texture := 0;
+
+ NM := TglBitmapNormalMap.Create;
+ try
+ NM.DeleteTextureOnFree := False;
+ NM.GenerateNormalMap(Size);
+
+ Texture := NM.ID;
+ Result := True;
+ finally
+ NM.Free;
+ end;
end;
+*)
-procedure MapRGB16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+{$REGION default Setter and Gettter}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
begin
- PWord(aData)^ := aPixel.Red;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Green;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Blue;
- inc(aData, 2);
+ glBitmapDefaultDeleteTextureOnFree := aDeleteTextureOnFree;
end;
-//RGBA//////////////////////////////////////////////////////////////////////////////////////////////
-procedure MapRGBA2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
begin
- aData^ :=
- ((aPixel.Red and aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Green and aPixel.PixelDesc.GreenRange) shl aPixel.PixelDesc.GreenShift) or
- ((aPixel.Blue and aPixel.PixelDesc.BlueRange) shl aPixel.PixelDesc.BlueShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift);
- inc(aData);
+ glBitmapDefaultFreeDataAfterGenTextures := aFreeData;
end;
-procedure MapRGBA4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
begin
- PWord(aData)^ :=
- ((aPixel.Red and aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Green and aPixel.PixelDesc.GreenRange) shl aPixel.PixelDesc.GreenShift) or
- ((aPixel.Blue and aPixel.PixelDesc.BlueRange) shl aPixel.PixelDesc.BlueShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift);
- inc(aData, 2);
+ glBitmapDefaultMipmap := aValue;
end;
-procedure MapRGB5A1(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
begin
- PWord(aData)^ :=
- ((aPixel.Red and aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Green and aPixel.PixelDesc.GreenRange) shl aPixel.PixelDesc.GreenShift) or
- ((aPixel.Blue and aPixel.PixelDesc.BlueRange) shl aPixel.PixelDesc.BlueShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift);
- inc(aData, 2);
+ glBitmapDefaultFormat := aFormat;
end;
-procedure MapRGBA8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
begin
- PCardinal(aData)^ :=
- ((aPixel.Red and aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Green and aPixel.PixelDesc.GreenRange) shl aPixel.PixelDesc.GreenShift) or
- ((aPixel.Blue and aPixel.PixelDesc.BlueRange) shl aPixel.PixelDesc.BlueShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift);
- inc(aData, 4);
+ glBitmapDefaultFilterMin := aMin;
+ glBitmapDefaultFilterMag := aMag;
end;
-procedure MapRGB10A2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultWrap(const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
begin
- PCardinal(aData)^ :=
- ((aPixel.Red and aPixel.PixelDesc.RedRange) shl aPixel.PixelDesc.RedShift) or
- ((aPixel.Green and aPixel.PixelDesc.GreenRange) shl aPixel.PixelDesc.GreenShift) or
- ((aPixel.Blue and aPixel.PixelDesc.BlueRange) shl aPixel.PixelDesc.BlueShift) or
- ((aPixel.Alpha and aPixel.PixelDesc.AlphaRange) shl aPixel.PixelDesc.AlphaShift);
- inc(aData, 4);
+ glBitmapDefaultWrapS := S;
+ glBitmapDefaultWrapT := T;
+ glBitmapDefaultWrapR := R;
end;
-procedure MapRGBA12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
begin
- //TODO
+ result := glBitmapDefaultDeleteTextureOnFree;
end;
-procedure MapRGBA16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
begin
- PWord(aData)^ := aPixel.Red;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Green;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Blue;
- inc(aData, 2);
- PWord(aData)^ := aPixel.Alpha;
- inc(aData, 2);
+ result := glBitmapDefaultFreeDataAfterGenTextures;
end;
-//DEPTH/////////////////////////////////////////////////////////////////////////////////////////////
-procedure MapDepth16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultMipmap: TglBitmapMipMap;
begin
- PWord(aData)^ := (aPixel.Red + aPixel.Green + aPixel.Blue) div 3;
- inc(aData, 2);
+ result := glBitmapDefaultMipmap;
end;
-procedure MapDepth24(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultFormat: TglBitmapFormat;
begin
- //TODO
+ result := glBitmapDefaultFormat;
end;
-procedure MapDepth32(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
begin
- PCardinal(aData)^ := (aPixel.Red + aPixel.Green + aPixel.Blue) div 3;
- inc(aData, 4);
+ aMin := glBitmapDefaultFilterMin;
+ aMag := glBitmapDefaultFilterMag;
end;
-function FormatGetMapFunc(const aInternalFormat: TglBitmapInternalFormat): TglBitmapMapFunc;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
begin
- case aInternalFormat of
- ifAlpha4: result := MapAlpha4;
- ifAlpha8: result := MapAlpha8;
- ifAlpha12: result := MapAlpha12;
- ifAlpha16: result := MapAlpha16;
-
- ifLuminance4: result := MapLuminance4;
- ifLuminance8: result := MapLuminance8;
- ifLuminance12: result := MapLuminance8;
- ifLuminance16: result := MapLuminance8;
-
- ifLuminance4Alpha4: result := MapLuminance4Alpha4;
- ifLuminance6Alpha2: result := MapLuminance6Alpha2;
- ifLuminance8Alpha8: result := MapLuminance8Alpha8;
- ifLuminance12Alpha4: result := MapLuminance12Alpha4;
- ifLuminance12Alpha12: result := MapLuminance12Alpha12;
- ifLuminance16Alpha16: result := MapLuminance16Alpha16;
-
- ifR3G3B2: result := MapR3G3B2;
- ifRGB4: result := MapRGB4;
- ifRGB5: result := MapRGB5;
- ifRGB8: result := MapRGB8;
- ifRGB10: result := MapRGB10;
- ifRGB12: result := MapRGB12;
- ifRGB16: result := MapRGB16;
-
- ifRGBA2: result := MapRGBA2;
- ifRGBA4: result := MapRGBA4;
- ifRGB5A1: result := MapRGB5A1;
- ifRGBA8: result := MapRGBA8;
- ifRGB10A2: result := MapRGB10A2;
- ifRGBA12: result := MapRGBA12;
- ifRGBA16: result := MapRGBA16;
-
- ifDepth16: result := MapDepth16;
- ifDepth24: result := MapDepth24;
- ifDepth32: result := MapDepth32;
- else
- raise EglBitmapUnsupportedInternalFormat.Create('FormatGetMapFunc - ' + UNSUPPORTED_INTERNAL_FORMAT);
- end;
+ S := glBitmapDefaultWrapS;
+ T := glBitmapDefaultWrapT;
+ R := glBitmapDefaultWrapR;
end;
{$ENDREGION}
-{$REGION UnmapFunctions}
-//ALPHA/////////////////////////////////////////////////////////////////////////////////////////////
-procedure UnmapAlpha4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+{$REGION TglBitmapFormatDescriptor}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglBitmapFormatDescriptor.WithoutAlpha: TglBitmapFormat;
begin
- //TODO
+ if not HasAlpha then
+ result := GetFormat
+ else
+ result := tfEmpty;
end;
-procedure UnmapAlpha8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglBitmapFormatDescriptor.WithAlpha: TglBitmapFormat;
begin
+ if HasAlpha then
+ result := GetFormat
+ else
+ result := tfEmpty;
+end;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglBitmapFormatDescriptor.IsEmpty: Boolean;
+begin
+ result := (GetFormat = tfEmpty);
end;
-procedure UnmapAlpha12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglBitmapFormatDescriptor.HasAlpha: Boolean;
begin
- //TODO
+ result := (GetPixelDesc.AlphaRange > 0);
end;
-procedure UnmapAlpha16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglBitmapFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: UInt64): Boolean;
+var
+ PixelDesc: TglBitmapPixelDesc;
begin
+ result := False;
+
+ if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then
+ raise EglBitmapException.Create('FormatCheckFormat - All Masks are 0');
+ PixelDesc := GetPixelDesc;
+ with PixelDesc do begin
+ if (aRedMask <> 0) and (aRedMask <> (RedRange shl RedShift)) then
+ exit;
+ if (aGreenMask <> 0) and (aGreenMask <> (GreenRange shl GreenShift)) then
+ exit;
+ if (aBlueMask <> 0) and (aBlueMask <> (BlueRange shl BlueShift)) then
+ exit;
+ if (aAlphaMask <> 0) and (aAlphaMask <> (AlphaRange shl AlphaShift)) then
+ exit;
+ end;
+ result := True;
end;
-//LUMINANCE/////////////////////////////////////////////////////////////////////////////////////////
-procedure UnmapLuminance4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglBitmapFormatDescriptor.PreparePixel(var aPixel: TglBitmapPixelData);
begin
- //TODO
+ FillChar(aPixel, SizeOf(aPixel), 0);
+ with GetPixelDesc do begin
+ aPixel.Red := RedRange;
+ aPixel.Green := GreenRange;
+ aPixel.Blue := BlueRange;
+ aPixel.Alpha := AlphaRange;
+ end;
end;
+{$ENDREGION}
-procedure UnmapLuminance8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+{$REGION TfdEmpty}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdEmpty////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TfdEmpty.GetFormat: TglBitmapFormat;
begin
-
+ result := tfEmpty;
end;
-procedure UnmapLuminance12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdEmpty.GetPixelDesc: TglBitmapPixelDesc;
begin
- //TODO
+ with result do begin
+ RedRange := $00000000; RedShift := 0;
+ GreenRange := $00000000; GreenShift := 0;
+ BlueRange := $00000000; BlueShift := 0;
+ AlphaRange := $00000000; AlphaShift := 0;
+ end;
end;
-procedure UnmapLuminance16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdEmpty.GetFormatDesc: TglBitmapFormatDesc;
begin
-
+ with result do begin
+ Format := 0;
+ InternalFormat := 0;
+ DataType := 0;
+ end;
end;
-//LUMINANCE_ALPHA///////////////////////////////////////////////////////////////////////////////////
-procedure UnmapLuminance4Alpha4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdEmpty.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
begin
-
+ raise EglBitmapException.Create('format does not support mapping');
end;
-procedure UnmapLuminance6Alpha2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdEmpty.Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
begin
-
+ raise EglBitmapException.Create('format does not support unmapping');
end;
+{$ENDREGION}
-procedure UnmapLuminance8Alpha8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+{$REGION TfdLuminance8}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance8///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TfdLuminance8.GetFormat: TglBitmapFormat;
begin
-
+ result := tfEmpty;
end;
-procedure UnmapLuminance12Alpha4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdLuminance8.GetPixelDesc: TglBitmapPixelDesc;
begin
-
+ with result do begin
+ RedRange := $000000FF; RedShift := 0;
+ GreenRange := $000000FF; GreenShift := 0;
+ BlueRange := $000000FF; BlueShift := 0;
+ AlphaRange := $00000000; AlphaShift := 0;
+ end;
end;
-procedure UnmapLuminance12Alpha12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdLuminance8.GetFormatDesc: TglBitmapFormatDesc;
begin
- //TODO
+ with result do begin
+ Format := GL_LUMINANCE;
+ InternalFormat := GL_LUMINANCE8;
+ DataType := GL_UNSIGNED_BYTE;
+ end;
end;
-procedure UnmapLuminance16Alpha16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdLuminance8.WithAlpha: TglBitmapFormat;
begin
-
+ result := tfLuminance8Alpha8;
end;
-//RGB///////////////////////////////////////////////////////////////////////////////////////////////
-procedure UnmapR3G3B2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdLuminance8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
begin
-
+ aData^ := Trunc(
+ aPixel.Red * LUMINANCE_WEIGHT_R +
+ aPixel.Green * LUMINANCE_WEIGHT_G +
+ aPixel.Blue * LUMINANCE_WEIGHT_B);
+ inc(aData);
end;
-procedure UnmapRGB4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdLuminance8.Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
begin
- //TODO
+ aPixel.Red := aData^;
+ aPixel.Green := aData^;
+ aPixel.Blue := aData^;
+ aPixel.Alpha := 0;
+ inc(aData);
end;
+{$ENDREGION}
-procedure UnmapRGB5(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+{$REGION TfdLuminance8Alpha8}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance8Alpha8/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TfdLuminance8Alpha8.GetFormat: TglBitmapFormat;
begin
- //TODO
+ result := tfLuminance8Alpha8;
end;
-procedure UnmapRGB8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdLuminance8Alpha8.GetPixelDesc: TglBitmapPixelDesc;
begin
-
+ with result do begin
+ RedRange := $000000FF; RedShift := 0;
+ GreenRange := $000000FF; GreenShift := 0;
+ BlueRange := $000000FF; BlueShift := 0;
+ AlphaRange := $000000FF; AlphaShift := 8;
+ end;
end;
-procedure UnmapRGB10(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdLuminance8Alpha8.GetFormatDesc: TglBitmapFormatDesc;
begin
- //TODO
+ with result do begin
+ Format := GL_LUMINANCE_ALPHA;
+ InternalFormat := GL_LUMINANCE8_ALPHA8;
+ DataType := GL_UNSIGNED_BYTE;
+ end;
end;
-procedure UnmapRGB12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdLuminance8Alpha8.WithoutAlpha: TglBitmapFormat;
begin
- //TODO
+ result := tfLuminance8;
end;
-procedure UnmapRGB16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdLuminance8Alpha8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
begin
+ aData^ := Trunc(
+ aPixel.Red * LUMINANCE_WEIGHT_R +
+ aPixel.Green * LUMINANCE_WEIGHT_G +
+ aPixel.Blue * LUMINANCE_WEIGHT_B);
+ inc(aData);
+ aData^ := aPixel.Alpha;
+ inc(aData);
end;
-//RGBA//////////////////////////////////////////////////////////////////////////////////////////////
-procedure UnmapRGBA2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdLuminance8Alpha8.Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
begin
+ aPixel.Red := aData^;
+ aPixel.Green := aData^;
+ aPixel.Blue := aData^;
+ inc(aData);
+ aPixel.Alpha := aData^;
+ inc(aData);
end;
+{$ENDREGION}
-procedure UnmapRGBA4(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+{$REGION TfdRGB8}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGB8/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TfdRGB8.GetFormat: TglBitmapFormat;
begin
-
+ result := tfRGB8;
end;
-procedure UnmapRGB5A1(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdRGB8.GetPixelDesc: TglBitmapPixelDesc;
begin
-
+ with result do begin
+ RedRange := $000000FF; RedShift := 0;
+ GreenRange := $000000FF; GreenShift := 8;
+ BlueRange := $000000FF; BlueShift := 16;
+ AlphaRange := $00000000; AlphaShift := 0;
+ end;
end;
-procedure UnmapRGBA8(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdRGB8.GetFormatDesc: TglBitmapFormatDesc;
begin
-
+ with result do begin
+ Format := GL_LUMINANCE;
+ InternalFormat := GL_LUMINANCE8;
+ DataType := GL_UNSIGNED_BYTE;
+ end;
end;
-procedure UnmapRGB10A2(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdRGB8.WithAlpha: TglBitmapFormat;
begin
-
+ result := tfRGBA8;
end;
-procedure UnmapRGBA12(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdRGB8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
begin
- //TODO
+ aData^ := aPixel.Red;
+ inc(aData);
+ aData^ := aPixel.Green;
+ inc(aData);
+ aData^ := aPixel.Blue;
+ inc(aData);
end;
-procedure UnmapRGBA16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class procedure TfdRGB8.Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
begin
-
+ aPixel.Red := aData^;
+ inc(aData);
+ aPixel.Green := aData^;
+ inc(aData);
+ aPixel.Blue := aData^;
+ inc(aData);
+ aPixel.Alpha := 0;
end;
+{$ENDREGION}
-//DEPTH/////////////////////////////////////////////////////////////////////////////////////////////
-procedure UnmapDepth16(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+{$REGION TfdRGBA8}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGBA8////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TfdRGBA8.GetFormat: TglBitmapFormat;
begin
-
+ result := tfRGBA8;
end;
-procedure UnmapDepth24(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdRGBA8.GetPixelDesc: TglBitmapPixelDesc;
begin
- //TODO
+ with result do begin
+ RedRange := $000000FF; RedShift := 0;
+ GreenRange := $000000FF; GreenShift := 8;
+ BlueRange := $000000FF; BlueShift := 16;
+ AlphaRange := $000000FF; AlphaShift := 24;
+ end;
end;
-procedure UnmapDepth32(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+class function TfdRGBA8.GetFormatDesc: TglBitmapFormatDesc;
begin
-
+ with result do begin
+ Format := GL_RGB;
+ InternalFormat := GL_RGB8;
+ DataType := GL_UNSIGNED_BYTE;
+ end;
end;
-
-
-
-procedure UnMapAlpha(var pData: pByte; var Pixel: TglBitmapPixelData);
+class function TfdRGBA8.WithoutAlpha: TglBitmapFormat;
begin
- Pixel.Alpha := pData^;
- Pixel.Red := Pixel.PixelDesc.RedRange;
- Pixel.Green := Pixel.PixelDesc.GreenRange;
- Pixel.Blue := Pixel.PixelDesc.BlueRange;
-
- Inc(pData);
+ result := tfRGB8;
end;
-
-procedure UnMapLuminance(var pData: pByte; var Pixel: TglBitmapPixelData);
+class procedure TfdRGBA8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
begin
- Pixel.Alpha := 255;
- Pixel.Red := pData^;
- Pixel.Green := pData^;
- Pixel.Blue := pData^;
-
- Inc(pData);
+ aData^ := aPixel.Red;
+ inc(aData);
+ aData^ := aPixel.Green;
+ inc(aData);
+ aData^ := aPixel.Blue;
+ inc(aData);
+ aData^ := aPixel.Alpha;
+ inc(aData);
end;
-
-procedure UnMapDepth8(var pData: pByte; var Pixel: TglBitmapPixelData);
+class procedure TfdRGBA8.Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
begin
- Pixel.Alpha := 255;
- Pixel.Red := pData^;
- Pixel.Green := pData^;
- Pixel.Blue := pData^;
-
- Inc(pData);
+ aPixel.Red := aData^;
+ inc(aData);
+ aPixel.Green := aData^;
+ inc(aData);
+ aPixel.Blue := aData^;
+ inc(aData);
+ aPixel.Alpha := aData^;
+ inc(aData);
end;
+{$ENDREGION}
-
-procedure UnMapLuminanceAlpha(var pData: pByte; var Pixel: TglBitmapPixelData);
+{$REGION TfdBGR8}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGR8/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TfdBGR8.GetFormat: TglBitmapFormat;
begin
- Pixel.Red := pData^;
- Pixel.Green := pData^;
- Pixel.Blue := pData^;
- Inc(pData);
-
- Pixel.Alpha := pData^;
- Inc(pData);
+ result := tfBGR8;
end;
-
-procedure UnMapRGBA4(var pData: pByte; var Pixel: TglBitmapPixelData);
-var
- Temp: Word;
+class function TfdBGR8.GetPixelDesc: TglBitmapPixelDesc;
begin
- Temp := pWord(pData)^;
-
- Pixel.Alpha := Temp shr PIXEL_DESC_RGBA4.AlphaShift and PIXEL_DESC_RGBA4.AlphaRange;
- Pixel.Red := Temp shr PIXEL_DESC_RGBA4.RedShift and PIXEL_DESC_RGBA4.RedRange;
- Pixel.Green := Temp shr PIXEL_DESC_RGBA4.GreenShift and PIXEL_DESC_RGBA4.GreenRange;
- Pixel.Blue := Temp and PIXEL_DESC_RGBA4.BlueRange;
-
- Inc(pData, 2);
+ with result do begin
+ RedRange := $000000FF; RedShift := 16;
+ GreenRange := $000000FF; GreenShift := 8;
+ BlueRange := $000000FF; BlueShift := 0;
+ AlphaRange := $00000000; AlphaShift := 0;
+ end;
end;
-
-procedure UnMapR5G6B5(var pData: pByte; var Pixel: TglBitmapPixelData);
-var
- Temp: Word;
+class function TfdBGR8.GetFormatDesc: TglBitmapFormatDesc;
begin
- Temp := pWord(pData)^;
-
- Pixel.Alpha := Pixel.PixelDesc.AlphaRange;
- Pixel.Red := Temp shr PIXEL_DESC_R5G6B5.RedShift and PIXEL_DESC_R5G6B5.RedRange;
- Pixel.Green := Temp shr PIXEL_DESC_R5G6B5.GreenShift and PIXEL_DESC_R5G6B5.GreenRange;
- Pixel.Blue := Temp and PIXEL_DESC_R5G6B5.BlueRange;
-
- Inc(pData, 2);
+ with result do begin
+ Format := GL_BGR;
+ InternalFormat := GL_RGB8;
+ DataType := GL_UNSIGNED_BYTE;
+ end;
end;
-
-procedure UnMapRGB5A1(var pData: pByte; var Pixel: TglBitmapPixelData);
-var
- Temp: Word;
+class function TfdBGR8.WithAlpha: TglBitmapFormat;
begin
- Temp := pWord(pData)^;
-
- Pixel.Alpha := Temp shr PIXEL_DESC_RGB5A1.AlphaShift and PIXEL_DESC_RGB5A1.AlphaRange;
- Pixel.Red := Temp shr PIXEL_DESC_RGB5A1.RedShift and PIXEL_DESC_RGB5A1.RedRange;
- Pixel.Green := Temp shr PIXEL_DESC_RGB5A1.GreenShift and PIXEL_DESC_RGB5A1.GreenRange;
- Pixel.Blue := Temp and PIXEL_DESC_RGB5A1.BlueRange;
-
- Inc(pData, 2);
+ result := tfBGRA8;
end;
-
-procedure UnMapRGB8(var pData: pByte; var Pixel: TglBitmapPixelData);
+class procedure TfdBGR8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
begin
- Pixel.Alpha := Pixel.PixelDesc.AlphaRange;
-
- Pixel.Red := pData^;
- Inc(pData);
-
- Pixel.Green := pData^;
- Inc(pData);
-
- Pixel.Blue := pData^;
- Inc(pData);
+ aData^ := aPixel.Blue;
+ inc(aData);
+ aData^ := aPixel.Green;
+ inc(aData);
+ aData^ := aPixel.Red;
+ inc(aData);
end;
-
-procedure UnMapBGR8(var pData: pByte; var Pixel: TglBitmapPixelData);
+class procedure TfdBGR8.Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
begin
- Pixel.Alpha := Pixel.PixelDesc.AlphaRange;
-
- Pixel.Blue := pData^;
- Inc(pData);
-
- Pixel.Green := pData^;
- Inc(pData);
-
- Pixel.Red := pData^;
- Inc(pData);
+ aPixel.Blue := aData^;
+ inc(aData);
+ aPixel.Green := aData^;
+ inc(aData);
+ aPixel.Red := aData^;
+ inc(aData);
end;
+{$ENDREGION}
-
-procedure UnMapRGBA8(var pData: pByte; var Pixel: TglBitmapPixelData);
+{$REGION TfdBGRA8}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGRA8////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TfdBGRA8.GetFormat: TglBitmapFormat;
begin
- Pixel.Red := pData^;
- Inc(pData);
-
- Pixel.Green := pData^;
- Inc(pData);
-
- Pixel.Blue := pData^;
- Inc(pData);
-
- Pixel.Alpha := pData^;
- Inc(pData);
+ result := tfBGRA8;
end;
-
-procedure UnMapBGRA8(var pData: pByte; var Pixel: TglBitmapPixelData);
+class function TfdBGRA8.GetPixelDesc: TglBitmapPixelDesc;
begin
- Pixel.Blue := pData^;
- Inc(pData);
-
- Pixel.Green := pData^;
- Inc(pData);
+ with result do begin
+ RedRange := $000000FF; RedShift := 16;
+ GreenRange := $000000FF; GreenShift := 8;
+ BlueRange := $000000FF; BlueShift := 0;
+ AlphaRange := $000000FF; AlphaShift := 24;
+ end;
+end;
- Pixel.Red := pData^;
- Inc(pData);
+class function TfdBGRA8.GetFormatDesc: TglBitmapFormatDesc;
+begin
+ with result do begin
+ Format := GL_BGRA;
+ InternalFormat := GL_RGBA8;
+ DataType := GL_UNSIGNED_BYTE;
+ end;
+end;
- Pixel.Alpha := pData^;
- Inc(pData);
+class function TfdBGRA8.WithoutAlpha: TglBitmapFormat;
+begin
+ result := tfBGR8;
end;
+class procedure TfdBGRA8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aBitOffset: Byte);
+begin
+ aData^ := aPixel.Blue;
+ inc(aData);
+ aData^ := aPixel.Green;
+ inc(aData);
+ aData^ := aPixel.Red;
+ inc(aData);
+ aData^ := aPixel.Alpha;
+ inc(aData);
+end;
-procedure UnMapRGB10A2(var pData: pByte; var Pixel: TglBitmapPixelData);
-var
- Temp: DWord;
-begin
- Temp := pDWord(pData)^;
-
- Pixel.Alpha := Temp shr PIXEL_DESC_RGB10A2.AlphaShift and PIXEL_DESC_RGB10A2.AlphaRange;
- Pixel.Red := Temp shr PIXEL_DESC_RGB10A2.RedShift and PIXEL_DESC_RGB10A2.RedRange;
- Pixel.Green := Temp shr PIXEL_DESC_RGB10A2.GreenShift and PIXEL_DESC_RGB10A2.GreenRange;
- Pixel.Blue := Temp and PIXEL_DESC_RGB10A2.BlueRange;
-
- Inc(pData, 4);
-end;
-
-
-function FormatGetUnMapFunc(const aInternalFormat: TglBitmapInternalFormat): TglBitmapUnMapFunc;
-begin
- case aInternalFormat of
- ifAlpha4: result := UnmapAlpha4;
- ifAlpha8: result := UnmapAlpha8;
- ifAlpha12: result := UnmapAlpha12;
- ifAlpha16: result := UnmapAlpha16;
-
- ifLuminance4: result := UnmapLuminance4;
- ifLuminance8: result := UnmapLuminance8;
- ifLuminance12: result := UnmapLuminance8;
- ifLuminance16: result := UnmapLuminance8;
-
- ifLuminance4Alpha4: result := UnmapLuminance4Alpha4;
- ifLuminance6Alpha2: result := UnmapLuminance6Alpha2;
- ifLuminance8Alpha8: result := UnmapLuminance8Alpha8;
- ifLuminance12Alpha4: result := UnmapLuminance12Alpha4;
- ifLuminance12Alpha12: result := UnmapLuminance12Alpha12;
- ifLuminance16Alpha16: result := UnmapLuminance16Alpha16;
-
- ifR3G3B2: result := UnmapR3G3B2;
- ifRGB4: result := UnmapRGB4;
- ifRGB5: result := UnmapRGB5;
- ifRGB8: result := UnmapRGB8;
- ifRGB10: result := UnmapRGB10;
- ifRGB12: result := UnmapRGB12;
- ifRGB16: result := UnmapRGB16;
-
- ifRGBA2: result := UnmapRGBA2;
- ifRGBA4: result := UnmapRGBA4;
- ifRGB5A1: result := UnmapRGB5A1;
- ifRGBA8: result := UnmapRGBA8;
- ifRGB10A2: result := UnmapRGB10A2;
- ifRGBA12: result := UnmapRGBA12;
- ifRGBA16: result := UnmapRGBA16;
-
- ifDepth16: result := UnmapDepth16;
- ifDepth24: result := UnmapDepth24;
- ifDepth32: result := UnmapDepth32;
- else
- raise EglBitmapUnsupportedInternalFormat.Create('FormatGetMapFunc - ' + UNSUPPORTED_INTERNAL_FORMAT);
- end;
+class procedure TfdBGRA8.Unmap(var aData: PByte; var aBitOffset: Byte; var aPixel: TglBitmapPixelData);
+begin
+ aPixel.Blue := aData^;
+ inc(aData);
+ aPixel.Green := aData^;
+ inc(aData);
+ aPixel.Red := aData^;
+ inc(aData);
+ aPixel.Alpha := aData^;
+ inc(aData);
end;
{$ENDREGION}
-{*
-** Tools
-*}
-function FormatGetSize (Format: TglBitmapInternalFormat): Single;
-begin
- case Format of
- ifEmpty:
- Result := 0;
- ifDXT1:
- Result := 0.5;
- ifAlpha, ifLuminance, ifDepth8, ifDXT3, ifDXT5:
- Result := 1;
- ifLuminanceAlpha, ifRGBA4, ifRGB5A1, ifR5G6B5:
- Result := 2;
- ifBGR8, ifRGB8:
- Result := 3;
- ifBGRA8, ifRGBA8, ifRGB10A2:
- Result := 4;
- else
- raise EglBitmapUnsupportedInternalFormat.Create('FormatGetSize - ' + UNSUPPORTED_INTERNAL_FORMAT);
- end;
+{$REGION TglBitmap }
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetHeight: Integer;
+begin
+ if (ffY in fDimension.Fields) then
+ result := fDimension.Y
+ else
+ result := -1;
end;
-
-function FormatIsCompressed(Format: TglBitmapInternalFormat): boolean;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetWidth: Integer;
begin
- Result := Format in [ifDXT1, ifDXT3, ifDXT5];
+ if (ffX in fDimension.Fields) then
+ result := fDimension.X
+ else
+ result := -1;
end;
-
-function FormatIsUncompressed(Format: TglBitmapInternalFormat): boolean;
+{$REGION Setter}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomData(const aValue: Pointer);
begin
- Result := Format in [ifAlpha, ifLuminance, ifDepth8, ifLuminanceAlpha, ifRGBA4, ifRGB5A1, ifR5G6B5, ifBGR8, ifRGB8, ifBGRA8, ifRGBA8, ifRGB10A2];
+ if fCustomData = aValue then
+ exit;
+ fCustomData := aValue;
end;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomName(const aValue: String);
+begin
+ if fCustomName = aValue then
+ exit;
+ fCustomName := aValue;
+end;
-function FormatIsEmpty(Format: TglBitmapInternalFormat): boolean;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomNameW(const aValue: WideString);
begin
- Result := Format = ifEmpty;
+ if fCustomNameW = aValue then
+ exit;
+ fCustomNameW := aValue;
end;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean);
+begin
+ if fDeleteTextureOnFree = aValue then
+ exit;
+ fDeleteTextureOnFree := aValue;
+end;
-function FormatHasAlpha(Format: TglBitmapInternalFormat): Boolean;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat);
begin
- Result := Format in [ifDXT1, ifDXT3, ifDXT5 ,ifAlpha, ifLuminanceAlpha, ifRGBA4, ifRGB5A1, ifBGRA8, ifRGBA8, ifRGB10A2];
+ if fFormat = aValue then
+ exit;
+ fFormat := aValue;
end;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetFreeDataAfterGenTexture(const aValue: Boolean);
+begin
+ if fFreeDataAfterGenTexture = aValue then
+ exit;
+ fFreeDataAfterGenTexture := aValue;
+end;
-procedure FormatPreparePixel(var Pixel: TglBitmapPixelData; Format: TglBitmapInternalFormat);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetID(const aValue: Cardinal);
begin
- FillChar(Pixel, SizeOf(Pixel), #0);
+ if fID = aValue then
+ exit;
+ fID := aValue;
+end;
- case Format of
- ifAlpha:
- Pixel.PixelDesc := PIXEL_DESC_ALPHA;
- ifLuminance:
- Pixel.PixelDesc := PIXEL_DESC_LUMINANCE;
- ifDepth8:
- Pixel.PixelDesc := PIXEL_DESC_DEPTH8;
- ifLuminanceAlpha:
- Pixel.PixelDesc := PIXEL_DESC_LUMINANCEALPHA;
- ifRGBA4:
- Pixel.PixelDesc := PIXEL_DESC_RGBA4;
- ifR5G6B5:
- Pixel.PixelDesc := PIXEL_DESC_R5G6B5;
- ifRGB5A1:
- Pixel.PixelDesc := PIXEL_DESC_RGB5A1;
- ifDXT1, ifDXT3, ifDXT5, ifBGRA8:
- Pixel.PixelDesc := PIXEL_DESC_BGRA8;
- ifBGR8:
- Pixel.PixelDesc := PIXEL_DESC_BGR8;
- ifRGB8:
- Pixel.PixelDesc := PIXEL_DESC_RGB8;
- ifRGBA8:
- Pixel.PixelDesc := PIXEL_DESC_RGBA8;
- ifRGB10A2:
- Pixel.PixelDesc := PIXEL_DESC_RGB10A2;
- end;
-
- Pixel.Red := Pixel.PixelDesc.RedRange;
- Pixel.Green := Pixel.PixelDesc.GreenRange;
- Pixel.Blue := Pixel.PixelDesc.BlueRange;
- Pixel.Alpha := Pixel.PixelDesc.AlphaRange;
-end;
-
-
-function FormatGetWithoutAlpha(Format: TglBitmapInternalFormat): TglBitmapInternalFormat;
-begin
- case Format of
- ifAlpha:
- Result := ifLuminance;
- ifLuminanceAlpha:
- Result := ifLuminance;
- ifRGBA4:
- Result := ifR5G6B5;
- ifRGB5A1:
- Result := ifR5G6B5;
- ifBGRA8:
- Result := ifBGR8;
- ifRGBA8:
- Result := ifRGB8;
- ifRGB10A2:
- Result := ifRGB8;
- else
- Result := Format;
- end;
-end;
-
-
-function FormatGetWithAlpha(Format: TglBitmapInternalFormat): TglBitmapInternalFormat;
-begin
- case Format of
- ifLuminance:
- Result := ifLuminanceAlpha;
- ifR5G6B5:
- Result := ifRGB5A1;
- ifBGR8:
- Result := ifBGRA8;
- ifRGB8:
- Result := ifRGBA8;
- else
- Result := Format;
- end;
-end;
-
-
-function FormatGetUncompressed(Format: TglBitmapInternalFormat): TglBitmapInternalFormat;
-begin
- case Format of
- ifDXT1:
- Result := ifRGB5A1;
- ifDXT3:
- Result := ifRGBA8;
- ifDXT5:
- Result := ifRGBA8;
- else
- Result := Format;
- end;
-end;
-
-
-function FormatGetImageSize(Size: TglBitmapPixelPosition; Format: TglBitmapInternalFormat): Integer;
-begin
- if (Size.X = 0) and (Size.Y = 0) then
- Result := 0
- else
- Result := Trunc(Max(Size.Y, 1) * Max(Size.X, 1) * FormatGetSize(Format));
-end;
-
-
-function FormatGetSupportedFiles(Format: TglBitmapInternalFormat): TglBitmapFileTypes;
-begin
- Result := [];
-
- {$IFDEF GLB_SUPPORT_PNG_WRITE}
- if Format in [ifLuminance, ifAlpha, ifDepth8, ifLuminanceAlpha, ifBGR8, ifBGRA8, ifRGB8, ifRGBA8] then
- Result := Result + [ftPNG];
- {$ENDIF}
-
- {$IFDEF GLB_SUPPORT_JPEG_WRITE}
- if Format in [ifLuminance, ifAlpha, ifDepth8, ifRGB8, ifBGR8] then
- Result := Result + [ftJPEG];
- {$ENDIF}
-
- Result := Result + [ftDDS];
-
- if Format in [ifLuminance, ifAlpha, ifDepth8, ifLuminanceAlpha, ifBGR8, ifRGB8, ifBGRA8, ifRGBA8] then
- Result := Result + [ftTGA];
-
- if Format in [ifLuminance, ifAlpha, ifDepth8, ifLuminanceAlpha, ifRGBA4, ifRGB5A1, ifR5G6B5, ifRGB8, ifBGR8, ifRGBA8, ifBGRA8, ifRGB10A2] then
- Result := Result + [ftBMP];
-end;
-
-
-function FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask: Cardinal; Format: TglBitmapInternalFormat): boolean;
-var
- Pix: TglBitmapPixelData;
-begin
- Result := False;
-
- if (RedMask = 0) and (GreenMask = 0) and (BlueMask = 0) and (AlphaMask = 0) then
- raise EglBitmapException.Create('FormatCheckFormat - All Masks are 0');
-
- FormatPreparePixel(Pix, Format);
-
- with Pix.PixelDesc do begin
- if RedMask <> 0 then
- if (RedMask <> (RedRange shl RedShift)) then
- Exit;
-
- if GreenMask <> 0 then
- if (GreenMask <> (GreenRange shl GreenShift)) then
- Exit;
-
- if BlueMask <> 0 then
- if (BlueMask <> (BlueRange shl BlueShift)) then
- Exit;
-
- if AlphaMask <> 0 then
- if (AlphaMask <> (AlphaRange shl AlphaShift)) then
- Exit;
-
- Result := True;
- end;
-end;
-
-
-function IsPowerOfTwo(Number: Integer): Boolean;
-begin
- while Number and 1 = 0 do
- Number := Number shr 1;
-
- Result := Number = 1;
-end;
-
-
-function GetBitSize(BitSet: Cardinal): Integer;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap);
begin
- Result := 0;
-
- while BitSet > 0 do begin
- if (BitSet and $1) = 1 then
- Inc(Result);
-
- BitSet := BitSet shr 1;
- end;
+ if fMipMap = aValue then
+ exit;
+ fMipMap := aValue;
end;
-
-procedure SwapRGB(pData: pByte; Width: Integer; HasAlpha: Boolean);
-type
- PRGBPix = ^TRGBPix;
- TRGBPix = array [0..2] of byte;
-var
- Temp: Byte;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetTarget(const aValue: Cardinal);
begin
- while Width > 0 do begin
- Temp := pRGBPIX(pData)^[0];
- pRGBPIX(pData)^[0] := pRGBPIX(pData)^[2];
- pRGBPIX(pData)^[2] := Temp;
-
- if HasAlpha then
- Inc(pData, 4)
- else
- Inc(pData, 3);
-
- Dec(Width);
- end;
+ if fTarget = aValue then
+ exit;
+ fTarget := aValue;
end;
-
-{$IFDEF GLB_DELPHI}
-function CreateGrayPalette: HPALETTE;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetAnisotropic(const aValue: Integer);
var
- Idx: Integer;
- Pal: PLogPalette;
+ MaxAnisotropic: Integer;
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;
+ fAnisotropic := Value;
+ if (ID > 0) then begin
+ if GL_EXT_texture_filter_anisotropic then begin
+ if fAnisotropic > 0 then begin
+ Bind(False);
+ glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAnisotropic);
+ if aValue > MaxAnisotropic then
+ fAnisotropic := MaxAnisotropic;
+ glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, fAnisotropic);
+ end;
+ end else begin
+ fAnisotropic := 0;
+ end;
end;
-
- {$IFDEF GLB_TEMPRANGECHECK}
- {$UNDEF GLB_TEMPRANGECHECK}
- {$R+}
- {$ENDIF}
-
- Result := CreatePalette(Pal^);
-
- FreeMem(Pal);
-end;
-{$ENDIF}
-
-
-{$IFDEF GLB_SDL_IMAGE}
-function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
-begin
- Result := TStream(context^.unknown.data1).Seek(offset, whence);
end;
+{$ENDREGION}
-
-function glBitmapRWread(context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer): Integer; cdecl;
+procedure TglBitmap.AfterConstruction;
begin
- Result := TStream(context^.unknown.data1).Read(Ptr^, size * maxnum);
-end;
+ inherited AfterConstruction;
+ fID := 0;
+ fTarget := 0;
+ fIsResident := False;
-function glBitmapRWwrite(context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer): Integer; cdecl;
-begin
- Result := TStream(context^.unknown.data1).Write(Ptr^, size * num);
-end;
-
+ fFormat := glBitmapGetDefaultFormat;
+ fMipMap := glBitmapDefaultMipmap;
+ fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture;
+ fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree;
-function glBitmapRWclose(context: PSDL_RWops): Integer; cdecl;
-begin
- Result := 0;
+ glBitmapGetDefaultFilter (fFilterMin, fFilterMag);
+ glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
end;
-
-function glBitmapCreateRWops(Stream: TStream): PSDL_RWops;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.BeforeDestruction;
begin
- Result := SDL_AllocRW;
-
- if Result = nil then
- raise EglBitmapException.Create('glBitmapCreateRWops - SDL_AllocRW failed.');
-
- Result^.seek := glBitmapRWseek;
- Result^.read := glBitmapRWread;
- Result^.write := glBitmapRWwrite;
- Result^.close := glBitmapRWclose;
- Result^.unknown.data1 := Stream;
+ SetDataPointer(nil, ifEmpty);
+ if (ID > 0) and fDeleteTextureOnFree then
+ glDeleteTextures(1, @ID);
+ inherited BeforeDestruction;
end;
-{$ENDIF}
-
-{*
-** Helper functions
-*}
-function LoadTexture(Filename: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal{$ENDIF}): Boolean;
-var
- glBitmap: TglBitmap2D;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.CreateID;
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;
+ if ID <> 0 then
+ glDeleteTextures(1, @ID);
+ glGenTextures(1, @ID);
+ Bind(false);
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;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetupParameters(var aBuildWithGlu: Boolean);
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);
+ // Set Up Parameters
+ SetWrap(fWrapS, fWrapT, fWrapR);
+ SetFilter(fFilterMin, fFilterMag);
+ SetAnisotropic(fAnisotropic);
+ SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);
- {$IFDEF GLB_DELPHI}
- if (LoadFromRes) then
- CM.LoadFromResource(Instance, NegativeZ)
+ // Mip Maps Generation Mode
+ aBuildWithGlu := False;
+ if (MipMap = mmMipmap) then begin
+ if (GL_VERSION_1_4 or GL_SGIS_generate_mipmap) then
+ glTexParameteri(Target, GL_GENERATE_MIPMAP, GL_TRUE)
else
- {$ENDIF}
- CM.LoadFromFile(NegativeZ);
- CM.GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);
-
- Texture := CM.ID;
- Result := True;
- finally
- CM.Free;
- end;
+ BuildWithGlu := True;
+ end else if (MipMap = mmMipmapGlu) then
+ BuildWithGlu := True;
end;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SelectFormat(const aFormat: TglBitmapFormat; var glFormat, glInternalFormat, glType: Cardinal);
-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;
+ procedure Check12;
+ begin
+ if not GL_VERSION_1_2 then
+ raise EglBitmapUnsupportedFormatFormat.Create('SelectFormat - You need at least OpenGL 1.2 to support these format.');
end;
-end;
-
-
-procedure glBitmapSetDefaultFormat(Format: TglBitmapFormat);
-begin
- glBitmapDefaultFormat := Format;
-end;
-
-
-procedure glBitmapSetDefaultDeleteTextureOnFree(DeleteTextureOnFree: Boolean);
-begin
- glBitmapDefaultDeleteTextureOnFree := DeleteTextureOnFree;
-end;
-
-procedure glBitmapSetDefaultFilter(Min, Mag: Integer);
begin
- glBitmapDefaultFilterMin := Min;
- glBitmapDefaultFilterMag := Mag;
-end;
+ PIXEL_DESC_ALPHA12;
+ glType := GL_UNSIGNED_BYTE;
+ glInternalFormat := Cardinal(aFormat);
+ case aFormat of
+ tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16:
+ glFormat := GL_ALPHA;
-procedure glBitmapSetDefaultWrap(S: Integer; T: Integer; R: Integer);
-begin
- glBitmapDefaultWrapS := S;
- glBitmapDefaultWrapT := T;
- glBitmapDefaultWrapR := R;
-end;
+ tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16:
+ glFormat := GL_LUMINANCE;
+ tfuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8,
+ tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16:
+ glFormat := GL_LUMINANCE_ALPHA;
-procedure glBitmapSetDefaultFreeDataAfterGenTexture(FreeData: Boolean);
-begin
- glBitmapDefaultFreeDataAfterGenTextures := FreeData;
-end;
+ tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16:
+ glFormat := GL_RGB;
+ tfRGBA2, tfRGBA4, tfRGB5A1, tfRGBA8, tfRGB10A2, tfRGBA12, tfRGBA16:
+ glFormat := GL_RGBA;
-function glBitmapGetDefaultFormat: TglBitmapFormat;
-begin
- Result := glBitmapDefaultFormat;
-end;
+ tfDepth16, tfDepth24, tfDepth32:
+ glFormat := GL_DEPTH_COMPONENT;
+ else
+ glFormat := 0;
+ end;
+ case aFormat of
+ tfRGBA4:
+ glType := GL_UNSIGNED_SHORT_4_4_4_4;
+ tfRGB5A1:
+ glType := GL_UNSIGNED_SHORT_5_5_5_1;
+ tfRG
+ end;
-function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
-begin
- Result := glBitmapDefaultDeleteTextureOnFree;
-end;
+ // selecting Format
+ case DataFormat of
+ ifAlpha:
+ glFormat := GL_ALPHA;
+ ifLuminance:
+ glFormat := GL_LUMINANCE;
+ ifDepth8:
+ glFormat := GL_DEPTH_COMPONENT;
+ ifLuminanceAlpha:
+ glFormat := GL_LUMINANCE_ALPHA;
+ ifBGR8:
+ begin
+ if (GL_VERSION_1_2 or GL_EXT_bgra) then begin
+ glFormat := GL_BGR;
+ end else begin
+ if CanConvertImage then
+ ConvertTo(tfRGB8);
+ glFormat := GL_RGB;
+ end;
+ end;
+ ifBGRA8:
+ begin
+ if (GL_VERSION_1_2 or GL_EXT_bgra) then begin
+ glFormat := GL_BGRA;
+ end else begin
+ if CanConvertImage then
+ ConvertTo(tfRGBA8);
+ glFormat := GL_RGBA;
+ end;
+ end;
+ tfRGB8:
+ glFormat := GL_RGB;
+ tfRGBA8:
+ glFormat := GL_RGBA;
+ tfRGBA4:
+ begin
+ Check12;
+ glFormat := GL_BGRA;
+ glType := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+ end;
+ tfRGB5A1:
+ begin
+ Check12;
+ glFormat := GL_BGRA;
+ glType := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+ end;
+ tfRGB10A2:
+ begin
+ Check12;
+ glFormat := GL_BGRA;
+ glType := GL_UNSIGNED_INT_2_10_10_10_REV;
+ end;
+ ifR5G6B5:
+ begin
+ Check12;
+ glFormat := GL_RGB;
+ glType := GL_UNSIGNED_SHORT_5_6_5;
+ end;
+ else
+ glFormat := 0;
+ end;
-procedure glBitmapGetDefaultFilter(var Min, Mag: Integer);
-begin
- Min := glBitmapDefaultFilterMin;
- Mag := glBitmapDefaultFilterMag;
+ // Selecting InternalFormat
+ case DataFormat of
+ ifDXT1, ifDXT3, ifDXT5:
+ begin
+ if GL_EXT_texture_compression_s3tc then begin
+ case DataFormat of
+ ifDXT1:
+ glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+ ifDXT3:
+ glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+ ifDXT5:
+ glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+ end;
+ end else begin
+ // Compression isn't supported so convert to RGBA
+ if CanConvertImage then
+ ConvertTo(tfRGBA8);
+ glFormat := GL_RGBA;
+ glInternalFormat := GL_RGBA8;
+ end;
+ end;
+ ifAlpha:
+ begin
+ case Format of
+ tf4BitsPerChanel:
+ glInternalFormat := GL_ALPHA4;
+ tf8BitsPerChanel:
+ glInternalFormat := GL_ALPHA8;
+ tfCompressed:
+ begin
+ if (GL_ARB_texture_compression or GL_VERSION_1_3) then
+ glInternalFormat := GL_COMPRESSED_ALPHA
+ else
+ glInternalFormat := GL_ALPHA;
+ end;
+ else
+ glInternalFormat := GL_ALPHA;
+ end;
+ end;
+ ifLuminance:
+ begin
+ case Format of
+ tf4BitsPerChanel:
+ glInternalFormat := GL_LUMINANCE4;
+ tf8BitsPerChanel:
+ glInternalFormat := GL_LUMINANCE8;
+ tfCompressed:
+ begin
+ if (GL_ARB_texture_compression or GL_VERSION_1_3) then
+ glInternalFormat := GL_COMPRESSED_LUMINANCE
+ else
+ glInternalFormat := GL_LUMINANCE;
+ end;
+ else
+ glInternalFormat := GL_LUMINANCE;
+ end;
+ end;
+ ifDepth8:
+ begin
+ glInternalFormat := GL_DEPTH_COMPONENT;
+ end;
+ ifLuminanceAlpha:
+ begin
+ case Format of
+ tf4BitsPerChanel:
+ glInternalFormat := GL_LUMINANCE4_ALPHA4;
+ tf8BitsPerChanel:
+ glInternalFormat := GL_LUMINANCE8_ALPHA8;
+ tfCompressed:
+ begin
+ if (GL_ARB_texture_compression or GL_VERSION_1_3) then
+ glInternalFormat := GL_COMPRESSED_LUMINANCE_ALPHA
+ else
+ glInternalFormat := GL_LUMINANCE_ALPHA;
+ end;
+ else
+ glInternalFormat := GL_LUMINANCE_ALPHA;
+ end;
+ end;
+ ifBGR8, tfRGB8:
+ begin
+ case Format of
+ tf4BitsPerChanel:
+ glInternalFormat := GL_RGB4;
+ tf8BitsPerChanel:
+ glInternalFormat := GL_RGB8;
+ tfCompressed:
+ begin
+ if (GL_ARB_texture_compression or GL_VERSION_1_3) then begin
+ glInternalFormat := GL_COMPRESSED_RGB
+ end else begin
+ if (GL_EXT_texture_compression_s3tc) then
+ glInternalFormat := GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+ else
+ glInternalFormat := GL_RGB;
+ end;
+ end;
+ else
+ glInternalFormat := GL_RGB;
+ end;
+ end;
+ ifBGRA8, tfRGBA8, tfRGBA4, tfRGB5A1, tfRGB10A2, ifR5G6B5:
+ begin
+ case Format of
+ tf4BitsPerChanel:
+ glInternalFormat := GL_RGBA4;
+ tf8BitsPerChanel:
+ glInternalFormat := GL_RGBA8;
+ tfCompressed:
+ begin
+ if (GL_ARB_texture_compression or GL_VERSION_1_3) then begin
+ glInternalFormat := GL_COMPRESSED_RGBA
+ end else begin
+ if (GL_EXT_texture_compression_s3tc) then
+ glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
+ else
+ glInternalFormat := GL_RGBA;
+ end;
+ end;
+ else
+ glInternalFormat := GL_RGBA;
+ end;
+ end;
+ end;
end;
-procedure glBitmapGetDefaultTextureWrap(var S, T, R: Integer);
-begin
- S := glBitmapDefaultWrapS;
- T := glBitmapDefaultWrapT;
- R := glBitmapDefaultWrapR;
-end;
-function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
-begin
- Result := glBitmapDefaultFreeDataAfterGenTextures;
-end;
-{ TglBitmap }
-procedure TglBitmap.AfterConstruction;
-begin
- inherited;
- fID := 0;
- fTarget := 0;
- fMipMap := mmMipmap;
- fIsResident := False;
- // get defaults
- fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture;
- fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree;
- fFormat := glBitmapGetDefaultFormat;
- glBitmapGetDefaultFilter(fFilterMin, fFilterMag);
- glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
-end;
-procedure TglBitmap.BeforeDestruction;
-begin
- SetDataPointer(nil, ifEmpty);
- if ((ID > 0) and (fDeleteTextureOnFree)) then
- glDeleteTextures(1, @ID);
- inherited;
-end;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor TglBitmap.Create;
begin
{$IFNDEF GLB_NO_NATIVE_GL}
constructor TglBitmap.Create(Size: TglBitmapPixelPosition;
- Format: TglBitmapInternalFormat);
+ Format: TglBitmapFormat);
var
Image: pByte;
ImageSize: Integer;
constructor TglBitmap.Create(Size: TglBitmapPixelPosition;
- Format: TglBitmapInternalFormat; Func: TglBitmapFunction; CustomData: Pointer);
+ Format: TglBitmapFormat; Func: TglBitmapFunction; CustomData: Pointer);
begin
Create;
LoadFromFunc(Size, Func, Format, CustomData);
end;
-procedure TglBitmap.LoadFromFile(FileName: String);
+procedure TglBitmap.LoadFromFile(const aFileName: String);
var
FS: TFileStream;
begin
end;
-procedure TglBitmap.LoadFromStream(Stream: TStream);
+procedure TglBitmap.LoadFromStream(const aStream: TStream);
begin
{$IFDEF GLB_SUPPORT_PNG_READ}
if not LoadPNG(Stream) then
-procedure TglBitmap.LoadFromFunc(Size: TglBitmapPixelPosition;
- Func: TglBitmapFunction; Format: TglBitmapInternalFormat; CustomData: Pointer);
+procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapPixelPosition;
+ const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat;
+ const aArgs: PtrInt);
var
Image: pByte;
ImageSize: Integer;
end;
-procedure TglBitmap.SaveToFile(FileName: String; FileType: TglBitmapFileType);
+procedure TglBitmap.SaveToFile(const aFileName: String;
+ const aFileType: TglBitmapFileType);
var
FS: TFileStream;
begin
end;
-procedure TglBitmap.SaveToStream(Stream: TStream; FileType: TglBitmapFileType);
+procedure TglBitmap.SaveToStream(const aStream: TStream;
+ const aFileType: TglBitmapFileType);
begin
case FileType of
{$IFDEF GLB_SUPPORT_PNG_WRITE}
end;
-procedure TglBitmap.SetFilter(Min, Mag: Integer);
+procedure TglBitmap.SetFilter(const aMin, aMag: Cardinal);
begin
case Min of
GL_NEAREST:
end;
-procedure TglBitmap.SetWrap(S: Integer; T: Integer; R: Integer);
+procedure TglBitmap.SetWrap(const S: Cardinal; const T: Cardinal;
+ const R: Cardinal);
begin
case S of
GL_CLAMP:
procedure TglBitmap.SetDataPointer(NewData: pByte;
- Format: TglBitmapInternalFormat; Width: Integer; Height: Integer);
+ Format: TglBitmapFormat; Width: Integer; Height: Integer);
begin
// Data
if Data <> NewData then begin
Info: TBMPInfo;
NewImage, pData: pByte;
- Format: TglBitmapInternalFormat;
+ Format: TglBitmapFormat;
LineSize, Padding, LineIdx: Integer;
RedMask, GreenMask, BlueMask, AlphaMask: Cardinal;
16:
begin
if (RedMask = 0) and (GreenMask = 0) and (BlueMask = 0) then begin
- Format := ifRGB5A1;
+ Format := tfRGB5A1;
end else begin
if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, ifLuminanceAlpha) then
Format := ifLuminanceAlpha;
- if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, ifRGBA4) then
- Format := ifRGBA4;
+ if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, tfRGBA4) then
+ Format := tfRGBA4;
- if FormatCheckFormat(RedMask, GreenMask, BlueMask, 0, ifRGB5A1) then
- Format := ifRGB5A1;
+ if FormatCheckFormat(RedMask, GreenMask, BlueMask, 0, tfRGB5A1) then
+ Format := tfRGB5A1;
if FormatCheckFormat(RedMask, GreenMask, BlueMask, 0, ifR5G6B5) then
Format := ifR5G6B5;
if (RedMask = 0) and (GreenMask = 0) and (BlueMask = 0) then begin
Format := ifBGRA8;
end else begin
- if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, ifRGBA8) then
- Format := ifRGBA8;
+ if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, tfRGBA8) then
+ Format := tfRGBA8;
if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, ifBGRA8) then
Format := ifBGRA8;
- if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, ifRGB10A2) then
- Format := ifRGB10A2;
+ if FormatCheckFormat(RedMask, GreenMask, BlueMask, AlphaMask, tfRGB10A2) then
+ Format := tfRGB10A2;
end;
end;
end;
end
else Stream.Position := StreamPos;
end;
-
+{$ENDREGION}
const
DDS_MAGIC = $20534444;
dwReserved: array[0..10] of Cardinal;
PixelFormat: TDDSPixelFormat;
Caps: TDDSCaps;
- dwReserved2: Cardinal;
- end;
-
-procedure TglBitmap.SetCustomData(const aValue: Pointer);
-begin
- if fCustomData = aValue then Exit;
- fCustomData := aValue;
-end;
-
-procedure TglBitmap.SetCustomName(const aValue: String);
-begin
- if fCustomName = aValue then Exit;
- fCustomName := aValue;
-end;
-
-procedure TglBitmap.SetCustomNameW(const aValue: WideString);
-begin
- if fCustomNameW = aValue then Exit;
- fCustomNameW := aValue;
-end;
-
-procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean);
-begin
- if fDeleteTextureOnFree = aValue then Exit;
- fDeleteTextureOnFree := aValue;
-end;
-
-procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat);
-begin
- if fFormat = aValue then Exit;
- fFormat := aValue;
-end;
-
-procedure TglBitmap.SetFreeDataAfterGenTexture(const aValue: Boolean);
-begin
- if fFreeDataAfterGenTexture = aValue then Exit;
- fFreeDataAfterGenTexture := aValue;
-end;
-
-procedure TglBitmap.SetID(const aValue: Cardinal);
-begin
- if fID = aValue then Exit;
- fID := aValue;
-end;
-
-procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap);
-begin
- if fMipMap = aValue then Exit;
- fMipMap := aValue;
-end;
+ dwReserved2: Cardinal;
+ end;
+
-procedure TglBitmap.SetTarget(const aValue: Cardinal);
-begin
- if fTarget = aValue then Exit;
- fTarget := aValue;
-end;
function TglBitmap.LoadDDS(Stream: TStream): Boolean;
var
// MipMapCount, X, Y, XSize, YSize: Cardinal;
RowSize: Cardinal;
NewImage, pData: pByte;
- Format: TglBitmapInternalFormat;
+ Format: TglBitmapFormat;
function RaiseEx : Exception;
end;
- function GetInternalFormat: TglBitmapInternalFormat;
+ function GetInternalFormat: TglBitmapFormat;
begin
with Header.PixelFormat do begin
// Compresses
if dwFlags and DDPF_ALPHAPIXELS > 0 then begin
// Alpha
case GetBitSize(dwRBitMask) of
- 5: Result := ifRGB5A1;
- 4: Result := ifRGBA4;
+ 5: Result := tfRGB5A1;
+ 4: Result := tfRGBA4;
else
Result := ifLuminanceAlpha;
end;
if dwRBitMask > dwBBitMask then
Result := ifBGR8
else
- Result := ifRGB8;
+ Result := tfRGB8;
end;
32:
begin
if GetBitSize(dwRBitMask) = 10 then
- Result := ifRGB10A2
+ Result := tfRGB10A2
else
if dwRBitMask > dwBBitMask then
Result := ifBGRA8
else
- Result := ifRGBA8;
+ Result := tfRGBA8;
end;
else
raise RaiseEx;
NewImage, pData: PByte;
StreamPos: Int64;
PixelSize, LineSize, YStart, YEnd, YInc: Integer;
- Format: TglBitmapInternalFormat;
+ Format: TglBitmapFormat;
const
CACHE_SIZE = $4000;
Pix: TglBitmapPixelData;
begin
if not FormatIsUncompressed(InternalFormat) then
- raise EglBitmapUnsupportedInternalFormat.Create('SaveDDS - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('SaveDDS - ' + UNSUPPORTED_INTERNAL_FORMAT);
if InternalFormat = ifAlpha then
FormatPreparePixel(Pix, ifLuminance)
begin
if not (ftTGA in FormatGetSupportedFiles (InternalFormat)) then
- raise EglBitmapUnsupportedInternalFormat.Create('SaveTGA - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('SaveTGA - ' + UNSUPPORTED_INTERNAL_FORMAT);
FillChar(Header, SizeOf(Header), 0);
Header.ImageType := TGA_UNCOMPRESSED_GRAY;
Header.Bpp := 16;
end;
- ifRGB8, ifBGR8:
+ tfRGB8, ifBGR8:
begin
Header.ImageType := TGA_UNCOMPRESSED_RGB;
Header.Bpp := 24;
end;
- ifRGBA8, ifBGRA8:
+ tfRGBA8, ifBGRA8:
begin
Header.ImageType := TGA_UNCOMPRESSED_RGB;
Header.Bpp := 32;
end;
else
- raise EglBitmapUnsupportedInternalFormat.Create('SaveTGA - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('SaveTGA - ' + UNSUPPORTED_INTERNAL_FORMAT);
end;
Header.Width := Width;
// convert RGB(A) to BGR(A)
Size := FormatGetImageSize(glBitmapPosition(Width, Height), InternalFormat);
- if InternalFormat in [ifRGB8, ifRGBA8] then begin
+ if InternalFormat in [tfRGB8, tfRGBA8] then begin
GetMem(pTemp, Size);
end else
pTemp := Data;
try
// convert data
- if InternalFormat in [ifRGB8, ifRGBA8] then begin
+ if InternalFormat in [tfRGB8, tfRGBA8] then begin
Move(Data^, pTemp^, Size);
ConvertData(pTemp);
end;
Stream.Write(pTemp^, Size);
finally
// free tempdata
- if InternalFormat in [ifRGB8, ifRGBA8] then
+ if InternalFormat in [tfRGB8, tfRGBA8] then
FreeMem(pTemp);
end;
end;
begin
if not (ftBMP in FormatGetSupportedFiles(InternalFormat)) then
- raise EglBitmapUnsupportedInternalFormat.Create('SaveBMP - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_INTERNAL_FORMAT);
ImageSize := Trunc(Width * Height * FormatGetSize(InternalFormat));
Info.biClrUsed := 256;
Info.biClrImportant := 256;
end;
- ifLuminanceAlpha, ifRGBA4, ifR5G6B5, ifRGB5A1:
+ ifLuminanceAlpha, tfRGBA4, ifR5G6B5, tfRGB5A1:
begin
Info.biBitCount := 16;
Info.biCompression := BMP_COMP_BITFIELDS;
end;
- ifBGR8, ifRGB8:
+ ifBGR8, tfRGB8:
Info.biBitCount := 24;
- ifBGRA8, ifRGBA8, ifRGB10A2:
+ ifBGRA8, tfRGBA8, tfRGB10A2:
begin
Info.biBitCount := 32;
Info.biCompression := BMP_COMP_BITFIELDS;
end;
else
- raise EglBitmapUnsupportedInternalFormat.Create('SaveBMP - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_INTERNAL_FORMAT);
end;
Info.biXPelsPerMeter := 2835;
Info.biYPelsPerMeter := 2835;
// prepare row buffer. But only for RGB because RGBA supports color masks
// so it's possible to change color within the image.
- if InternalFormat = ifRGB8 then
+ if InternalFormat = tfRGB8 then
GetMem(pTemp, fRowSize)
else
pTemp := nil;
// write image data
for LineIdx := 0 to Height - 1 do begin
// preparing row
- if InternalFormat = ifRGB8 then begin
+ if InternalFormat = tfRGB8 then begin
Move(pData^, pTemp^, fRowSize);
SwapRGB(pTemp, Width, False);
end else
end;
finally
// destroy row buffer
- if InternalFormat = ifRGB8 then
+ if InternalFormat = tfRGB8 then
FreeMem(pTemp);
end;
end;
end;
-procedure TglBitmap.CreateID;
-begin
- // Generate Texture
- if ID <> 0 then
- glDeleteTextures(1, @ID);
-
- glGenTextures(1, @ID);
-
- Bind(False);
-end;
-
-
-procedure TglBitmap.SetupParameters(var BuildWithGlu: Boolean);
-begin
- // Set up parameters
- SetWrap(fWrapS, fWrapT, fWrapR);
- SetFilter(fFilterMin, fFilterMag);
- SetAnisotropic(fAnisotropic);
- SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);
-
- // Mip Maps generation Mode
- BuildWithGlu := False;
-
- if (MipMap = mmMipmap) then begin
- if (GL_VERSION_1_4 or GL_SGIS_generate_mipmap) then
- glTexParameteri(Target, GL_GENERATE_MIPMAP, GL_TRUE)
- else
- BuildWithGlu := True;
- end else
- if (MipMap = mmMipmapGlu) then
- BuildWithGlu := True;
-end;
-
-
-procedure TglBitmap.SelectFormat(DataFormat: TglBitmapInternalFormat; var glFormat, glInternalFormat, glType: Cardinal; CanConvertImage: Boolean = True);
-
- procedure Check12;
- begin
- if not GL_VERSION_1_2 then
- raise EglBitmapUnsupportedInternalFormat.Create('SelectFormat - You need at least OpenGL 1.2 to support these format.');
- end;
-
-begin
- glType := GL_UNSIGNED_BYTE;
- // selecting Format
- case DataFormat of
- ifAlpha:
- glFormat := GL_ALPHA;
- ifLuminance:
- glFormat := GL_LUMINANCE;
- ifDepth8:
- glFormat := GL_DEPTH_COMPONENT;
- ifLuminanceAlpha:
- glFormat := GL_LUMINANCE_ALPHA;
- ifBGR8:
- begin
- if (GL_VERSION_1_2 or GL_EXT_bgra) then begin
- glFormat := GL_BGR;
- end else begin
- if CanConvertImage then
- ConvertTo(ifRGB8);
- glFormat := GL_RGB;
- end;
- end;
- ifBGRA8:
- begin
- if (GL_VERSION_1_2 or GL_EXT_bgra) then begin
- glFormat := GL_BGRA;
- end else begin
- if CanConvertImage then
- ConvertTo(ifRGBA8);
- glFormat := GL_RGBA;
- end;
- end;
- ifRGB8:
- glFormat := GL_RGB;
- ifRGBA8:
- glFormat := GL_RGBA;
- ifRGBA4:
- begin
- Check12;
- glFormat := GL_BGRA;
- glType := GL_UNSIGNED_SHORT_4_4_4_4_REV;
- end;
- ifRGB5A1:
- begin
- Check12;
- glFormat := GL_BGRA;
- glType := GL_UNSIGNED_SHORT_1_5_5_5_REV;
- end;
- ifRGB10A2:
- begin
- Check12;
- glFormat := GL_BGRA;
- glType := GL_UNSIGNED_INT_2_10_10_10_REV;
- end;
- ifR5G6B5:
- begin
- Check12;
- glFormat := GL_RGB;
- glType := GL_UNSIGNED_SHORT_5_6_5;
- end;
- else
- glFormat := 0;
- end;
- // Selecting InternalFormat
- case DataFormat of
- ifDXT1, ifDXT3, ifDXT5:
- begin
- if GL_EXT_texture_compression_s3tc then begin
- case DataFormat of
- ifDXT1:
- glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
- ifDXT3:
- glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
- ifDXT5:
- glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
- end;
- end else begin
- // Compression isn't supported so convert to RGBA
- if CanConvertImage then
- ConvertTo(ifRGBA8);
- glFormat := GL_RGBA;
- glInternalFormat := GL_RGBA8;
- end;
- end;
- ifAlpha:
- begin
- case Format of
- tf4BitsPerChanel:
- glInternalFormat := GL_ALPHA4;
- tf8BitsPerChanel:
- glInternalFormat := GL_ALPHA8;
- tfCompressed:
- begin
- if (GL_ARB_texture_compression or GL_VERSION_1_3) then
- glInternalFormat := GL_COMPRESSED_ALPHA
- else
- glInternalFormat := GL_ALPHA;
- end;
- else
- glInternalFormat := GL_ALPHA;
- end;
- end;
- ifLuminance:
- begin
- case Format of
- tf4BitsPerChanel:
- glInternalFormat := GL_LUMINANCE4;
- tf8BitsPerChanel:
- glInternalFormat := GL_LUMINANCE8;
- tfCompressed:
- begin
- if (GL_ARB_texture_compression or GL_VERSION_1_3) then
- glInternalFormat := GL_COMPRESSED_LUMINANCE
- else
- glInternalFormat := GL_LUMINANCE;
- end;
- else
- glInternalFormat := GL_LUMINANCE;
- end;
- end;
- ifDepth8:
- begin
- glInternalFormat := GL_DEPTH_COMPONENT;
- end;
- ifLuminanceAlpha:
- begin
- case Format of
- tf4BitsPerChanel:
- glInternalFormat := GL_LUMINANCE4_ALPHA4;
- tf8BitsPerChanel:
- glInternalFormat := GL_LUMINANCE8_ALPHA8;
- tfCompressed:
- begin
- if (GL_ARB_texture_compression or GL_VERSION_1_3) then
- glInternalFormat := GL_COMPRESSED_LUMINANCE_ALPHA
- else
- glInternalFormat := GL_LUMINANCE_ALPHA;
- end;
- else
- glInternalFormat := GL_LUMINANCE_ALPHA;
- end;
- end;
- ifBGR8, ifRGB8:
- begin
- case Format of
- tf4BitsPerChanel:
- glInternalFormat := GL_RGB4;
- tf8BitsPerChanel:
- glInternalFormat := GL_RGB8;
- tfCompressed:
- begin
- if (GL_ARB_texture_compression or GL_VERSION_1_3) then begin
- glInternalFormat := GL_COMPRESSED_RGB
- end else begin
- if (GL_EXT_texture_compression_s3tc) then
- glInternalFormat := GL_COMPRESSED_RGB_S3TC_DXT1_EXT
- else
- glInternalFormat := GL_RGB;
- end;
- end;
- else
- glInternalFormat := GL_RGB;
- end;
- end;
- ifBGRA8, ifRGBA8, ifRGBA4, ifRGB5A1, ifRGB10A2, ifR5G6B5:
- begin
- case Format of
- tf4BitsPerChanel:
- glInternalFormat := GL_RGBA4;
- tf8BitsPerChanel:
- glInternalFormat := GL_RGBA8;
- tfCompressed:
- begin
- if (GL_ARB_texture_compression or GL_VERSION_1_3) then begin
- glInternalFormat := GL_COMPRESSED_RGBA
- end else begin
- if (GL_EXT_texture_compression_s3tc) then
- glInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
- else
- glInternalFormat := GL_RGBA;
- end;
- end;
- else
- glInternalFormat := GL_RGBA;
- end;
- end;
- end;
-end;
function TglBitmap.FlipHorz: Boolean;
end;
-procedure TglBitmap.SetAnisotropic(const aValue: Integer);
-var
- MaxAniso: Integer;
-begin
- fAnisotropic := Value;
-
- if (ID > 0) then begin
- if GL_EXT_texture_filter_anisotropic then begin
- if fAnisotropic > 0 then begin
- Bind(False);
-
- glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAniso);
-
- if Value > MaxAniso then
- fAnisotropic := MaxAniso;
-
- glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, fAnisotropic);
- end;
- end else begin
- fAnisotropic := 0;
- end;
- end;
-end;
-
-procedure TglBitmap.SetInternalFormat(const aValue: TglBitmapInternalFormat);
+procedure TglBitmap.SetInternalFormat(const aValue: TglBitmapFormat);
begin
if InternalFormat <> Value then begin
if FormatGetSize(Value) <> FormatGetSize(InternalFormat) then
- raise EglBitmapUnsupportedInternalFormat.Create('SetInternalFormat - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('SetInternalFormat - ' + UNSUPPORTED_INTERNAL_FORMAT);
// Update whatever
SetDataPointer(Data, Value);
function TglBitmap.AddFunc(Source: TglBitmap; Func: TglBitmapFunction;
- CreateTemp: Boolean; Format: TglBitmapInternalFormat; CustomData: Pointer): boolean;
+ CreateTemp: Boolean; Format: TglBitmapFormat; CustomData: Pointer): boolean;
var
pDest, NewImage, pSource: pByte;
TempHeight, TempWidth: Integer;
end;
-function TglBitmap.ConvertTo(NewFormat: TglBitmapInternalFormat): boolean;
+function TglBitmap.ConvertTo(NewFormat: TglBitmapFormat): boolean;
var
Source, Dest: TglBitmapPixelData;
PixelDesc: TglBitmapPixelDesc;
if (Assigned(Data)) then begin
if not (FormatIsUncompressed(InternalFormat) or FormatHasAlpha(InternalFormat)) then
- raise EglBitmapUnsupportedInternalFormat.Create('RemoveAlpha - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('RemoveAlpha - ' + UNSUPPORTED_INTERNAL_FORMAT);
Result := ConvertTo(FormatGetWithoutAlpha(InternalFormat));
end;
function TglBitmap.AddAlphaFromFunc(Func: TglBitmapFunction; CustomData: Pointer): boolean;
begin
if not FormatIsUncompressed(InternalFormat) then
- raise EglBitmapUnsupportedInternalFormat.Create('AddAlphaFromFunc - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('AddAlphaFromFunc - ' + UNSUPPORTED_INTERNAL_FORMAT);
Result := AddFunc(Self, Func, False, FormatGetWithAlpha(InternalFormat), CustomData);
end;
-function TglBitmap.GetHeight: Integer;
-begin
- if ffY in fDimension.Fields then
- Result := fDimension.Y
- else
- Result := -1;
-end;
-
-
-function TglBitmap.GetWidth: Integer;
-begin
- if ffX in fDimension.Fields then
- Result := fDimension.X
- else
- Result := -1;
-end;
-
-
function TglBitmap.GetFileHeight: Integer;
begin
Result := Max(1, Height);
{ TglBitmap2D }
-procedure TglBitmap2D.SetDataPointer(Data: pByte; Format: TglBitmapInternalFormat; Width, Height: Integer);
+procedure TglBitmap2D.SetDataPointer(Data: pByte; Format: TglBitmapFormat; Width, Height: Integer);
var
Idx, LineWidth: Integer;
begin
begin
if not FormatIsUncompressed(InternalFormat) then
- raise EglBitmapUnsupportedInternalFormat.Create('TglBitmap2D.ToNormalMap - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('TglBitmap2D.ToNormalMap - ' + UNSUPPORTED_INTERNAL_FORMAT);
if Scale > 100 then
Rec.Scale := 100
end;
-procedure TglBitmap2D.GrabScreen(Top, Left, Right, Bottom: Integer; Format: TglBitmapInternalFormat);
+procedure TglBitmap2D.GrabScreen(Top, Left, Right, Bottom: Integer; Format: TglBitmapFormat);
var
Temp: pByte;
Size: Integer;
glFormat, glInternalFormat, glType: Cardinal;
begin
if not FormatIsUncompressed(Format) then
- raise EglBitmapUnsupportedInternalFormat.Create('TglBitmap2D.GrabScreen - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormatFormat.Create('TglBitmap2D.GrabScreen - ' + UNSUPPORTED_INTERNAL_FORMAT);
// Only to select Formats
SelectFormat(Format, glFormat, glInternalFormat, glType, False);
Temp: pByte;
TempWidth, TempHeight, RedSize, GreenSize, BlueSize, AlphaSize, LumSize: Integer;
TempType, TempIntFormat: Cardinal;
- IntFormat: TglBitmapInternalFormat;
+ IntFormat: TglBitmapFormat;
begin
Bind;
TempType := GL_UNSIGNED_SHORT_5_6_5;
end;
GL_RGB, GL_RGB8:
- IntFormat := ifRGB8;
+ IntFormat := tfRGB8;
GL_RGBA, GL_RGBA4, GL_RGBA8:
begin
if (RedSize = 4) and (BlueSize = 4) and (GreenSize = 4) and (AlphaSize = 4) then begin
- IntFormat := ifRGBA4;
+ IntFormat := tfRGBA4;
TempIntFormat := GL_BGRA;
TempType := GL_UNSIGNED_SHORT_4_4_4_4_REV;
end else
if (RedSize = 5) and (BlueSize = 5) and (GreenSize = 5) and (AlphaSize = 1) then begin
- IntFormat := ifRGB5A1;
+ IntFormat := tfRGB5A1;
TempIntFormat := GL_BGRA;
TempType := GL_UNSIGNED_SHORT_1_5_5_5_REV;
end else begin
- IntFormat := ifRGBA8;
+ IntFormat := tfRGBA8;
end;
end;
GL_BGR:
GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, TestTextureSize);
end;
-
-
initialization
- glBitmapSetDefaultFormat(tfDefault);
+ glBitmapSetDefaultFormat(tfEmpty);
+ glBitmapSetDefaultMipmap(mmMipmap);
glBitmapSetDefaultFilter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
- glBitmapSetDefaultWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+ glBitmapSetDefaultWrap (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
- glBitmapSetDefaultFreeDataAfterGenTexture(True);
- glBitmapSetDefaultDeleteTextureOnFree(True);
+ glBitmapSetDefaultFreeDataAfterGenTexture(true);
+ glBitmapSetDefaultDeleteTextureOnFree (true);
finalization
projects / glBitmap.git / blobdiff