Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapData.html b/doc/glBitmap.TglBitmapData.html new file mode 100644 index 0000000..1e23065 --- /dev/null +++ b/doc/glBitmap.TglBitmapData.html @@ -0,0 +1,1539 @@ + + + +glBitmap: Class TglBitmapData + + + + + +

Class TglBitmapData

+ + +

Unit

+glBitmap

Declaration

+type TglBitmapData = class(TObject)

Description

+class to store texture data in. used to load, save and manipulate data before assigned to texture object all operations on a data object can be done from a background thread

Hierarchy

TObject
TglBitmapData

Overview

Fields

+ + + + + + + + + + + + + + + + + + + + + + + + + +

	`fData: PByte;`
	`fDimension: TglBitmapSize;`
	`fFormat: TglBitmapFormat;`
	`fFilename: String;`
	`fScanlines: array of PByte;`
	`fHasScanlines: Boolean;`

Methods

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`function GetFormatDescriptor: TglBitmapFormatDescriptor;`
	`function GetWidth: Integer;`
	`function GetHeight: Integer;`
	`function GetScanlines(const aIndex: Integer): PByte;`
	`procedure SetFormat(const aValue: TglBitmapFormat);`
	`procedure PrepareResType(var aResource: String; var aResType: PChar);`
	`procedure UpdateScanlines;`
	`function LoadPNG(const aStream: TStream): Boolean; virtual;`
	`procedure SavePNG(const aStream: TStream); virtual;`
	`function LoadJPEG(const aStream: TStream): Boolean; virtual;`
	`procedure SaveJPEG(const aStream: TStream); virtual;`
	`function LoadRAW(const aStream: TStream): Boolean;`
	`procedure SaveRAW(const aStream: TStream);`
	`function LoadBMP(const aStream: TStream): Boolean;`
	`procedure SaveBMP(const aStream: TStream);`
	`function LoadTGA(const aStream: TStream): Boolean;`
	`procedure SaveTGA(const aStream: TStream);`
	`function LoadDDS(const aStream: TStream): Boolean;`
	`procedure SaveDDS(const aStream: TStream);`
	`function FlipHorz: Boolean; virtual;`
	`function FlipVert: Boolean; virtual;`
	`procedure LoadFromFile(const aFilename: String);`
	`procedure LoadFromStream(const aStream: TStream); virtual;`
	`procedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);`
	`procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);`
	`procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);`
	`procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);`
	`procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;`
	`function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;`
	`function Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;`
	`function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;`
	`function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;`
	`function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;`
	`function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;`
	`function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;`
	`function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;`
	`function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;`
	`function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;`
	`function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;`
	`function AddAlphaFromValue(const aAlpha: Byte): Boolean;`
	`function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;`
	`function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;`
	`function RemoveAlpha: Boolean; virtual;`
	`procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);`
	`procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);`
	`procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);`
	`procedure SetData(const aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;`
	`function Clone: TglBitmapData;`
	`procedure Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);`
	`procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);`
	`constructor Create; overload;`
	`constructor Create(const aFileName: String); overload;`
	`constructor Create(const aStream: TStream); overload;`
	`constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;`
	`constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;`
	`constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;`
	`constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;`
	`destructor Destroy; override;`

Properties

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

	`property Data: PByte read fData;`
	`property Dimension: TglBitmapSize read fDimension;`
	`property Filename: String read fFilename;`
	`property Width: Integer read GetWidth;`
	`property Height: Integer read GetHeight;`
	`property Format: TglBitmapFormat read fFormat write SetFormat;`
	`property Scanlines[constaIndex:Integer]: PByte read GetScanlines;`
	`property FormatDescriptor: TglBitmapFormatDescriptor read GetFormatDescriptor;`

Description

Fields

+ + + + + + +

	`fData: PByte;`
+ +texture data +

+ + + + + + +

	`fDimension: TglBitmapSize;`
+ +pixel size of the data +

+ + + + + + +

	`fFormat: TglBitmapFormat;`
+ +format the texture data is stored in +

+ + + + + + +

	`fFilename: String;`
+ +file the data was load from +

+ + + + + + +

	`fScanlines: array of PByte;`
+ +pointer to begin of each line +

+ + + + + + +

	`fHasScanlines: Boolean;`
+ +`True` if scanlines are initialized, `False` otherwise +

Methods

+ + + + + + +

function GetFormatDescriptor: TglBitmapFormatDescriptor;

Returns

the format descriptor suitable to the texture data format

+ + + + + + +

function GetWidth: Integer;

Returns

the width of the texture data (in pixel) or -1 if no data is set

+ + + + + + +

function GetHeight: Integer;

Returns

the height of the texture data (in pixel) or -1 if no data is set

+ + + + + + +

function GetScanlines(const aIndex: Integer): PByte;

+get scanline at index aIndex

Returns

Pointer to start of line or Nil

+ + + + + + +

	`procedure SetFormat(const aValue: TglBitmapFormat);`
+ +set new value for the data format. only possible if new format has the same pixel size. if you want to convert the texture data, see ConvertTo function +

+ + + + + + +

procedure PrepareResType(var aResource: String; var aResType: PChar);

+splits a resource identifier into the resource and it's type

Parameters

aResource: resource identifier to split and store name in
aResType: type of the resource

+ + + + + + +

	`procedure UpdateScanlines;`
+ +updates scanlines array +

+ + + + + + +

function LoadPNG(const aStream: TStream): Boolean; virtual;

+try to load a PNG from a stream

Parameters

aStream: stream to load PNG from

Returns

True on success, False otherwise

+ + + + + + +

procedure SavePNG(const aStream: TStream); virtual;

+save texture data as PNG to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadJPEG(const aStream: TStream): Boolean; virtual;

+try to load a JPEG from a stream

Parameters

aStream: stream to load JPEG from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveJPEG(const aStream: TStream); virtual;

+save texture data as JPEG to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadRAW(const aStream: TStream): Boolean;

+try to load a RAW image from a stream

Parameters

aStream: stream to load RAW image from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveRAW(const aStream: TStream);

+save texture data as RAW image to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadBMP(const aStream: TStream): Boolean;

+try to load a BMP from a stream

Parameters

aStream: stream to load BMP from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveBMP(const aStream: TStream);

+save texture data as BMP to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadTGA(const aStream: TStream): Boolean;

+try to load a TGA from a stream

Parameters

aStream: stream to load TGA from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveTGA(const aStream: TStream);

+save texture data as TGA to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function LoadDDS(const aStream: TStream): Boolean;

+try to load a DDS from a stream

Parameters

aStream: stream to load DDS from

Returns

True on success, False otherwise

+ + + + + + +

procedure SaveDDS(const aStream: TStream);

+save texture data as DDS to stream

Parameters

aStream: stream to save data to

+ + + + + + +

function FlipHorz: Boolean; virtual;

+flip texture horizontal

Returns

True in success, False otherwise

+ + + + + + +

function FlipVert: Boolean; virtual;

+flip texture vertical

Returns

True in success, False otherwise

+ + + + + + +

procedure LoadFromFile(const aFilename: String);

+load a texture from a file

Parameters

aFilename: file to load texuture from

+ + + + + + +

procedure LoadFromStream(const aStream: TStream); virtual;

+load a texture from a stream

Parameters

aStream: stream to load texture from

+ + + + + + +

procedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);

+use a function to generate texture data

Parameters

aSize: size of the texture
aFunc: callback to use for generation
aFormat: format of the texture data
aArgs: user defined paramaters (use at will)

+ + + + + + +

procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);

+load a texture from a resource

Parameters

aInstance: resource handle
aResource: resource indentifier
aResType: resource type (if known)

+ + + + + + +

procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);

+load a texture from a resource id

Parameters

aInstance: resource handle
aResource: resource ID
aResType: resource type

+ + + + + + +

procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);

+save texture data to a file

Parameters

aFilename: filename to store texture in
aFileType: file type to store data into

+ + + + + + +

procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;

+save texture data to a stream

Parameters

aFilename: filename to store texture in
aFileType: file type to store data into

+ + + + + + +

function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;

+convert texture data using a user defined callback

Parameters

aFunc: callback to use for converting
aCreateTemp: create a temporary buffer to use for converting
aArgs: user defined paramters (use at will)

Returns

True if converting was successful, False otherwise

+ + + + + + +

function Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;

+convert texture data using a user defined callback

Parameters

aSource: glBitmap to read data from
aFunc: callback to use for converting
aCreateTemp: create a temporary buffer to use for converting
aFormat: format of the new data
aArgs: user defined paramters (use at will)

Returns

True if converting was successful, False otherwise

+ + + + + + +

function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;

+convert texture data using a specific format

Parameters

aFormat: new format of texture data

Returns

True if converting was successful, False otherwise

+ + + + + + +

function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;

+assign texture data to TLazIntfImage object

Parameters

aImage: TLazIntfImage to write data to

Returns

True on success, False otherwise

+ + + + + + +

function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;

+assign texture data from TLazIntfImage object

Parameters

aImage: TLazIntfImage to read data from

Returns

True on success, False otherwise

+ + + + + + +

function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;

+assign alpha channel data to TLazIntfImage object

Parameters

aImage: TLazIntfImage to write data to

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+assign alpha channel data from TLazIntfImage object

Parameters

aImage: TLazIntfImage to read data from
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+load alpha channel data from resource

Parameters

aInstance: resource handle
aResource: resource ID
aResType: resource type
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+load alpha channel data from resource ID

Parameters

aInstance: resource handle
aResourceID: resource ID
aResType: resource type
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;

+add alpha channel data from function

Parameters

aFunc: callback to get data from
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+add alpha channel data from file (macro for: new glBitmap, LoadFromFile, AddAlphaFromGlBitmap)

Parameters

aFilename: file to load alpha channel data from
aFunc: callback to use for converting
aArgs: SetFormat user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;

+add alpha channel data from stream (macro for: new glBitmap, LoadFromStream, AddAlphaFromGlBitmap)

Parameters

aStream: stream to load alpha channel data from
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;

+add alpha channel data from existing glBitmap object

Parameters

aBitmap: TglBitmap to copy alpha channel data from
aFunc: callback to use for converting
aArgs: user defined parameters (use at will)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;

+add alpha to pixel if the pixels color is greter than the given color value

Parameters

aRed: red threshold (0-255)
aGreen: green threshold (0-255)
aBlue: blue threshold (0-255)
aDeviatation: accepted deviatation (0-255)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;

+add alpha to pixel if the pixels color is greter than the given color value

Parameters

aRed: red threshold (0-Range.r)
aGreen: green threshold (0-Range.g)
aBlue: blue threshold (0-Range.b)
aDeviatation: accepted deviatation (0-max(Range.rgb))

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;

+add alpha to pixel if the pixels color is greter than the given color value

Parameters

aRed: red threshold (0.0-1.0)
aGreen: green threshold (0.0-1.0)
aBlue: blue threshold (0.0-1.0)
aDeviatation: accepted deviatation (0.0-1.0)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromValue(const aAlpha: Byte): Boolean;

+add a constand alpha value to all pixels

Parameters

aAlpha: alpha value to add (0-255)

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;

+add a constand alpha value to all pixels

Parameters

aAlpha: alpha value to add (0-max(Range.rgb))

Returns

True on success, False otherwise

+ + + + + + +

function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;

+add a constand alpha value to all pixels

Parameters

aAlpha: alpha value to add (0.0-1.0)

Returns

True on success, False otherwise

+ + + + + + +

function RemoveAlpha: Boolean; virtual;

+remove alpha channel

Returns

True on success, False otherwise

+ + + + + + +

procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);

+fill complete texture with one color

Parameters

aRed: red color for border (0-255)
aGreen: green color for border (0-255)
aBlue: blue color for border (0-255)
aAlpha: alpha color for border (0-255)

+ + + + + + +

procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);

+fill complete texture with one color

Parameters

aRed: red color for border (0-Range.r)
aGreen: green color for border (0-Range.g)
aBlue: blue color for border (0-Range.b)
aAlpha: alpha color for border (0-Range.a)

+ + + + + + +

procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);

+fill complete texture with one color

Parameters

aRed: red color for border (0.0-1.0)
aGreen: green color for border (0.0-1.0)
aBlue: blue color for border (0.0-1.0)
aAlpha: alpha color for border (0.0-1.0)

+ + + + + + +

procedure SetData(const aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;

+set data pointer of texture data

Parameters

aData: pointer to new texture data
aFormat: format of the data stored at aData
aWidth: width of the texture data
aHeight: height of the texture data

+ + + + + + +

function Clone: TglBitmapData;

+create a clone of the current object

Returns

clone of this object

+ + + + + + +

procedure Invert(const aRed, aGreen, aBlue, aAlpha: Boolean);

+invert color data (bitwise not)

Parameters

aRed: invert red channel
aGreen: invert green channel
aBlue: invert blue channel
aAlpha: invert alpha channel

+ + + + + + +

procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);

+create normal map from texture data

Parameters

aFunc: normal map function to generate normalmap with
aScale: scale of the normale stored in the normal map
aUseAlpha: generate normalmap from alpha channel data (if present)

+ + + + + + +

	`constructor Create; overload;`
+ +constructor - creates a texutre data object +

+ + + + + + +

constructor Create(const aFileName: String); overload;

+constructor - creates a texture data object and loads it from a file

Parameters

aFilename: file to load texture from

+ + + + + + +

constructor Create(const aStream: TStream); overload;

+constructor - creates a texture data object and loads it from a stream

Parameters

aStream: stream to load texture from

+ + + + + + +

constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;

+constructor - creates a texture data object with the given size, format and data

Parameters

aSize: size of the texture
aFormat: format of the given data
aData: texture data - be carefull: the data will now be managed by the texture data object

+ + + + + + +

constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;

+constructor - creates a texture data object with the given size and format and uses the given callback to create the data

Parameters

aSize: size of the texture
aFormat: format of the given data
aFunc: callback to use for generating the data
aArgs: user defined parameters (use at will)

+ + + + + + +

constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;

+constructor - creates a texture data object and loads it from a resource

Parameters

aInstance: resource handle
aResource: resource indentifier
aResType: resource type (if known)

+ + + + + + +

constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;

+constructor - creates a texture data object and loads it from a resource

Parameters

aInstance: resource handle
aResourceID: resource ID
aResType: resource type (if known)

+ + + + + + +

	`destructor Destroy; override;`
+ +destructor +

Properties

+ + + + + + +

	`property Data: PByte read fData;`
+ +texture data (be carefull with this!) +

+ + + + + + +

	`property Dimension: TglBitmapSize read fDimension;`
+ +size of the texture data (in pixel) +

+ + + + + + +

	`property Filename: String read fFilename;`
+ +file the data was loaded from +

+ + + + + + +

	`property Width: Integer read GetWidth;`
+ +width of the texture data (in pixel) +

+ + + + + + +

	`property Height: Integer read GetHeight;`
+ +height of the texture data (in pixel) +

+ + + + + + +

	`property Format: TglBitmapFormat read fFormat write SetFormat;`
+ +format the texture data is stored in +

+ + + + + + +

	`property Scanlines[constaIndex:Integer]: PByte read GetScanlines;`
+ +pointer to begin of line at given index or `Nil` +

+ + + + + + +

	`property FormatDescriptor: TglBitmapFormatDescriptor read GetFormatDescriptor;`
+ +descriptor object that describes the format of the stored data +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 + +

diff --git a/doc/glBitmap.TglBitmapFormatDescriptor.html b/doc/glBitmap.TglBitmapFormatDescriptor.html index c903418..5e899f1 100644 --- a/doc/glBitmap.TglBitmapFormatDescriptor.html +++ b/doc/glBitmap.TglBitmapFormatDescriptor.html @@ -132,6 +132,14 @@ describes the properties of a given texture data format

+function GetSize(const aSize: TglBitmapSize): Integer; overload; virtual; + + +

+function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; + + +

constructor Create; @@ -484,6 +492,22 @@ calculate cached values

+ + + +

	`function GetSize(const aSize: TglBitmapSize): Integer; overload; virtual;`
+

+ + + + + + +

	`function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;`
+

+ + +

constructor Create;

@@ -738,6 +762,6 @@ OpenGL data format enum (e.g. GL_UNSIGNED_BYTE)

True if the format is a grayscale format, False otherwise

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapFunctionRec.html b/doc/glBitmap.TglBitmapFunctionRec.html index 23f734f..f8833da 100644 --- a/doc/glBitmap.TglBitmapFunctionRec.html +++ b/doc/glBitmap.TglBitmapFunctionRec.html @@ -26,7 +26,7 @@ structure to store data for converting in

Fields

- + @@ -48,7 +48,7 @@ structure to store data for converting in

Fields

`Sender: TglBitmap;`	`Sender: TglBitmapData;`
`Size: TglBitmapSize;`

- +

Sender: TglBitmap; Sender: TglBitmapData;

@@ -100,6 +100,6 @@ new data of the pixel (must be filled in)

user defined args that was passed to the convert function

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapNormalMap.html b/doc/glBitmap.TglBitmapNormalMap.html index b58e758..daf09c0 100644 --- a/doc/glBitmap.TglBitmapNormalMap.html +++ b/doc/glBitmap.TglBitmapNormalMap.html @@ -21,7 +21,7 @@ type TglBitmapNormalMap = class(TglBitmapCubeMap)

Description

-wrapper class for cube normal maps

+wrapper class for cube normal maps all operations on a bitmap object must be done from the render thread

Hierarchy

TObject
TglBitmap

procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true);

procedure GenerateNormalMap(const aSize: Integer = 32; const aCheckSize: Boolean = true);

Description

procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true); procedure GenerateNormalMap(const aSize: Integer = 32; const aCheckSize: Boolean = true);

@@ -63,11 +63,11 @@ create cube normal map from texture data and upload it to video card

aSize: size of each cube map texture
aTestTextureSize: check texture size when uploading and throw exception if something is wrong
aCheckSize: check size before upload and throw exception if something is wrong

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapPixelData.html b/doc/glBitmap.TglBitmapPixelData.html index 9144e65..e468b17 100644 --- a/doc/glBitmap.TglBitmapPixelData.html +++ b/doc/glBitmap.TglBitmapPixelData.html @@ -64,6 +64,6 @@ maximal color value for each channel

format of the pixel

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapRec4ub.html b/doc/glBitmap.TglBitmapRec4ub.html index 7f5f880..f7dec9a 100644 --- a/doc/glBitmap.TglBitmapRec4ub.html +++ b/doc/glBitmap.TglBitmapRec4ub.html @@ -78,6 +78,6 @@ record that stores 4 unsigned byte values

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapRec4ui.html b/doc/glBitmap.TglBitmapRec4ui.html index 36e5ce5..6365e17 100644 --- a/doc/glBitmap.TglBitmapRec4ui.html +++ b/doc/glBitmap.TglBitmapRec4ui.html @@ -78,6 +78,6 @@ record that stores 4 unsigned integer values

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapRec4ul.html b/doc/glBitmap.TglBitmapRec4ul.html index f9e9b67..9d5f10f 100644 --- a/doc/glBitmap.TglBitmapRec4ul.html +++ b/doc/glBitmap.TglBitmapRec4ul.html @@ -78,6 +78,6 @@ record that stores 4 unsigned long integer values

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.TglBitmapSize.html b/doc/glBitmap.TglBitmapSize.html index 67b9ace..78f6f1f 100644 --- a/doc/glBitmap.TglBitmapSize.html +++ b/doc/glBitmap.TglBitmapSize.html @@ -56,6 +56,6 @@ -

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/glBitmap.html b/doc/glBitmap.html index 839c453..9f34b78 100644 --- a/doc/glBitmap.html +++ b/doc/glBitmap.html @@ -62,15 +62,15 @@ glBitmap by Steffen Xonna aka Lossy eX (2003-2008) -Class TglBitmapFormatDescriptor +packed record TglBitmapPixelData -packed record TglBitmapPixelData +packed record TglBitmapSize -packed record TglBitmapSize +Class TglBitmapFormatDescriptor @@ -78,22 +78,26 @@ glBitmap by Steffen Xonna aka Lossy eX (2003-2008) -Class TglBitmap +Class TglBitmapData -Class TglBitmap1D +Class TglBitmap -Class TglBitmap2D +Class TglBitmap1D -Class TglBitmapCubeMap +Class TglBitmap2D +Class TglBitmapCubeMap + + + Class TglBitmapNormalMap @@ -164,7 +168,7 @@ glBitmap by Steffen Xonna aka Lossy eX (2003-2008) function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean; -function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; +function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData;

Types

@@ -354,7 +358,7 @@ glBitmap by Steffen Xonna aka Lossy eX (2003-2008) -function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; +function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData; @@ -500,10 +504,14 @@ tfS3tcDtx5RGBA:

-Portable Network Graphic file (PNG)

+type to define suitable file formats

Values

+ftPNG: Portable Network Graphic file (PNG)
+ftJPEG: JPEG file
ftDDS: Direct Draw Surface file (DDS)
ftTGA: Targa Image File (TGA)

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/index.html b/doc/index.html index d165995..063a13d 100644 --- a/doc/index.html +++ b/doc/index.html @@ -26,6 +26,6 @@

The glBitmap is a Delphi/FPC unit that contains several wrapper classes to manage OpenGL texture objects. Below you can find a list of the main functionality of this classes: - load texture data from file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - load texture data from several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - save texture data to file (e.g. BMP, TGA, DDS, PNG, JPEG, ...) - save texture data to several other image objects (e.g. TBitmap, TLazIntfImage, SDL Surface) - support for many texture formats (e.g. RGB8, BGR8, RGBA8, BGRA8, ...) - manage texture properties (e.g. Filter, Clamp, Mipmap, ...) - upload texture data to video card - download texture data from video card - manipulate texture data (e.g. add alpha, remove alpha, convert to other format, switch RGB, ...)

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/doc/legend.html b/doc/legend.html index e2df3a3..e908f2e 100644 --- a/doc/legend.html +++ b/doc/legend.html @@ -48,6 +48,6 @@ Implicit -

Generated by PasDoc 0.13.0 on 2014-12-21 15:05:48 +

Generated by PasDoc 0.13.0 on 2014-12-24 04:27:09 diff --git a/examples/GrabScreen/GrabScreen.lpi b/examples/GrabScreen/GrabScreen.lpi index de9d899..12f6c24 100644 --- a/examples/GrabScreen/GrabScreen.lpi +++ b/examples/GrabScreen/GrabScreen.lpi @@ -35,12 +35,10 @@ - - @@ -61,7 +59,7 @@ - + diff --git a/examples/GrabScreen/GrabScreen.lpr b/examples/GrabScreen/GrabScreen.lpr index c3b7b77..97acff5 100644 --- a/examples/GrabScreen/GrabScreen.lpr +++ b/examples/GrabScreen/GrabScreen.lpr @@ -14,7 +14,7 @@ var function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; var - tex: TglBitmap2D; + data: TglBitmapData; begin case Msg of WM_DESTROY: begin @@ -23,13 +23,15 @@ begin WM_KEYDOWN: begin if wParam = VK_RETURN then begin - tex := TglBitmap2D.Create; // create empty texture + data := TglBitmapData.Create; // create texture data object try - tex.GrabScreen(0, 0, 800, 600, tfRGB8ub3); // copy current framebuffer content to texture - tex.SaveToFile(ExtractFilePath(ApplicationName) + 'screen.bmp', ftBMP); // save texture to file + TglBitmap2D.GrabScreen(0, 0, 800, 600, tfRGBA8ui1, data); // read pixels from frame buffer + data.SaveToFile( // save data to file + ExtractFilePath(ApplicationName) + + 'screen.bmp', ftBMP); WriteLn('screen saved to screen.bmp'); finally - FreeAndNil(tex); + FreeAndNil(data); // free texture data object when done end; end; end; diff --git a/examples/GrabScreen/GrabScreen.lps b/examples/GrabScreen/GrabScreen.lps index dd7a9c5..92e04b8 100644 --- a/examples/GrabScreen/GrabScreen.lps +++ b/examples/GrabScreen/GrabScreen.lps @@ -8,19 +8,17 @@ - - - - + + + - - + @@ -29,7 +27,7 @@ - + @@ -37,41 +35,132 @@ - - - + + + - + - - + + - - + + - - + + - - + + - - + + - - + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi index cc27760..50332a3 100644 --- a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi +++ b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpi @@ -39,7 +39,6 @@ - @@ -49,7 +48,6 @@ - @@ -60,7 +58,7 @@ - + diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr index cb7cc15..bdb9c69 100644 --- a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr +++ b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lpr @@ -12,6 +12,7 @@ var oglWindow: TOpenGLWindow; running: Boolean = true; tex: TglBitmap2D; + data: TglBitmapData; function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; begin @@ -39,10 +40,16 @@ end; begin oglWindow := CreateOpenGLWindow('SimpleLoadFromFile', 800, 600, @WindowProc); try - // load texture - tex := TglBitmap2D.Create; - tex.LoadFromFile(ExtractFilePath(ApplicationName) + '../textures/BMP_24_RGB8.bmp'); - tex.GenTexture; + tex := TglBitmap2D.Create; // create texture object + data := TglBitmapData.Create; // create texture data object + try + data.LoadFromFile( // load texture data from file + ExtractFilePath(ApplicationName) + + '../textures/BMP_24_RGB8.bmp'); + tex.UploadData(data); // upload data to video card + finally + FreeAndNil(data); // after upload is done, the data object could be freed to save memory + end; while running and ProgressMesages do begin RenderLoop; diff --git a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps index 84a19dc..41e7f95 100644 --- a/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps +++ b/examples/SimpleLoadFromFile/SimpleLoadFromFile.lps @@ -4,12 +4,13 @@ - + - + + @@ -21,14 +22,113 @@ + + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/TextureFromFunction/TextureFromFunction.lpi b/examples/TextureFromFunction/TextureFromFunction.lpi index 3852d10..897ab96 100644 --- a/examples/TextureFromFunction/TextureFromFunction.lpi +++ b/examples/TextureFromFunction/TextureFromFunction.lpi @@ -35,7 +35,6 @@ - @@ -61,7 +60,7 @@ - + diff --git a/examples/TextureFromFunction/TextureFromFunction.lpr b/examples/TextureFromFunction/TextureFromFunction.lpr index f960c25..7c60833 100644 --- a/examples/TextureFromFunction/TextureFromFunction.lpr +++ b/examples/TextureFromFunction/TextureFromFunction.lpr @@ -11,6 +11,7 @@ uses var oglWindow: TOpenGLWindow; running: Boolean = true; + data: TglBitmapData; tex: TglBitmap2D; function WindowProc(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; @@ -74,14 +75,19 @@ end; begin oglWindow := CreateOpenGLWindow('TextureFromFunction', 800, 600, @WindowProc); try - // create texture use either GenerateTextureFunc1 or GenerateTextureFunc2 - tex := TglBitmap2D.Create( - glBitmapSize(512, 512), - tfRGBA8ub4, - @GenerateTextureFunc1 - //@GenerateTextureFunc2 - ); - tex.GenTexture; + tex := TglBitmap2D.Create; // create texture object + data := TglBitmapData.Create; // create texture data object + try + data.LoadFromFunc( // generate texture data using either GenerateTextureFunc1 or GenerateTextureFunc2 + glBitmapSize(512, 512), + tfRGBA8ub4, + @GenerateTextureFunc1 + //@GenerateTextureFunc2 + ); + tex.UploadData(data); // upload data to video card + finally + FreeAndNil(data); // after upload is done, the data object could be freed to save memory + end; while running and ProgressMesages do begin RenderLoop; diff --git a/examples/TextureFromFunction/TextureFromFunction.lps b/examples/TextureFromFunction/TextureFromFunction.lps index e3c3fb0..aa8b9d4 100644 --- a/examples/TextureFromFunction/TextureFromFunction.lps +++ b/examples/TextureFromFunction/TextureFromFunction.lps @@ -8,10 +8,9 @@ - - - + + @@ -36,21 +35,20 @@ - - + + - - + @@ -66,21 +64,53 @@ - - + + - + - - + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/glBitmapConf.inc b/examples/glBitmapConf.inc new file mode 100644 index 0000000..6a9c66c --- /dev/null +++ b/examples/glBitmapConf.inc @@ -0,0 +1,61 @@ +{ this is the default configuration file of the glBitmap.pas + please uncomment you preferences below, rename this file to glBitmapConf.inc + and make it available to your compilers include paths } + + +// enable support for OpenGL ES 1.1 +{.$DEFINE OPENGL_ES_1_1} + +// enable support for OpenGL ES 2.0 +{.$DEFINE OPENGL_ES_2_0} + +// enable support for OpenGL ES 3.0 +{.$DEFINE OPENGL_ES_3_0} + +// enable support for all OpenGL ES extensions +{.$DEFINE OPENGL_ES_EXT} + + + +// activate to enable the support for SDL_surfaces +{.$DEFINE GLB_SDL} + +// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap) +{.$DEFINE GLB_DELPHI} + +// activate to enable the support for TLazIntfImage from Lazarus +{.$DEFINE GLB_LAZARUS} + + + +// activate to enable the support of SDL_image to load files. (READ ONLY) +// If you enable SDL_image all other libraries will be ignored! +{.$DEFINE GLB_SDL_IMAGE} + + + +// activate to enable Lazarus TPortableNetworkGraphic support +// if you enable this pngImage and libPNG will be ignored +{.$DEFINE GLB_LAZ_PNG} + +// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/ +// if you enable pngimage the libPNG will be ignored +{.$DEFINE GLB_PNGIMAGE} + +// activate to use the libPNG -> http://www.libpng.org/ +// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng +{.$DEFINE GLB_LIB_PNG} + + + +// activate to enable Lazarus TJPEGImage support +// if you enable this delphi jpegs and libJPEG will be ignored +{.$DEFINE GLB_LAZ_JPEG} + +// if you enable delphi jpegs the libJPEG will be ignored +{.$DEFINE GLB_DELPHI_JPEG} + +// activate to use the libJPEG -> http://www.ijg.org/ +// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg +{.$DEFINE GLB_LIB_JPEG} + \ No newline at end of file diff --git a/glBitmap.pas b/glBitmap.pas index 0285b0f..1e804e0 100644 --- a/glBitmap.pas +++ b/glBitmap.pas @@ -179,6 +179,8 @@ unit glBitmap; {$OPTIMIZATION ON} {$ENDIF} +{$UNDEF GLB_LAZARUS} + interface uses @@ -346,6 +348,22 @@ type 1: (arr: array[0..3] of QWord); end; + { structure to store pixel data in } + TglBitmapPixelData = packed record + Data: TglBitmapRec4ui; //< color data for each color channel + Range: TglBitmapRec4ui; //< maximal color value for each channel + Format: TglBitmapFormat; //< format of the pixel + end; + PglBitmapPixelData = ^TglBitmapPixelData; + + TglBitmapSizeFields = set of (ffX, ffY); + TglBitmapSize = packed record + Fields: TglBitmapSizeFields; + X: Word; + Y: Word; + end; + TglBitmapPixelPosition = TglBitmapSize; + { describes the properties of a given texture data format } TglBitmapFormatDescriptor = class(TObject) private @@ -424,6 +442,9 @@ type property HasColor: Boolean read GetHasColor; //< @true if the format has any color color channel, @false otherwise property IsGrayscale: Boolean read GetIsGrayscale; //< @true if the format is a grayscale format, @false otherwise + function GetSize(const aSize: TglBitmapSize): Integer; overload; virtual; + function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; + { constructor } constructor Create; public @@ -434,28 +455,11 @@ type end; //////////////////////////////////////////////////////////////////////////////////////////////////// - { structure to store pixel data in } - TglBitmapPixelData = packed record - Data: TglBitmapRec4ui; //< color data for each color channel - Range: TglBitmapRec4ui; //< maximal color value for each channel - Format: TglBitmapFormat; //< format of the pixel - end; - PglBitmapPixelData = ^TglBitmapPixelData; - - TglBitmapSizeFields = set of (ffX, ffY); - TglBitmapSize = packed record - Fields: TglBitmapSizeFields; - X: Word; - Y: Word; - end; - TglBitmapPixelPosition = TglBitmapSize; - -//////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmap = class; + TglBitmapData = class; { structure to store data for converting in } TglBitmapFunctionRec = record - Sender: TglBitmap; //< texture object that stores the data to convert + Sender: TglBitmapData; //< texture object that stores the data to convert Size: TglBitmapSize; //< size of the texture Position: TglBitmapPixelPosition; //< position of the currently pixel Source: TglBitmapPixelData; //< pixel data of the current pixel @@ -467,119 +471,124 @@ type TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - { base class for all glBitmap classes. used to manage OpenGL texture objects - and to load, save and manipulate texture data } - TglBitmap = class - private - { @returns format descriptor that describes the format of the stored data } - function GetFormatDesc: TglBitmapFormatDescriptor; - protected - fID: GLuint; //< name of the OpenGL texture object - fTarget: GLuint; //< texture target (e.g. GL_TEXTURE_2D) - fAnisotropic: Integer; //< anisotropic level - fDeleteTextureOnFree: Boolean; //< delete OpenGL texture object when this object is destroyed - fFreeDataOnDestroy: Boolean; //< free stored data when this object is destroyed - fFreeDataAfterGenTexture: Boolean; //< free stored data after data was uploaded to video card - fData: PByte; //< data of this texture -{$IFNDEF OPENGL_ES} - fIsResident: GLboolean; //< @true if OpenGL texture object has data, @false otherwise -{$ENDIF} - fBorderColor: array[0..3] of Single; //< color of the texture border + { class to store texture data in. used to load, save and + manipulate data before assigned to texture object + all operations on a data object can be done from a background thread } + TglBitmapData = class + private { fields } - fDimension: TglBitmapSize; //< size of this texture - fMipMap: TglBitmapMipMap; //< mipmap type - fFormat: TglBitmapFormat; //< format the texture data is stored in + fData: PByte; //< texture data + fDimension: TglBitmapSize; //< pixel size of the data + fFormat: TglBitmapFormat; //< format the texture data is stored in + fFilename: String; //< file the data was load from - // Mapping - fPixelSize: Integer; //< size of one pixel (in byte) - fRowSize: Integer; //< size of one pixel row (in byte) + fScanlines: array of PByte; //< pointer to begin of each line + fHasScanlines: Boolean; //< @true if scanlines are initialized, @false otherwise - // Filtering - fFilterMin: GLenum; //< min filter to apply to the texture - fFilterMag: GLenum; //< mag filter to apply to the texture + private { getter / setter } - // TexturWarp - fWrapS: GLenum; //< texture wrapping for x axis - fWrapT: GLenum; //< texture wrapping for y axis - fWrapR: GLenum; //< texture wrapping for z axis + { @returns the format descriptor suitable to the texture data format } + function GetFormatDescriptor: TglBitmapFormatDescriptor; -{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} - //Swizzle - fSwizzle: array[0..3] of GLenum; //< color channel swizzle -{$IFEND} + { @returns the width of the texture data (in pixel) or -1 if no data is set } + function GetWidth: Integer; - // CustomData - fFilename: String; //< filename the texture was load from - fCustomName: String; //< user defined name - fCustomNameW: WideString; //< user defined name - fCustomData: Pointer; //< user defined data + { @returns the height of the texture data (in pixel) or -1 if no data is set } + function GetHeight: Integer; - protected - { @returns the actual width of the texture } - function GetWidth: Integer; virtual; + { get scanline at index aIndex + @returns Pointer to start of line or @nil } + function GetScanlines(const aIndex: Integer): PByte; - { @returns the actual height of the texture } - function GetHeight: Integer; virtual; + { set new value for the data format. only possible if new format has the same pixel size. + if you want to convert the texture data, see ConvertTo function } + procedure SetFormat(const aValue: TglBitmapFormat); - { @returns the width of the texture or 1 if the width is zero } - function GetFileWidth: Integer; virtual; + private { internal misc } - { @returns the height of the texture or 1 if the height is zero } - function GetFileHeight: Integer; virtual; + { splits a resource identifier into the resource and it's type + @param aResource resource identifier to split and store name in + @param aResType type of the resource } + procedure PrepareResType(var aResource: String; var aResType: PChar); - protected - { set a new value for fCustomData } - procedure SetCustomData(const aValue: Pointer); + { updates scanlines array } + procedure UpdateScanlines; - { set a new value for fCustomName } - procedure SetCustomName(const aValue: String); + private { internal load and save } +{$IFDEF GLB_SUPPORT_PNG_READ} + { try to load a PNG from a stream + @param aStream stream to load PNG from + @returns @true on success, @false otherwise } + function LoadPNG(const aStream: TStream): Boolean; virtual; +{$ENDIF} - { set a new value for fCustomNameW } - procedure SetCustomNameW(const aValue: WideString); +{$ifdef GLB_SUPPORT_PNG_WRITE} + { save texture data as PNG to stream + @param aStream stream to save data to} + procedure SavePNG(const aStream: TStream); virtual; +{$ENDIF} - { set new value for fFreeDataOnDestroy } - procedure SetFreeDataOnDestroy(const aValue: Boolean); +{$IFDEF GLB_SUPPORT_JPEG_READ} + { try to load a JPEG from a stream + @param aStream stream to load JPEG from + @returns @true on success, @false otherwise } + function LoadJPEG(const aStream: TStream): Boolean; virtual; +{$ENDIF} - { set new value for fDeleteTextureOnFree } - procedure SetDeleteTextureOnFree(const aValue: Boolean); +{$IFDEF GLB_SUPPORT_JPEG_WRITE} + { save texture data as JPEG to stream + @param aStream stream to save data to} + procedure SaveJPEG(const aStream: TStream); virtual; +{$ENDIF} - { set new value for the data format. only possible if new format has the same pixel size. - if you want to convert the texture data, see ConvertTo function } - procedure SetFormat(const aValue: TglBitmapFormat); + { try to load a RAW image from a stream + @param aStream stream to load RAW image from + @returns @true on success, @false otherwise } + function LoadRAW(const aStream: TStream): Boolean; - { set new value for fFreeDataAfterGenTexture } - procedure SetFreeDataAfterGenTexture(const aValue: Boolean); + { save texture data as RAW image to stream + @param aStream stream to save data to} + procedure SaveRAW(const aStream: TStream); - { set name of OpenGL texture object } - procedure SetID(const aValue: Cardinal); + { try to load a BMP from a stream + @param aStream stream to load BMP from + @returns @true on success, @false otherwise } + function LoadBMP(const aStream: TStream): Boolean; - { set new value for fMipMap } - procedure SetMipMap(const aValue: TglBitmapMipMap); + { save texture data as BMP to stream + @param aStream stream to save data to} + procedure SaveBMP(const aStream: TStream); - { set new value for target } - procedure SetTarget(const aValue: Cardinal); + { try to load a TGA from a stream + @param aStream stream to load TGA from + @returns @true on success, @false otherwise } + function LoadTGA(const aStream: TStream): Boolean; - { set new value for fAnisotrophic } - procedure SetAnisotropic(const aValue: Integer); + { save texture data as TGA to stream + @param aStream stream to save data to} + procedure SaveTGA(const aStream: TStream); - protected - { create OpenGL texture object (delete exisiting object if exists) } - procedure CreateID; + { try to load a DDS from a stream + @param aStream stream to load DDS from + @returns @true on success, @false otherwise } + function LoadDDS(const aStream: TStream): Boolean; - { setup texture parameters } - procedure SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF}); + { save texture data as DDS to stream + @param aStream stream to save data to} + procedure SaveDDS(const aStream: TStream); - { set data pointer of texture data - @param aData pointer to new texture data (be carefull, aData could be freed by this function) - @param aFormat format of the data stored at aData - @param aWidth width of the texture data - @param aHeight height of the texture data } - procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; + public { properties } + property Data: PByte read fData; //< texture data (be carefull with this!) + property Dimension: TglBitmapSize read fDimension; //< size of the texture data (in pixel) + property Filename: String read fFilename; //< file the data was loaded from + property Width: Integer read GetWidth; //< width of the texture data (in pixel) + property Height: Integer read GetHeight; //< height of the texture data (in pixel) + property Format: TglBitmapFormat read fFormat write SetFormat; //< format the texture data is stored in + property Scanlines[const aIndex: Integer]: PByte read GetScanlines; //< pointer to begin of line at given index or @nil - { generate texture (upload texture data to video card) - @param aTestTextureSize test texture size before uploading and raise exception if something is wrong } - procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract; + property FormatDescriptor: TglBitmapFormatDescriptor read GetFormatDescriptor; //< descriptor object that describes the format of the stored data + + public { flip } { flip texture horizontal @returns @true in success, @false otherwise } @@ -589,48 +598,8 @@ type @returns @true in success, @false otherwise } function FlipVert: Boolean; virtual; - protected - property Width: Integer read GetWidth; //< the actual width of the texture - property Height: Integer read GetHeight; //< the actual height of the texture - - property FileWidth: Integer read GetFileWidth; //< the width of the texture or 1 if the width is zero - property FileHeight: Integer read GetFileHeight; //< the height of the texture or 1 if the height is zero - public - property ID: Cardinal read fID write SetID; //< name of the OpenGL texture object - property Target: Cardinal read fTarget write SetTarget; //< texture target (e.g. GL_TEXTURE_2D) - property Format: TglBitmapFormat read fFormat write SetFormat; //< format the texture data is stored in - property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; //< mipmap type - property Anisotropic: Integer read fAnisotropic write SetAnisotropic; //< anisotropic level - - property FormatDesc: TglBitmapFormatDescriptor read GetFormatDesc; //< format descriptor that describes the format of the stored data - - property Filename: String read fFilename; //< filename the texture was load from - property CustomName: String read fCustomName write SetCustomName; //< user defined name (use at will) - property CustomNameW: WideString read fCustomNameW write SetCustomNameW; //< user defined name (as WideString; use at will) - property CustomData: Pointer read fCustomData write SetCustomData; //< user defined data (use at will) - - property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; //< delete texture object when this object is destroyed - property FreeDataOnDestroy: Boolean read fFreeDataOnDestroy write SetFreeDataOnDestroy; //< free stored data when this object is destroyed - property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture; //< free stored data after it is uplaoded to video card - - property Dimension: TglBitmapSize read fDimension; //< size of the texture - property Data: PByte read fData; //< texture data (or @nil if unset) -{$IFNDEF OPENGL_ES} - property IsResident: GLboolean read fIsResident; //< @true if OpenGL texture object has data, @false otherwise -{$ENDIF} - - { this method is called after the constructor and sets the default values of this object } - procedure AfterConstruction; override; - - { this method is called before the destructor and does some cleanup } - procedure BeforeDestruction; override; - - { splits a resource identifier into the resource and it's type - @param aResource resource identifier to split and store name in - @param aResType type of the resource } - procedure PrepareResType(var aResource: String; var aResType: PChar); + public { load } - public { load a texture from a file @param aFilename file to load texuture from } procedure LoadFromFile(const aFilename: String); @@ -641,11 +610,10 @@ type { use a function to generate texture data @param aSize size of the texture - @param aFunc callback to use for generation @param aFormat format of the texture data + @param aFunc callback to use for generation @param aArgs user defined paramaters (use at will) } - procedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; - const aFormat: TglBitmapFormat; const aArgs: Pointer = nil); + procedure LoadFromFunc(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); { load a texture from a resource @param aInstance resource handle @@ -659,7 +627,8 @@ type @param aResType resource type } procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); - public + public { save } + { save texture data to a file @param aFilename filename to store texture in @param aFileType file type to store data into } @@ -670,7 +639,8 @@ type @param aFileType file type to store data into } procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual; - public + public { convert } + { convert texture data using a user defined callback @param aFunc callback to use for converting @param aCreateTemp create a temporary buffer to use for converting @@ -685,7 +655,7 @@ type @param aFormat format of the new data @param aArgs user defined paramters (use at will) @returns @true if converting was successful, @false otherwise } - function Convert(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; + function Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload; { convert texture data using a specific format @@ -694,7 +664,8 @@ type function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual; {$IFDEF GLB_SDL} - public + public { SDL } + { assign texture data to SDL surface @param aSurface SDL surface to write data to @returns @true on success, @false otherwise } @@ -719,7 +690,8 @@ type {$ENDIF} {$IFDEF GLB_DELPHI} - public + public { Delphi } + { assign texture data to TBitmap object @param aBitmap TBitmap to write data to @returns @true on success, @false otherwise } @@ -744,7 +716,8 @@ type {$ENDIF} {$IFDEF GLB_LAZARUS} - public + public { Lazarus } + { assign texture data to TLazIntfImage object @param aImage TLazIntfImage to write data to @returns @true on success, @false otherwise } @@ -768,7 +741,7 @@ type function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; {$ENDIF} - public + public { Alpha } { load alpha channel data from resource @param aInstance resource handle @param aResource resource ID @@ -796,7 +769,7 @@ type { add alpha channel data from file (macro for: new glBitmap, LoadFromFile, AddAlphaFromGlBitmap) @param aFilename file to load alpha channel data from @param aFunc callback to use for converting - @param aArgs user defined parameters (use at will) + @param aArgs SetFormat user defined parameters (use at will) @returns @true on success, @false otherwise } function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; @@ -812,7 +785,7 @@ type @param aFunc callback to use for converting @param aArgs user defined parameters (use at will) @returns @true on success, @false otherwise } - function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; + function AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; { add alpha to pixel if the pixels color is greter than the given color value @param aRed red threshold (0-255) @@ -857,29 +830,7 @@ type @returns @true on success, @false otherwise } function RemoveAlpha: Boolean; virtual; - public - { create a clone of the current object - @returns clone of this object} - function Clone: TglBitmap; - - { invert color data (xor) - @param aUseRGB xor each color channel - @param aUseAlpha xor alpha channel } - procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false); - - { free texture stored data } - procedure FreeData; - -{$IFNDEF OPENGL_ES} - { set the new value for texture border color - @param aRed red color for border (0.0-1.0) - @param aGreen green color for border (0.0-1.0) - @param aBlue blue color for border (0.0-1.0) - @param aAlpha alpha color for border (0.0-1.0) } - procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); -{$ENDIF} - - public + public { fill } { fill complete texture with one color @param aRed red color for border (0-255) @param aGreen green color for border (0-255) @@ -901,257 +852,326 @@ type @param aAlpha alpha color for border (0.0-1.0) } procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0); - public - { set new texture filer - @param aMin min filter - @param aMag mag filter } - procedure SetFilter(const aMin, aMag: GLenum); + public { Misc } - { set new texture wrapping - @param S texture wrapping for x axis - @param T texture wrapping for y axis - @param R texture wrapping for z axis } - procedure SetWrap( - const S: GLenum = GL_CLAMP_TO_EDGE; - const T: GLenum = GL_CLAMP_TO_EDGE; - const R: GLenum = GL_CLAMP_TO_EDGE); + { set data pointer of texture data + @param aData pointer to new texture data + @param aFormat format of the data stored at aData + @param aWidth width of the texture data + @param aHeight height of the texture data } + procedure SetData(const aData: PByte; const aFormat: TglBitmapFormat; + const aWidth: Integer = -1; const aHeight: Integer = -1); virtual; -{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} - { set new swizzle - @param r swizzle for red channel - @param g swizzle for green channel - @param b swizzle for blue channel - @param a swizzle for alpha channel } - procedure SetSwizzle(const r, g, b, a: GLenum); -{$IFEND} + { create a clone of the current object + @returns clone of this object} + function Clone: TglBitmapData; - public - { bind texture - @param aEnableTextureUnit enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) } - procedure Bind(const aEnableTextureUnit: Boolean = true); virtual; + { invert color data (bitwise not) + @param aRed invert red channel + @param aGreen invert green channel + @param aBlue invert blue channel + @param aAlpha invert alpha channel } + procedure Invert(const aRed, aGreen, aBlue, aAlpha: Boolean); - { bind texture - @param aDisableTextureUnit disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) } - procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual; + { create normal map from texture data + @param aFunc normal map function to generate normalmap with + @param aScale scale of the normale stored in the normal map + @param aUseAlpha generate normalmap from alpha channel data (if present) } + procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; + const aScale: Single = 2; const aUseAlpha: Boolean = false); - public - { constructor - created an empty texture } + public { constructor } + + { constructor - creates a texutre data object } constructor Create; overload; - { constructor - creates a texture and load it from a file + { constructor - creates a texture data object and loads it from a file @param aFilename file to load texture from } constructor Create(const aFileName: String); overload; - { constructor - creates a texture and load it from a stream + { constructor - creates a texture data object and loads it from a stream @param aStream stream to load texture from } constructor Create(const aStream: TStream); overload; - { constructor - creates a texture with the given size, format and data + { constructor - creates a texture data object with the given size, format and data @param aSize size of the texture @param aFormat format of the given data - @param aData texture data - be carefull: the data will now be managed by the glBitmap object, - you can control this by setting DeleteTextureOnFree, FreeDataOnDestroy and FreeDataAfterGenTexture } + @param aData texture data - be carefull: the data will now be managed by the texture data object } constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload; - { constructor - creates a texture with the given size and format and uses the given callback to create the data + { constructor - creates a texture data object with the given size and format and uses the given callback to create the data @param aSize size of the texture @param aFormat format of the given data @param aFunc callback to use for generating the data @param aArgs user defined parameters (use at will) } constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload; - { constructor - creates a texture and loads it from a resource + { constructor - creates a texture data object and loads it from a resource @param aInstance resource handle @param aResource resource indentifier @param aResType resource type (if known) } constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload; - { constructor - creates a texture and loads it from a resource + { constructor - creates a texture data object and loads it from a resource @param aInstance resource handle @param aResourceID resource ID @param aResType resource type (if known) } constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload; - private -{$IFDEF GLB_SUPPORT_PNG_READ} - { try to load a PNG from a stream - @param aStream stream to load PNG from - @returns @true on success, @false otherwise } - function LoadPNG(const aStream: TStream): Boolean; virtual; -{$ENDIF} + { destructor } + destructor Destroy; override; -{$ifdef GLB_SUPPORT_PNG_WRITE} - { save texture data as PNG to stream - @param aStream stream to save data to} - procedure SavePNG(const aStream: TStream); virtual; + end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + { base class for all glBitmap classes. used to manage OpenGL texture objects + all operations on a bitmap object must be done from the render thread } + TglBitmap = class + protected + fID: GLuint; //< name of the OpenGL texture object + fTarget: GLuint; //< texture target (e.g. GL_TEXTURE_2D) + fDeleteTextureOnFree: Boolean; //< delete OpenGL texture object when this object is destroyed + + // texture properties + fFilterMin: GLenum; //< min filter to apply to the texture + fFilterMag: GLenum; //< mag filter to apply to the texture + fWrapS: GLenum; //< texture wrapping for x axis + fWrapT: GLenum; //< texture wrapping for y axis + fWrapR: GLenum; //< texture wrapping for z axis + fAnisotropic: Integer; //< anisotropic level + fBorderColor: array[0..3] of Single; //< color of the texture border + +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + //Swizzle + fSwizzle: array[0..3] of GLenum; //< color channel swizzle +{$IFEND} +{$IFNDEF OPENGL_ES} + fIsResident: GLboolean; //< @true if OpenGL texture object has data, @false otherwise {$ENDIF} -{$IFDEF GLB_SUPPORT_JPEG_READ} - { try to load a JPEG from a stream - @param aStream stream to load JPEG from - @returns @true on success, @false otherwise } - function LoadJPEG(const aStream: TStream): Boolean; virtual; + fDimension: TglBitmapSize; //< size of this texture + fMipMap: TglBitmapMipMap; //< mipmap type + + // CustomData + fCustomData: Pointer; //< user defined data + fCustomName: String; //< user defined name + fCustomNameW: WideString; //< user defined name + protected + { @returns the actual width of the texture } + function GetWidth: Integer; virtual; + + { @returns the actual height of the texture } + function GetHeight: Integer; virtual; + + protected + { set a new value for fCustomData } + procedure SetCustomData(const aValue: Pointer); + + { set a new value for fCustomName } + procedure SetCustomName(const aValue: String); + + { set a new value for fCustomNameW } + procedure SetCustomNameW(const aValue: WideString); + + { set new value for fDeleteTextureOnFree } + procedure SetDeleteTextureOnFree(const aValue: Boolean); + + { set name of OpenGL texture object } + procedure SetID(const aValue: Cardinal); + + { set new value for fMipMap } + procedure SetMipMap(const aValue: TglBitmapMipMap); + + { set new value for target } + procedure SetTarget(const aValue: Cardinal); + + { set new value for fAnisotrophic } + procedure SetAnisotropic(const aValue: Integer); + + protected + { create OpenGL texture object (delete exisiting object if exists) } + procedure CreateID; + + { setup texture parameters } + procedure SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF}); + + protected + property Width: Integer read GetWidth; //< the actual width of the texture + property Height: Integer read GetHeight; //< the actual height of the texture + + public + property ID: Cardinal read fID write SetID; //< name of the OpenGL texture object + property Target: Cardinal read fTarget write SetTarget; //< texture target (e.g. GL_TEXTURE_2D) + property DeleteTextureOnFree: Boolean read fDeleteTextureOnFree write SetDeleteTextureOnFree; //< delete texture object when this object is destroyed + + property MipMap: TglBitmapMipMap read fMipMap write SetMipMap; //< mipmap type + property Anisotropic: Integer read fAnisotropic write SetAnisotropic; //< anisotropic level + + property CustomData: Pointer read fCustomData write SetCustomData; //< user defined data (use at will) + property CustomName: String read fCustomName write SetCustomName; //< user defined name (use at will) + property CustomNameW: WideString read fCustomNameW write SetCustomNameW; //< user defined name (as WideString; use at will) + + property Dimension: TglBitmapSize read fDimension; //< size of the texture +{$IFNDEF OPENGL_ES} + property IsResident: GLboolean read fIsResident; //< @true if OpenGL texture object has data, @false otherwise {$ENDIF} -{$IFDEF GLB_SUPPORT_JPEG_WRITE} - { save texture data as JPEG to stream - @param aStream stream to save data to} - procedure SaveJPEG(const aStream: TStream); virtual; + { this method is called after the constructor and sets the default values of this object } + procedure AfterConstruction; override; + + { this method is called before the destructor and does some cleanup } + procedure BeforeDestruction; override; + + public +{$IFNDEF OPENGL_ES} + { set the new value for texture border color + @param aRed red color for border (0.0-1.0) + @param aGreen green color for border (0.0-1.0) + @param aBlue blue color for border (0.0-1.0) + @param aAlpha alpha color for border (0.0-1.0) } + procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); {$ENDIF} - { try to load a RAW image from a stream - @param aStream stream to load RAW image from - @returns @true on success, @false otherwise } - function LoadRAW(const aStream: TStream): Boolean; + public + { set new texture filer + @param aMin min filter + @param aMag mag filter } + procedure SetFilter(const aMin, aMag: GLenum); - { save texture data as RAW image to stream - @param aStream stream to save data to} - procedure SaveRAW(const aStream: TStream); + { set new texture wrapping + @param S texture wrapping for x axis + @param T texture wrapping for y axis + @param R texture wrapping for z axis } + procedure SetWrap( + const S: GLenum = GL_CLAMP_TO_EDGE; + const T: GLenum = GL_CLAMP_TO_EDGE; + const R: GLenum = GL_CLAMP_TO_EDGE); - { try to load a BMP from a stream - @param aStream stream to load BMP from - @returns @true on success, @false otherwise } - function LoadBMP(const aStream: TStream): Boolean; +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + { set new swizzle + @param r swizzle for red channel + @param g swizzle for green channel + @param b swizzle for blue channel + @param a swizzle for alpha channel } + procedure SetSwizzle(const r, g, b, a: GLenum); +{$IFEND} - { save texture data as BMP to stream - @param aStream stream to save data to} - procedure SaveBMP(const aStream: TStream); + public + { bind texture + @param aEnableTextureUnit enable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) } + procedure Bind(const aEnableTextureUnit: Boolean = true); virtual; - { try to load a TGA from a stream - @param aStream stream to load TGA from - @returns @true on success, @false otherwise } - function LoadTGA(const aStream: TStream): Boolean; + { bind texture + @param aDisableTextureUnit disable texture unit for this texture (e.g. glEnable(GL_TEXTURE_2D)) } + procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual; - { save texture data as TGA to stream - @param aStream stream to save data to} - procedure SaveTGA(const aStream: TStream); + { upload texture data from given data object to video card + @param aData texture data object that contains the actual data + @param aCheckSize check size before upload and throw exception if something is wrong } + procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); virtual; - { try to load a DDS from a stream - @param aStream stream to load DDS from - @returns @true on success, @false otherwise } - function LoadDDS(const aStream: TStream): Boolean; +{$IFNDEF OPENGL_ES} + { download texture data from video card and store it into given data object + @returns @true when download was successfull, @false otherwise } + function DownloadData(const aDataObj: TglBitmapData): Boolean; virtual; +{$ENDIF} + public + { constructor - creates an empty texture } + constructor Create; overload; + + { constructor - creates an texture object and uploads the given data } + constructor Create(const aData: TglBitmapData); overload; - { save texture data as DDS to stream - @param aStream stream to save data to} - procedure SaveDDS(const aStream: TStream); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// {$IF NOT DEFINED(OPENGL_ES)} - { wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D } + { wrapper class for 1-dimensional textures (OpenGL target = GL_TEXTURE_1D + all operations on a bitmap object must be done from the render thread } TglBitmap1D = class(TglBitmap) protected - { set data pointer of texture data - @param aData pointer to new texture data (be carefull, aData could be freed by this function) - @param aFormat format of the data stored at aData - @param aWidth width of the texture data - @param aHeight height of the texture data } - procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; { upload the texture data to video card + @param aDataObj texture data object that contains the actual data @param aBuildWithGlu use glu functions to build mipmaps } - procedure UploadData(const aBuildWithGlu: Boolean); + procedure UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean); + public property Width; //< actual with of the texture { this method is called after constructor and initializes the object } procedure AfterConstruction; override; - { flip texture horizontally - @returns @true on success, @fals otherwise } - function FlipHorz: Boolean; override; + { upload texture data from given data object to video card + @param aData texture data object that contains the actual data + @param aCheckSize check size before upload and throw exception if something is wrong } + procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override; - { generate texture (create texture object if not exist, set texture parameters and upload data - @param aTestTextureSize check the size of the texture and throw exception if something is wrong } - procedure GenTexture(const aTestTextureSize: Boolean = true); override; end; {$IFEND} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - { wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) } + { wrapper class for 2-dimensional textures (OpenGL target = GL_TEXTURE_2D) + all operations on a bitmap object must be done from the render thread } TglBitmap2D = class(TglBitmap) protected - fLines: array of PByte; //< array to store scanline entry points in - - { get a specific scanline - @param aIndex index of the scanline to return - @returns scanline at position aIndex or @nil } - function GetScanline(const aIndex: Integer): Pointer; - - { set data pointer of texture data - @param aData pointer to new texture data (be carefull, aData could be freed by this function) - @param aFormat format of the data stored at aData - @param aWidth width of the texture data - @param aHeight height of the texture data } - procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer = - 1; const aHeight: Integer = - 1); override; { upload the texture data to video card + @param aDataObj texture data object that contains the actual data @param aTarget target o upload data to (e.g. GL_TEXTURE_2D) @param aBuildWithGlu use glu functions to build mipmaps } - procedure UploadData(const aTarget: GLenum{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF}); + procedure UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum + {$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF}); + public - property Width; //< actual width of the texture - property Height; //< actual height of the texture - property Scanline[const aIndex: Integer]: Pointer read GetScanline; //< scanline to access texture data directly + property Width; //< actual width of the texture + property Height; //< actual height of the texture { this method is called after constructor and initializes the object } procedure AfterConstruction; override; - { copy a part of the frame buffer top the texture + { upload texture data from given data object to video card + @param aData texture data object that contains the actual data + @param aCheckSize check size before upload and throw exception if something is wrong } + procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override; + + public + + { copy a part of the frame buffer to the texture @param aTop topmost pixel to copy @param aLeft leftmost pixel to copy @param aRight rightmost pixel to copy @param aBottom bottommost pixel to copy - @param aFormat format to store data in } - procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); - -{$IFNDEF OPENGL_ES} - { downlaod texture data from OpenGL texture object } - procedure GetDataFromTexture; -{$ENDIF} - - { generate texture (create texture object if not exist, set texture parameters and upload data) - @param aTestTextureSize check the size of the texture and throw exception if something is wrong } - procedure GenTexture(const aTestTextureSize: Boolean = true); override; - - { flip texture horizontally - @returns @true on success, @false otherwise } - function FlipHorz: Boolean; override; + @param aFormat format to store data in + @param aDataObj texture data object to store the data in } + class procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData); - { flip texture vertically - @returns @true on success, @false otherwise } - function FlipVert: Boolean; override; - - { create normal map from texture data - @param aFunc normal map function to generate normalmap with - @param aScale scale of the normale stored in the normal map - @param aUseAlpha generate normalmap from alpha channel data (if present) } - procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; - const aScale: Single = 2; const aUseAlpha: Boolean = false); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} - { wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) } + { wrapper class for cube maps (OpenGL target = GL_TEXTURE_CUBE_MAP) + all operations on a bitmap object must be done from the render thread } TglBitmapCubeMap = class(TglBitmap2D) protected {$IFNDEF OPENGL_ES} fGenMode: Integer; //< generation mode for the cube map (e.g. GL_REFLECTION_MAP) {$ENDIF} - { generate texture (create texture object if not exist, set texture parameters and upload data - do not call directly for cubemaps, use GenerateCubeMap instead - @param aTestTextureSize check the size of the texture and throw exception if something is wrong } - procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce; public { this method is called after constructor and initializes the object } procedure AfterConstruction; override; - { generate texture (create texture object if not exist, set texture parameters and upload data - @param aCubeTarget cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X) - @param aTestTextureSize check the size of the texture and throw exception if something is wrong } - procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true); + { upload texture data from given data object to video card + @param aData texture data object that contains the actual data + @param aCheckSize check size before upload and throw exception if something is wrong } + procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override; + + { upload texture data from given data object to video card + @param aData texture data object that contains the actual data + @param aCubeTarget cube map target to upload data to (e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X) + @param aCheckSize check size before upload and throw exception if something is wrong } + procedure UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean); { bind texture @param aEnableTexCoordsGen enable cube map generator @@ -1167,16 +1187,17 @@ type {$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - { wrapper class for cube normal maps } + { wrapper class for cube normal maps + all operations on a bitmap object must be done from the render thread } TglBitmapNormalMap = class(TglBitmapCubeMap) public { this method is called after constructor and initializes the object } procedure AfterConstruction; override; { create cube normal map from texture data and upload it to video card - @param aSize size of each cube map texture - @param aTestTextureSize check texture size when uploading and throw exception if something is wrong } - procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true); + @param aSize size of each cube map texture + @param aCheckSize check size before upload and throw exception if something is wrong } + procedure GenerateNormalMap(const aSize: Integer = 32; const aCheckSize: Boolean = true); end; {$IFEND} @@ -1215,7 +1236,7 @@ function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul; function glBitmapRec4ubCompare(const r1, r2: TglBitmapRec4ub): Boolean; function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean; -function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; +function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData; {$IFDEF GLB_DELPHI} function CreateGrayPalette: HPALETTE; @@ -1247,9 +1268,6 @@ type procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract; - function GetSize(const aSize: TglBitmapSize): Integer; overload; virtual; - function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual; - function CreateMappingData: Pointer; virtual; procedure FreeMappingData(var aMappingData: Pointer); virtual; @@ -1645,18 +1663,17 @@ type TbmpColorTable = array of TbmpColorTableEnty; TbmpColorTableFormat = class(TFormatDescriptor) private - fBitsPerPixel: Integer; fColorTable: TbmpColorTable; protected procedure SetValues; override; public property ColorTable: TbmpColorTable read fColorTable write fColorTable; - property BitsPerPixel: Integer read fBitsPerPixel write fBitsPerPixel; procedure SetCustomValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload; procedure CalcValues; procedure CreateColorTable; + function CreateMappingData: Pointer; override; procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; destructor Destroy; override; @@ -1834,7 +1851,7 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; +function glBitmapCreateTestData(const aFormat: TglBitmapFormat): TglBitmapData; var desc: TFormatDescriptor; p, tmp: PByte; @@ -1874,10 +1891,7 @@ begin desc.FreeMappingData(md); end; - result := TglBitmap2D.Create(glBitmapPosition(5, 5), aFormat, p); - result.FreeDataOnDestroy := true; - result.FreeDataAfterGenTexture := false; - result.SetFilter(GL_NEAREST, GL_NEAREST); + result := TglBitmapData.Create(glBitmapPosition(5, 5), aFormat, p); end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2132,33 +2146,11 @@ begin b := glDefaultSwizzle[2]; a := glDefaultSwizzle[3]; end; -{$ENDIF} +{$IFEND} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetSize(const aSize: TglBitmapSize): Integer; -var - w, h: Integer; -begin - if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin - w := Max(1, aSize.X); - h := Max(1, aSize.Y); - result := GetSize(w, h); - end else - result := 0; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer; -begin - result := 0; - if (aWidth <= 0) or (aHeight <= 0) then - exit; - result := Ceil(aWidth * aHeight * BytesPerPixel); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.CreateMappingData: Pointer; begin result := nil; @@ -3845,7 +3837,6 @@ begin result := (Mask.r = Mask.g) and (Mask.g = Mask.b) and (Mask.r > 0); end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmapFormatDescriptor.SetValues; begin fFormat := tfEmpty; @@ -3880,6 +3871,26 @@ begin end; end; +function TglBitmapFormatDescriptor.GetSize(const aSize: TglBitmapSize): Integer; +var + w, h: Integer; +begin + if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin + w := Max(1, aSize.X); + h := Max(1, aSize.Y); + result := GetSize(w, h); + end else + result := 0; +end; + +function TglBitmapFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer; +begin + result := 0; + if (aWidth <= 0) or (aHeight <= 0) then + exit; + result := Ceil(aWidth * aHeight * BytesPerPixel); +end; + constructor TglBitmapFormatDescriptor.Create; begin inherited Create; @@ -4015,12 +4026,13 @@ var begin for i := 0 to 3 do begin fShift.arr[i] := 0; - while (aMask.arr[i] > 0) and (aMask.arr[i] and 1 > 0) do begin + while (aMask.arr[i] > 0) and ((aMask.arr[i] and 1) = 0) do begin aMask.arr[i] := aMask.arr[i] shr 1; inc(fShift.arr[i]); end; fPrecision.arr[i] := CountSetBits(aMask.arr[i]); end; + fBitsPerPixel := aBPP; CalcValues; end; @@ -4124,6 +4136,12 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TbmpColorTableFormat.CreateMappingData: Pointer; +begin + result := Pointer(0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin if (BitsPerPixel <> 8) then @@ -4134,24 +4152,46 @@ begin else // normal aData^ := Round( - ((aPixel.Data.r and Range.r) shl Shift.r) or - ((aPixel.Data.g and Range.g) shl Shift.g) or - ((aPixel.Data.b and Range.b) shl Shift.b)); + ((aPixel.Data.r shr Shift.r) and Range.r) * LUMINANCE_WEIGHT_R + + ((aPixel.Data.g shr Shift.g) and Range.g) * LUMINANCE_WEIGHT_G + + ((aPixel.Data.b shr Shift.b) and Range.b) * LUMINANCE_WEIGHT_B); inc(aData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); + + function ReadValue: Byte; + var + i: PtrUInt; + begin + if (BitsPerPixel = 8) then begin + result := aData^; + inc(aData); + end else begin + i := {%H-}PtrUInt(aMapData); + if (BitsPerPixel > 1) then + result := (aData^ shr i) and ((1 shl BitsPerPixel) - 1) + else + result := (aData^ shr (7-i)) and ((1 shl BitsPerPixel) - 1); + inc(i, BitsPerPixel); + while (i >= 8) do begin + inc(aData); + dec(i, 8); + end; + aMapData := {%H-}Pointer(i); + end; + end; + begin - if (BitsPerPixel <> 8) then + if (BitsPerPixel > 8) then raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats'); - with fColorTable[aData^] do begin + with fColorTable[ReadValue] do begin aPixel.Data.r := r; aPixel.Data.g := g; aPixel.Data.b := b; aPixel.Data.a := a; end; - inc(aData, 1); end; destructor TbmpColorTableFormat.Destroy; @@ -4225,17 +4265,14 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure glBitmapInvertFunc(var aFuncRec: TglBitmapFunctionRec); +var + i: Integer; begin with aFuncRec do begin Dest.Data := Source.Data; - if ({%H-}PtrUInt(Args) and $1 > 0) then begin - Dest.Data.r := Dest.Data.r xor Dest.Range.r; - Dest.Data.g := Dest.Data.g xor Dest.Range.g; - Dest.Data.b := Dest.Data.b xor Dest.Range.b; - end; - if ({%H-}PtrUInt(Args) and $2 > 0) then begin - Dest.Data.a := Dest.Data.a xor Dest.Range.a; - end; + for i := 0 to 3 do + if ({%H-}PtrUInt(Args) and (1 shl i) > 0) then + Dest.Data.arr[i] := Dest.Data.arr[i] xor Dest.Range.arr[i]; end; end; @@ -4320,15 +4357,15 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap - PROTECTED/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapData/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetFormatDesc: TglBitmapFormatDescriptor; +function TglBitmapData.GetFormatDescriptor: TglBitmapFormatDescriptor; begin - result := TFormatDescriptor.Get(Format); + result := TFormatDescriptor.Get(fFormat); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetWidth: Integer; +function TglBitmapData.GetWidth: Integer; begin if (ffX in fDimension.Fields) then result := fDimension.X @@ -4337,7 +4374,7 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetHeight: Integer; +function TglBitmapData.GetHeight: Integer; begin if (ffY in fDimension.Fields) then result := fDimension.Y @@ -4346,3943 +4383,4015 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetFileWidth: Integer; -begin - result := Max(1, Width); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.GetFileHeight: Integer; -begin - result := Max(1, Height); -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.SetFreeDataOnDestroy(const aValue: Boolean); -begin - if fFreeDataOnDestroy = aValue then - exit; - fFreeDataOnDestroy := aValue; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean); +function TglBitmapData.GetScanlines(const aIndex: Integer): PByte; begin - if fDeleteTextureOnFree = aValue then - exit; - fDeleteTextureOnFree := aValue; + if fHasScanlines and (aIndex >= Low(fScanlines)) and (aIndex <= High(fScanlines)) then + result := fScanlines[aIndex] + else + result := nil; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat); +procedure TglBitmapData.SetFormat(const aValue: TglBitmapFormat); begin if fFormat = aValue then exit; if TFormatDescriptor.Get(Format).BitsPerPixel <> TFormatDescriptor.Get(aValue).BitsPerPixel then raise EglBitmapUnsupportedFormat.Create(Format); - SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method + SetData(fData, aValue, Width, Height); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFreeDataAfterGenTexture(const aValue: Boolean); +procedure TglBitmapData.PrepareResType(var aResource: String; var aResType: PChar); +var + TempPos: Integer; begin - if fFreeDataAfterGenTexture = aValue then - exit; - fFreeDataAfterGenTexture := aValue; + if not Assigned(aResType) then begin + TempPos := Pos('.', aResource); + aResType := PChar(UpperCase(Copy(aResource, TempPos + 1, Length(aResource) - TempPos))); + aResource := UpperCase(Copy(aResource, 0, TempPos -1)); + end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetID(const aValue: Cardinal); -begin - if fID = aValue then - exit; - fID := aValue; +procedure TglBitmapData.UpdateScanlines; +var + w, h, i, LineWidth: Integer; +begin + w := Width; + h := Height; + fHasScanlines := Assigned(fData) and (w > 0) and (h > 0); + if fHasScanlines then begin + SetLength(fScanlines, h); + LineWidth := Trunc(w * FormatDescriptor.BytesPerPixel); + for i := 0 to h-1 do begin + fScanlines[i] := fData; + Inc(fScanlines[i], i * LineWidth); + end; + end else + SetLength(fScanlines, 0); end; +{$IFDEF GLB_SUPPORT_PNG_READ} +{$IF DEFINED(GLB_LAZ_PNG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap); +//PNG///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.LoadPNG(const aStream: TStream): Boolean; +const + MAGIC_LEN = 8; + PNG_MAGIC: String[MAGIC_LEN] = #$89#$50#$4E#$47#$0D#$0A#$1A#$0A; +var + reader: TLazReaderPNG; + intf: TLazIntfImage; + StreamPos: Int64; + magic: String[MAGIC_LEN]; begin - if fMipMap = aValue then + result := true; + StreamPos := aStream.Position; + + SetLength(magic, MAGIC_LEN); + aStream.Read(magic[1], MAGIC_LEN); + aStream.Position := StreamPos; + if (magic <> PNG_MAGIC) then begin + result := false; exit; - fMipMap := aValue; -end; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetTarget(const aValue: Cardinal); -begin - if fTarget = aValue then + intf := TLazIntfImage.Create(0, 0); + reader := TLazReaderPNG.Create; + try try + reader.UpdateDescription := true; + reader.ImageRead(aStream, intf); + AssignFromLazIntfImage(intf); + except + result := false; + aStream.Position := StreamPos; exit; - fTarget := aValue; + end; + finally + reader.Free; + intf.Free; + end; end; +{$ELSEIF DEFINED(GLB_SDL_IMAGE)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetAnisotropic(const aValue: Integer); -{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)} +function TglBitmapData.LoadPNG(const aStream: TStream): Boolean; var - MaxAnisotropic: Integer; -{$IFEND} + Surface: PSDL_Surface; + RWops: PSDL_RWops; begin - fAnisotropic := aValue; - if (ID > 0) then begin -{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)} - if GL_EXT_texture_filter_anisotropic then begin - if fAnisotropic > 0 then begin - Bind(false); - glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAnisotropic); - if aValue > MaxAnisotropic then - fAnisotropic := MaxAnisotropic; - glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, fAnisotropic); + result := false; + RWops := glBitmapCreateRWops(aStream); + try + if IMG_isPNG(RWops) > 0 then begin + Surface := IMG_LoadPNG_RW(RWops); + try + AssignFromSurface(Surface); + result := true; + finally + SDL_FreeSurface(Surface); end; - end else begin - fAnisotropic := 0; end; -{$ELSE} - fAnisotropic := 0; -{$IFEND} + finally + SDL_FreeRW(RWops); end; end; +{$ELSEIF DEFINED(GLB_LIB_PNG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.CreateID; +procedure glBitmap_libPNG_read_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl; begin - if (ID <> 0) then - glDeleteTextures(1, @fID); - glGenTextures(1, @fID); - Bind(false); + TStream(png_get_io_ptr(png)).Read(buffer^, size); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF}); -begin - // Set Up Parameters - SetWrap(fWrapS, fWrapT, fWrapR); - SetFilter(fFilterMin, fFilterMag); - SetAnisotropic(fAnisotropic); - -{$IFNDEF OPENGL_ES} - SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]); - if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then - SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); -{$ENDIF} +function TglBitmapData.LoadPNG(const aStream: TStream): Boolean; +var + StreamPos: Int64; + signature: array [0..7] of byte; + png: png_structp; + png_info: png_infop; -{$IFNDEF OPENGL_ES} - // 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 - aBuildWithGlu := true; - end else if (MipMap = mmMipmapGlu) then - aBuildWithGlu := true; -{$ELSE} - if (MipMap = mmMipmap) then - glTexParameteri(Target, GL_GENERATE_MIPMAP, GL_TRUE); -{$ENDIF} -end; + TempHeight, TempWidth: Integer; + Format: TglBitmapFormat; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer; const aHeight: Integer); -var - s: Single; + png_data: pByte; + png_rows: array of pByte; + Row, LineSize: Integer; begin - if (Data <> aData) then begin - if (Assigned(Data)) then - FreeMem(Data); - fData := aData; - end; + result := false; - if not Assigned(fData) then begin - fPixelSize := 0; - fRowSize := 0; - end else begin - FillChar(fDimension, SizeOf(fDimension), 0); - if aWidth <> -1 then begin - fDimension.Fields := fDimension.Fields + [ffX]; - fDimension.X := aWidth; - end; + if not init_libPNG then + raise Exception.Create('LoadPNG - unable to initialize libPNG.'); - if aHeight <> -1 then begin - fDimension.Fields := fDimension.Fields + [ffY]; - fDimension.Y := aHeight; - end; + try + // signature + StreamPos := aStream.Position; + aStream.Read(signature{%H-}, 8); + aStream.Position := StreamPos; - s := TFormatDescriptor.Get(aFormat).BytesPerPixel; - fFormat := aFormat; - fPixelSize := Ceil(s); - fRowSize := Ceil(s * aWidth); - end; -end; + if png_check_sig(@signature, 8) <> 0 then begin + // png read struct + png := png_create_read_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil); + if png = nil then + raise EglBitmapException.Create('LoadPng - couldn''t create read struct.'); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.FlipHorz: Boolean; -begin - result := false; -end; + // png info + png_info := png_create_info_struct(png); + if png_info = nil then begin + png_destroy_read_struct(@png, nil, nil); + raise EglBitmapException.Create('LoadPng - couldn''t create info struct.'); + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.FlipVert: Boolean; -begin - result := false; -end; + // set read callback + png_set_read_fn(png, aStream, glBitmap_libPNG_read_func); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap - PUBLIC////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.AfterConstruction; -begin - inherited AfterConstruction; + // read informations + png_read_info(png, png_info); - fID := 0; - fTarget := 0; -{$IFNDEF OPENGL_ES} - fIsResident := false; -{$ENDIF} + // size + TempHeight := png_get_image_height(png, png_info); + TempWidth := png_get_image_width(png, png_info); - fMipMap := glBitmapDefaultMipmap; - fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture; - fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree; + // format + case png_get_color_type(png, png_info) of + PNG_COLOR_TYPE_GRAY: + Format := tfLuminance8ub1; + PNG_COLOR_TYPE_GRAY_ALPHA: + Format := tfLuminance8Alpha8us1; + PNG_COLOR_TYPE_RGB: + Format := tfRGB8ub3; + PNG_COLOR_TYPE_RGB_ALPHA: + Format := tfRGBA8ub4; + else + raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); + end; - glBitmapGetDefaultFilter (fFilterMin, fFilterMag); - glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR); -{$IFNDEF OPENGL_ES} - glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); -{$ENDIF} -end; + // cut upper 8 bit from 16 bit formats + if png_get_bit_depth(png, png_info) > 8 then + png_set_strip_16(png); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.BeforeDestruction; -var - NewData: PByte; -begin - if fFreeDataOnDestroy then begin - NewData := nil; - SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method - end; - if (fID > 0) and fDeleteTextureOnFree then - glDeleteTextures(1, @fID); - inherited BeforeDestruction; -end; + // expand bitdepth smaller than 8 + if png_get_bit_depth(png, png_info) < 8 then + png_set_expand(png); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.PrepareResType(var aResource: String; var aResType: PChar); -var - TempPos: Integer; -begin - if not Assigned(aResType) then begin - TempPos := Pos('.', aResource); - aResType := PChar(UpperCase(Copy(aResource, TempPos + 1, Length(aResource) - TempPos))); - aResource := UpperCase(Copy(aResource, 0, TempPos -1)); - end; -end; + // allocating mem for scanlines + LineSize := png_get_rowbytes(png, png_info); + GetMem(png_data, TempHeight * LineSize); + try + SetLength(png_rows, TempHeight); + for Row := Low(png_rows) to High(png_rows) do begin + png_rows[Row] := png_data; + Inc(png_rows[Row], Row * LineSize); + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromFile(const aFilename: String); -var - fs: TFileStream; -begin - if not FileExists(aFilename) then - raise EglBitmap.Create('file does not exist: ' + aFilename); - fFilename := aFilename; - fs := TFileStream.Create(fFilename, fmOpenRead); - try - fs.Position := 0; - LoadFromStream(fs); + // read complete image into scanlines + png_read_image(png, @png_rows[0]); + + // read end + png_read_end(png, png_info); + + // destroy read struct + png_destroy_read_struct(@png, @png_info, nil); + + SetLength(png_rows, 0); + + // set new data + SetData(png_data, Format, TempWidth, TempHeight); + + result := true; + except + if Assigned(png_data) then + FreeMem(png_data); + raise; + end; + end; finally - fs.Free; + quit_libPNG; end; end; +{$ELSEIF DEFINED(GLB_PNGIMAGE)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromStream(const aStream: TStream); -begin - {$IFDEF GLB_SUPPORT_PNG_READ} - if not LoadPNG(aStream) then - {$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_READ} - if not LoadJPEG(aStream) then - {$ENDIF} - if not LoadDDS(aStream) then - if not LoadTGA(aStream) then - if not LoadBMP(aStream) then - if not LoadRAW(aStream) then - raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.'); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; - const aFormat: TglBitmapFormat; const aArgs: Pointer); +function TglBitmapData.LoadPNG(const aStream: TStream): Boolean; var - tmpData: PByte; - size: Integer; + StreamPos: Int64; + Png: TPNGObject; + Header: String[8]; + Row, Col, PixSize, LineSize: Integer; + NewImage, pSource, pDest, pAlpha: pByte; + PngFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; + +const + PngHeader: String[8] = #137#80#78#71#13#10#26#10; + begin - size := TFormatDescriptor.Get(aFormat).GetSize(aSize); - GetMem(tmpData, size); - try - FillChar(tmpData^, size, #$FF); - SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method - except - if Assigned(tmpData) then - FreeMem(tmpData); - raise; + result := false; + + StreamPos := aStream.Position; + aStream.Read(Header[0], SizeOf(Header)); + aStream.Position := StreamPos; + + {Test if the header matches} + if Header = PngHeader then begin + Png := TPNGObject.Create; + try + Png.LoadFromStream(aStream); + + case Png.Header.ColorType of + COLOR_GRAYSCALE: + PngFormat := tfLuminance8ub1; + COLOR_GRAYSCALEALPHA: + PngFormat := tfLuminance8Alpha8us1; + COLOR_RGB: + PngFormat := tfBGR8ub3; + COLOR_RGBALPHA: + PngFormat := tfBGRA8ub4; + else + raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); + end; + + FormatDesc := TFormatDescriptor.Get(PngFormat); + PixSize := Round(FormatDesc.PixelSize); + LineSize := FormatDesc.GetSize(Png.Header.Width, 1); + + GetMem(NewImage, LineSize * Integer(Png.Header.Height)); + try + pDest := NewImage; + + case Png.Header.ColorType of + COLOR_RGB, COLOR_GRAYSCALE: + begin + for Row := 0 to Png.Height -1 do begin + Move (Png.Scanline[Row]^, pDest^, LineSize); + Inc(pDest, LineSize); + end; + end; + COLOR_RGBALPHA, COLOR_GRAYSCALEALPHA: + begin + PixSize := PixSize -1; + + for Row := 0 to Png.Height -1 do begin + pSource := Png.Scanline[Row]; + pAlpha := pByte(Png.AlphaScanline[Row]); + + for Col := 0 to Png.Width -1 do begin + Move (pSource^, pDest^, PixSize); + Inc(pSource, PixSize); + Inc(pDest, PixSize); + + pDest^ := pAlpha^; + inc(pAlpha); + Inc(pDest); + end; + end; + end; + else + raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); + end; + + SetData(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); + + result := true; + except + if Assigned(NewImage) then + FreeMem(NewImage); + raise; + end; + finally + Png.Free; + end; end; - Convert(Self, aFunc, false, aFormat, aArgs); end; +{$IFEND} +{$ENDIF} +{$IFDEF GLB_SUPPORT_PNG_WRITE} +{$IFDEF GLB_LIB_PNG} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar); -var - rs: TResourceStream; +procedure glBitmap_libPNG_write_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl; begin - PrepareResType(aResource, aResType); - rs := TResourceStream.Create(aInstance, aResource, aResType); - try - LoadFromStream(rs); - finally - rs.Free; - end; + TStream(png_get_io_ptr(png)).Write(buffer^, size); end; +{$ENDIF} +{$IF DEFINED(GLB_LAZ_PNG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); +procedure TglBitmapData.SavePNG(const aStream: TStream); var - rs: TResourceStream; + png: TPortableNetworkGraphic; + intf: TLazIntfImage; + raw: TRawImage; begin - rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); + png := TPortableNetworkGraphic.Create; + intf := TLazIntfImage.Create(0, 0); try - LoadFromStream(rs); + if not AssignToLazIntfImage(intf) then + raise EglBitmap.Create('unable to create LazIntfImage from glBitmap'); + intf.GetRawImage(raw); + png.LoadFromRawImage(raw, false); + png.SaveToStream(aStream); finally - rs.Free; + png.Free; + intf.Free; end; end; +{$ELSEIF DEFINED(GLB_LIB_PNG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType); +procedure TglBitmapData.SavePNG(const aStream: TStream); var - fs: TFileStream; + png: png_structp; + png_info: png_infop; + png_rows: array of pByte; + LineSize: Integer; + ColorType: Integer; + Row: Integer; + FormatDesc: TFormatDescriptor; begin - fs := TFileStream.Create(aFileName, fmCreate); - try - fs.Position := 0; - SaveToStream(fs, aFileType); - finally - fs.Free; - end; -end; + if not (ftPNG in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); -begin - case aFileType of - {$IFDEF GLB_SUPPORT_PNG_WRITE} - ftPNG: SavePNG(aStream); - {$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_WRITE} - ftJPEG: SaveJPEG(aStream); - {$ENDIF} - ftDDS: SaveDDS(aStream); - ftTGA: SaveTGA(aStream); - ftBMP: SaveBMP(aStream); - ftRAW: SaveRAW(aStream); - end; -end; + if not init_libPNG then + raise Exception.Create('unable to initialize libPNG.'); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean; -begin - result := Convert(Self, aFunc, aCreateTemp, Format, aArgs); -end; + try + case Format of + tfAlpha8ub1, tfLuminance8ub1: + ColorType := PNG_COLOR_TYPE_GRAY; + tfLuminance8Alpha8us1: + ColorType := PNG_COLOR_TYPE_GRAY_ALPHA; + tfBGR8ub3, tfRGB8ub3: + ColorType := PNG_COLOR_TYPE_RGB; + tfBGRA8ub4, tfRGBA8ub4: + ColorType := PNG_COLOR_TYPE_RGBA; + else + raise EglBitmapUnsupportedFormat.Create(Format); + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.Convert(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; - const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean; -var - DestData, TmpData, SourceData: pByte; - TempHeight, TempWidth: Integer; - SourceFD, DestFD: TFormatDescriptor; - SourceMD, DestMD: Pointer; + FormatDesc := TFormatDescriptor.Get(Format); + LineSize := FormatDesc.GetSize(Width, 1); - FuncRec: TglBitmapFunctionRec; -begin - Assert(Assigned(Data)); - Assert(Assigned(aSource)); - Assert(Assigned(aSource.Data)); + // creating array for scanline + SetLength(png_rows, Height); + try + for Row := 0 to Height - 1 do begin + png_rows[Row] := Data; + Inc(png_rows[Row], Row * LineSize) + end; - result := false; - if Assigned(aSource.Data) and ((aSource.Height > 0) or (aSource.Width > 0)) then begin - SourceFD := TFormatDescriptor.Get(aSource.Format); - DestFD := TFormatDescriptor.Get(aFormat); + // write struct + png := png_create_write_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil); + if png = nil then + raise EglBitmapException.Create('SavePng - couldn''t create write struct.'); - if (SourceFD.IsCompressed) then - raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format); - if (DestFD.IsCompressed) then - raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format); + // create png info + png_info := png_create_info_struct(png); + if png_info = nil then begin + png_destroy_write_struct(@png, nil); + raise EglBitmapException.Create('SavePng - couldn''t create info struct.'); + end; - // inkompatible Formats so CreateTemp - if (SourceFD.BitsPerPixel <> DestFD.BitsPerPixel) then - aCreateTemp := true; + // set read callback + png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil); - // Values - TempHeight := Max(1, aSource.Height); - TempWidth := Max(1, aSource.Width); + // set compression + png_set_compression_level(png, 6); - FuncRec.Sender := Self; - FuncRec.Args := aArgs; + if Format in [tfBGR8ub3, tfBGRA8ub4] then + png_set_bgr(png); - TmpData := nil; - if aCreateTemp then begin - GetMem(TmpData, DestFD.GetSize(TempWidth, TempHeight)); - DestData := TmpData; - end else - DestData := Data; + png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); + png_write_info(png, png_info); + png_write_image(png, @png_rows[0]); + png_write_end(png, png_info); + png_destroy_write_struct(@png, @png_info); + finally + SetLength(png_rows, 0); + end; + finally + quit_libPNG; + end; +end; - try - SourceFD.PreparePixel(FuncRec.Source); - DestFD.PreparePixel (FuncRec.Dest); +{$ELSEIF DEFINED(GLB_PNGIMAGE)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.SavePNG(const aStream: TStream); +var + Png: TPNGObject; - SourceMD := SourceFD.CreateMappingData; - DestMD := DestFD.CreateMappingData; + pSource, pDest: pByte; + X, Y, PixSize: Integer; + ColorType: Cardinal; + Alpha: Boolean; - FuncRec.Size := aSource.Dimension; - FuncRec.Position.Fields := FuncRec.Size.Fields; + pTemp: pByte; + Temp: Byte; +begin + if not (ftPNG in FormatGetSupportedFiles (Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); - try - SourceData := aSource.Data; - FuncRec.Position.Y := 0; - while FuncRec.Position.Y < TempHeight do begin - FuncRec.Position.X := 0; - while FuncRec.Position.X < TempWidth do begin - SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD); - aFunc(FuncRec); - DestFD.Map(FuncRec.Dest, DestData, DestMD); - inc(FuncRec.Position.X); - end; - inc(FuncRec.Position.Y); - end; + case Format of + tfAlpha8ub1, tfLuminance8ub1: begin + ColorType := COLOR_GRAYSCALE; + PixSize := 1; + Alpha := false; + end; + tfLuminance8Alpha8us1: begin + ColorType := COLOR_GRAYSCALEALPHA; + PixSize := 1; + Alpha := true; + end; + tfBGR8ub3, tfRGB8ub3: begin + ColorType := COLOR_RGB; + PixSize := 3; + Alpha := false; + end; + tfBGRA8ub4, tfRGBA8ub4: begin + ColorType := COLOR_RGBALPHA; + PixSize := 3; + Alpha := true + end; + else + raise EglBitmapUnsupportedFormat.Create(Format); + end; - // Updating Image or InternalFormat - if aCreateTemp then - SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) //be careful, Data could be freed by this method - else if (aFormat <> fFormat) then - Format := aFormat; + Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height); + try + // Copy ImageData + pSource := Data; + for Y := 0 to Height -1 do begin + pDest := png.ScanLine[Y]; + for X := 0 to Width -1 do begin + Move(pSource^, pDest^, PixSize); + Inc(pDest, PixSize); + Inc(pSource, PixSize); + if Alpha then begin + png.AlphaScanline[Y]^[X] := pSource^; + Inc(pSource); + end; + end; - result := true; - finally - SourceFD.FreeMappingData(SourceMD); - DestFD.FreeMappingData(DestMD); + // convert RGB line to BGR + if Format in [tfRGB8ub3, tfRGBA8ub4] then begin + pTemp := png.ScanLine[Y]; + for X := 0 to Width -1 do begin + Temp := pByteArray(pTemp)^[0]; + pByteArray(pTemp)^[0] := pByteArray(pTemp)^[2]; + pByteArray(pTemp)^[2] := Temp; + Inc(pTemp, 3); + end; end; - except - if aCreateTemp and Assigned(TmpData) then - FreeMem(TmpData); - raise; end; + + // Save to Stream + Png.CompressionLevel := 6; + Png.SaveToStream(aStream); + finally + FreeAndNil(Png); end; end; +{$IFEND} +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.ConvertTo(const aFormat: TglBitmapFormat): Boolean; -var - SourceFD, DestFD: TFormatDescriptor; - SourcePD, DestPD: TglBitmapPixelData; - ShiftData: TShiftData; +//JPEG//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +{$IFDEF GLB_LIB_JPEG} +type + glBitmap_libJPEG_source_mgr_ptr = ^glBitmap_libJPEG_source_mgr; + glBitmap_libJPEG_source_mgr = record + pub: jpeg_source_mgr; - function DataIsIdentical: Boolean; - begin - result := SourceFD.MaskMatch(DestFD.Mask); + SrcStream: TStream; + SrcBuffer: array [1..4096] of byte; end; - function CanCopyDirect: Boolean; - begin - result := - ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and - ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and - ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and - ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); - end; + glBitmap_libJPEG_dest_mgr_ptr = ^glBitmap_libJPEG_dest_mgr; + glBitmap_libJPEG_dest_mgr = record + pub: jpeg_destination_mgr; - function CanShift: Boolean; - begin - result := - ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and - ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and - ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and - ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); + DestStream: TStream; + DestBuffer: array [1..4096] of byte; end; - function GetShift(aSource, aDest: Cardinal) : ShortInt; - begin - result := 0; - while (aSource > aDest) and (aSource > 0) do begin - inc(result); - aSource := aSource shr 1; - end; - end; +procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl; +begin + //DUMMY +end; + +procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl; begin - if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin - SourceFD := TFormatDescriptor.Get(Format); - DestFD := TFormatDescriptor.Get(aFormat); - - if DataIsIdentical then begin - result := true; - Format := aFormat; - exit; - end; - - SourceFD.PreparePixel(SourcePD); - DestFD.PreparePixel (DestPD); - - if CanCopyDirect then - result := Convert(Self, glBitmapConvertCopyFunc, false, aFormat) - else if CanShift then begin - ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r); - ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g); - ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b); - ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a); - result := Convert(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData); - end else - result := Convert(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat); - end else - result := true; + //DUMMY end; -{$IFDEF GLB_SDL} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignToSurface(out aSurface: PSDL_Surface): Boolean; -var - Row, RowSize: Integer; - SourceData, TmpData: PByte; - TempDepth: Integer; - FormatDesc: TFormatDescriptor; - - function GetRowPointer(Row: Integer): pByte; - begin - result := aSurface.pixels; - Inc(result, Row * RowSize); - end; +procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl; begin - result := false; - - FormatDesc := TFormatDescriptor.Get(Format); - if FormatDesc.IsCompressed then - raise EglBitmapUnsupportedFormat.Create(Format); + //DUMMY +end; - if Assigned(Data) then begin - case Trunc(FormatDesc.PixelSize) of - 1: TempDepth := 8; - 2: TempDepth := 16; - 3: TempDepth := 24; - 4: TempDepth := 32; - else - raise EglBitmapUnsupportedFormat.Create(Format); - end; +procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl; +begin + //DUMMY +end; - aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth, - FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask); - SourceData := Data; - RowSize := FormatDesc.GetSize(FileWidth, 1); - for Row := 0 to FileHeight-1 do begin - TmpData := GetRowPointer(Row); - if Assigned(TmpData) then begin - Move(SourceData^, TmpData^, RowSize); - inc(SourceData, RowSize); - end; - end; - result := true; - end; +procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl; +begin + //DUMMY end; + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean; +function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl; var - pSource, pData, pTempData: PByte; - Row, RowSize, TempWidth, TempHeight: Integer; - IntFormat: TglBitmapFormat; - fd: TFormatDescriptor; - Mask: TglBitmapMask; + src: glBitmap_libJPEG_source_mgr_ptr; + bytes: integer; +begin + src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src); - function GetRowPointer(Row: Integer): pByte; - begin - result := aSurface^.pixels; - Inc(result, Row * RowSize); - end; + bytes := src^.SrcStream.Read(src^.SrcBuffer[1], 4096); + if (bytes <= 0) then begin + src^.SrcBuffer[1] := $FF; + src^.SrcBuffer[2] := JPEG_EOI; + bytes := 2; + end; -begin - result := false; - if (Assigned(aSurface)) then begin - with aSurface^.format^ do begin - Mask.r := RMask; - Mask.g := GMask; - Mask.b := BMask; - Mask.a := AMask; - IntFormat := TFormatDescriptor.GetFromMask(Mask).Format; - if (IntFormat = tfEmpty) then - raise EglBitmap.Create('AssignFromSurface - Invalid Pixelformat.'); - end; + src^.pub.next_input_byte := @(src^.SrcBuffer[1]); + src^.pub.bytes_in_buffer := bytes; - fd := TFormatDescriptor.Get(IntFormat); - TempWidth := aSurface^.w; - TempHeight := aSurface^.h; - RowSize := fd.GetSize(TempWidth, 1); - GetMem(pData, TempHeight * RowSize); - try - pTempData := pData; - for Row := 0 to TempHeight -1 do begin - pSource := GetRowPointer(Row); - if (Assigned(pSource)) then begin - Move(pSource^, pTempData^, RowSize); - Inc(pTempData, RowSize); - end; - end; - SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method - result := true; - except - if Assigned(pData) then - FreeMem(pData); - raise; - end; - end; + result := true; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean; +procedure glBitmap_libJPEG_skip_input_data(cinfo: j_decompress_ptr; num_bytes: Longint); cdecl; var - Row, Col, AlphaInterleave: Integer; - pSource, pDest: PByte; - - function GetRowPointer(Row: Integer): pByte; - begin - result := aSurface.pixels; - Inc(result, Row * Width); - end; - + src: glBitmap_libJPEG_source_mgr_ptr; begin - result := false; - if Assigned(Data) then begin - if Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfBGRA8ub4, tfRGBA8ub4] then begin - aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0); - - AlphaInterleave := 0; - case Format of - tfLuminance8Alpha8ub2: - AlphaInterleave := 1; - tfBGRA8ub4, tfRGBA8ub4: - AlphaInterleave := 3; - end; + src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src); - pSource := Data; - for Row := 0 to Height -1 do begin - pDest := GetRowPointer(Row); - if Assigned(pDest) then begin - for Col := 0 to Width -1 do begin - Inc(pSource, AlphaInterleave); - pDest^ := pSource^; - Inc(pDest); - Inc(pSource); - end; - end; - end; - result := true; + if num_bytes > 0 then begin + // wanted byte isn't in buffer so set stream position and read buffer + if num_bytes > src^.pub.bytes_in_buffer then begin + src^.SrcStream.Position := src^.SrcStream.Position + num_bytes - src^.pub.bytes_in_buffer; + src^.pub.fill_input_buffer(cinfo); + end else begin + // wanted byte is in buffer so only skip + inc(src^.pub.next_input_byte, num_bytes); + dec(src^.pub.bytes_in_buffer, num_bytes); end; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; +function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl; var - bmp: TglBitmap2D; + dest: glBitmap_libJPEG_dest_mgr_ptr; begin - bmp := TglBitmap2D.Create; - try - bmp.AssignFromSurface(aSurface); - result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs); - finally - bmp.Free; + dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest); + + if dest^.pub.free_in_buffer < Cardinal(Length(dest^.DestBuffer)) then begin + // write complete buffer + dest^.DestStream.Write(dest^.DestBuffer[1], SizeOf(dest^.DestBuffer)); + + // reset buffer + dest^.pub.next_output_byte := @dest^.DestBuffer[1]; + dest^.pub.free_in_buffer := Length(dest^.DestBuffer); end; + + result := true; end; -{$ENDIF} -{$IFDEF GLB_DELPHI} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function CreateGrayPalette: HPALETTE; +procedure glBitmap_libJPEG_term_destination(cinfo: j_compress_ptr); cdecl; var Idx: Integer; - Pal: PLogPalette; + dest: glBitmap_libJPEG_dest_mgr_ptr; begin - GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256)); + dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest); - Pal.palVersion := $300; - Pal.palNumEntries := 256; + for Idx := Low(dest^.DestBuffer) to High(dest^.DestBuffer) do begin + // check for endblock + if (Idx < High(dest^.DestBuffer)) and (dest^.DestBuffer[Idx] = $FF) and (dest^.DestBuffer[Idx +1] = JPEG_EOI) then begin + // write endblock + dest^.DestStream.Write(dest^.DestBuffer[Idx], 2); - for Idx := 0 to Pal.palNumEntries - 1 do begin - Pal.palPalEntry[Idx].peRed := Idx; - Pal.palPalEntry[Idx].peGreen := Idx; - Pal.palPalEntry[Idx].peBlue := Idx; - Pal.palPalEntry[Idx].peFlags := 0; + // leave + break; + end else + dest^.DestStream.Write(dest^.DestBuffer[Idx], 1); end; - Result := CreatePalette(Pal^); - FreeMem(Pal); end; +{$ENDIF} +{$IFDEF GLB_SUPPORT_JPEG_READ} +{$IF DEFINED(GLB_LAZ_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignToBitmap(const aBitmap: TBitmap): Boolean; +function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean; +const + MAGIC_LEN = 2; + JPEG_MAGIC: String[MAGIC_LEN] = #$FF#$D8; var - Row: Integer; - pSource, pData: PByte; + intf: TLazIntfImage; + reader: TFPReaderJPEG; + StreamPos: Int64; + magic: String[MAGIC_LEN]; begin - result := false; - if Assigned(Data) then begin - if Assigned(aBitmap) then begin - aBitmap.Width := Width; - aBitmap.Height := Height; + result := true; + StreamPos := aStream.Position; - case Format of - tfAlpha8ub1, tfLuminance8ub1: begin - aBitmap.PixelFormat := pf8bit; - aBitmap.Palette := CreateGrayPalette; - end; - tfRGB5A1us1: - aBitmap.PixelFormat := pf15bit; - tfR5G6B5us1: - aBitmap.PixelFormat := pf16bit; - tfRGB8ub3, tfBGR8ub3: - aBitmap.PixelFormat := pf24bit; - tfRGBA8ub4, tfBGRA8ub4: - aBitmap.PixelFormat := pf32bit; - else - raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.'); - end; + SetLength(magic, MAGIC_LEN); + aStream.Read(magic[1], MAGIC_LEN); + aStream.Position := StreamPos; + if (magic <> JPEG_MAGIC) then begin + result := false; + exit; + end; - pSource := Data; - for Row := 0 to FileHeight -1 do begin - pData := aBitmap.Scanline[Row]; - Move(pSource^, pData^, fRowSize); - Inc(pSource, fRowSize); - if (Format in [tfRGB8ub3, tfRGBA8ub4]) then // swap RGB(A) to BGR(A) - SwapRGB(pData, FileWidth, Format = tfRGBA8ub4); - end; - result := true; - end; + reader := TFPReaderJPEG.Create; + intf := TLazIntfImage.Create(0, 0); + try try + intf.DataDescription := GetDescriptionFromDevice(0, 0, 0); + reader.ImageRead(aStream, intf); + AssignFromLazIntfImage(intf); + except + result := false; + aStream.Position := StreamPos; + exit; + end; + finally + reader.Free; + intf.Free; end; end; +{$ELSEIF DEFINED(GLB_SDL_IMAGE)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignFromBitmap(const aBitmap: TBitmap): Boolean; +function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean; var - pSource, pData, pTempData: PByte; - Row, RowSize, TempWidth, TempHeight: Integer; - IntFormat: TglBitmapFormat; + Surface: PSDL_Surface; + RWops: PSDL_RWops; begin result := false; - if (Assigned(aBitmap)) then begin - case aBitmap.PixelFormat of - pf8bit: - IntFormat := tfLuminance8ub1; - pf15bit: - IntFormat := tfRGB5A1us1; - pf16bit: - IntFormat := tfR5G6B5us1; - pf24bit: - IntFormat := tfBGR8ub3; - pf32bit: - IntFormat := tfBGRA8ub4; - else - raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.'); - end; - - TempWidth := aBitmap.Width; - TempHeight := aBitmap.Height; - RowSize := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1); - GetMem(pData, TempHeight * RowSize); - try - pTempData := pData; - for Row := 0 to TempHeight -1 do begin - pSource := aBitmap.Scanline[Row]; - if (Assigned(pSource)) then begin - Move(pSource^, pTempData^, RowSize); - Inc(pTempData, RowSize); - end; + RWops := glBitmapCreateRWops(aStream); + try + if IMG_isJPG(RWops) > 0 then begin + Surface := IMG_LoadJPG_RW(RWops); + try + AssignFromSurface(Surface); + result := true; + finally + SDL_FreeSurface(Surface); end; - SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method - result := true; - except - if Assigned(pData) then - FreeMem(pData); - raise; end; + finally + SDL_FreeRW(RWops); end; end; +{$ELSEIF DEFINED(GLB_LIB_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; +function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean; var - Row, Col, AlphaInterleave: Integer; - pSource, pDest: PByte; + StreamPos: Int64; + Temp: array[0..1]of Byte; + + jpeg: jpeg_decompress_struct; + jpeg_err: jpeg_error_mgr; + + IntFormat: TglBitmapFormat; + pImage: pByte; + TempHeight, TempWidth: Integer; + + pTemp: pByte; + Row: Integer; + + FormatDesc: TFormatDescriptor; begin result := false; - if Assigned(Data) then begin - if (Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfRGBA8ub4, tfBGRA8ub4]) then begin - if Assigned(aBitmap) then begin - aBitmap.PixelFormat := pf8bit; - aBitmap.Palette := CreateGrayPalette; - aBitmap.Width := Width; - aBitmap.Height := Height; + if not init_libJPEG then + raise Exception.Create('LoadJPG - unable to initialize libJPEG.'); - case Format of - tfLuminance8Alpha8ub2: - AlphaInterleave := 1; - tfRGBA8ub4, tfBGRA8ub4: - AlphaInterleave := 3; - else - AlphaInterleave := 0; - end; + try + // reading first two bytes to test file and set cursor back to begin + StreamPos := aStream.Position; + aStream.Read({%H-}Temp[0], 2); + aStream.Position := StreamPos; - // Copy Data - pSource := Data; + // if Bitmap then read file. + if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin + FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00); + FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); - for Row := 0 to Height -1 do begin - pDest := aBitmap.Scanline[Row]; - if Assigned(pDest) then begin - for Col := 0 to Width -1 do begin - Inc(pSource, AlphaInterleave); - pDest^ := pSource^; - Inc(pDest); - Inc(pSource); - end; + // error managment + jpeg.err := jpeg_std_error(@jpeg_err); + jpeg_err.error_exit := glBitmap_libJPEG_error_exit; + jpeg_err.output_message := glBitmap_libJPEG_output_message; + + // decompression struct + jpeg_create_decompress(@jpeg); + + // allocation space for streaming methods + jpeg.src := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_source_mgr)); + + // seeting up custom functions + with glBitmap_libJPEG_source_mgr_ptr(jpeg.src)^ do begin + pub.init_source := glBitmap_libJPEG_init_source; + pub.fill_input_buffer := glBitmap_libJPEG_fill_input_buffer; + pub.skip_input_data := glBitmap_libJPEG_skip_input_data; + pub.resync_to_restart := jpeg_resync_to_restart; // use default method + pub.term_source := glBitmap_libJPEG_term_source; + + pub.bytes_in_buffer := 0; // forces fill_input_buffer on first read + pub.next_input_byte := nil; // until buffer loaded + + SrcStream := aStream; + end; + + // set global decoding state + jpeg.global_state := DSTATE_START; + + // read header of jpeg + jpeg_read_header(@jpeg, false); + + // setting output parameter + case jpeg.jpeg_color_space of + JCS_GRAYSCALE: + begin + jpeg.out_color_space := JCS_GRAYSCALE; + IntFormat := tfLuminance8ub1; end; + else + jpeg.out_color_space := JCS_RGB; + IntFormat := tfRGB8ub3; + end; + + // reading image + jpeg_start_decompress(@jpeg); + + TempHeight := jpeg.output_height; + TempWidth := jpeg.output_width; + + FormatDesc := TFormatDescriptor.Get(IntFormat); + + // creating new image + GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight)); + try + pTemp := pImage; + + for Row := 0 to TempHeight -1 do begin + jpeg_read_scanlines(@jpeg, @pTemp, 1); + Inc(pTemp, FormatDesc.GetSize(TempWidth, 1)); end; + + // finish decompression + jpeg_finish_decompress(@jpeg); + + // destroy decompression + jpeg_destroy_decompress(@jpeg); + + SetData(pImage, IntFormat, TempWidth, TempHeight); + result := true; + except + if Assigned(pImage) then + FreeMem(pImage); + raise; end; end; + finally + quit_libJPEG; end; end; +{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +function TglBitmapData.LoadJPEG(const aStream: TStream): Boolean; var - tex: TglBitmap2D; + bmp: TBitmap; + jpg: TJPEGImage; + StreamPos: Int64; + Temp: array[0..1]of Byte; begin - tex := TglBitmap2D.Create; - try - tex.AssignFromBitmap(ABitmap); - result := AddAlphaFromglBitmap(tex, aFunc, aArgs); - finally - tex.Free; + result := false; + + // reading first two bytes to test file and set cursor back to begin + StreamPos := aStream.Position; + aStream.Read(Temp[0], 2); + aStream.Position := StreamPos; + + // if Bitmap then read file. + if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin + bmp := TBitmap.Create; + try + jpg := TJPEGImage.Create; + try + jpg.LoadFromStream(aStream); + bmp.Assign(jpg); + result := AssignFromBitmap(bmp); + finally + jpg.Free; + end; + finally + bmp.Free; + end; end; end; +{$IFEND} {$ENDIF} -{$IFDEF GLB_LAZARUS} +{$IFDEF GLB_SUPPORT_JPEG_WRITE} +{$IF DEFINED(GLB_LAZ_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; +procedure TglBitmapData.SaveJPEG(const aStream: TStream); var - rid: TRawImageDescription; - FormatDesc: TFormatDescriptor; + jpeg: TJPEGImage; + intf: TLazIntfImage; + raw: TRawImage; begin - if not Assigned(Data) then - raise EglBitmap.Create('no pixel data assigned. load data before save'); - - result := false; - if not Assigned(aImage) or (Format = tfEmpty) then - exit; - FormatDesc := TFormatDescriptor.Get(Format); - if FormatDesc.IsCompressed then - exit; - - FillChar(rid{%H-}, SizeOf(rid), 0); - if FormatDesc.IsGrayscale then - rid.Format := ricfGray - else - rid.Format := ricfRGBA; + jpeg := TJPEGImage.Create; + intf := TLazIntfImage.Create(0, 0); + try + if not AssignToLazIntfImage(intf) then + raise EglBitmap.Create('unable to create LazIntfImage from glBitmap'); + intf.GetRawImage(raw); + jpeg.LoadFromRawImage(raw, false); + jpeg.SaveToStream(aStream); + finally + intf.Free; + jpeg.Free; + end; +end; - rid.Width := Width; - rid.Height := Height; - rid.Depth := FormatDesc.BitsPerPixel; - rid.BitOrder := riboBitsInOrder; - rid.ByteOrder := riboLSBFirst; - rid.LineOrder := riloTopToBottom; - rid.LineEnd := rileTight; - rid.BitsPerPixel := FormatDesc.BitsPerPixel; - rid.RedPrec := CountSetBits(FormatDesc.Range.r); - rid.GreenPrec := CountSetBits(FormatDesc.Range.g); - rid.BluePrec := CountSetBits(FormatDesc.Range.b); - rid.AlphaPrec := CountSetBits(FormatDesc.Range.a); - rid.RedShift := FormatDesc.Shift.r; - rid.GreenShift := FormatDesc.Shift.g; - rid.BlueShift := FormatDesc.Shift.b; - rid.AlphaShift := FormatDesc.Shift.a; +{$ELSEIF DEFINED(GLB_LIB_JPEG)} +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.SaveJPEG(const aStream: TStream); +var + jpeg: jpeg_compress_struct; + jpeg_err: jpeg_error_mgr; + Row: Integer; + pTemp, pTemp2: pByte; - rid.MaskBitsPerPixel := 0; - rid.PaletteColorCount := 0; + procedure CopyRow(pDest, pSource: pByte); + var + X: Integer; + begin + for X := 0 to Width - 1 do begin + pByteArray(pDest)^[0] := pByteArray(pSource)^[2]; + pByteArray(pDest)^[1] := pByteArray(pSource)^[1]; + pByteArray(pDest)^[2] := pByteArray(pSource)^[0]; + Inc(pDest, 3); + Inc(pSource, 3); + end; + end; - aImage.DataDescription := rid; - aImage.CreateData; +begin + if not (ftJPEG in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); - if not Assigned(aImage.PixelData) then - raise EglBitmap.Create('error while creating LazIntfImage'); - Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension)); + if not init_libJPEG then + raise Exception.Create('SaveJPG - unable to initialize libJPEG.'); - result := true; + try + FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00); + FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); + + // error managment + jpeg.err := jpeg_std_error(@jpeg_err); + jpeg_err.error_exit := glBitmap_libJPEG_error_exit; + jpeg_err.output_message := glBitmap_libJPEG_output_message; + + // compression struct + jpeg_create_compress(@jpeg); + + // allocation space for streaming methods + jpeg.dest := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_dest_mgr)); + + // seeting up custom functions + with glBitmap_libJPEG_dest_mgr_ptr(jpeg.dest)^ do begin + pub.init_destination := glBitmap_libJPEG_init_destination; + pub.empty_output_buffer := glBitmap_libJPEG_empty_output_buffer; + pub.term_destination := glBitmap_libJPEG_term_destination; + + pub.next_output_byte := @DestBuffer[1]; + pub.free_in_buffer := Length(DestBuffer); + + DestStream := aStream; + end; + + // very important state + jpeg.global_state := CSTATE_START; + jpeg.image_width := Width; + jpeg.image_height := Height; + case Format of + tfAlpha8ub1, tfLuminance8ub1: begin + jpeg.input_components := 1; + jpeg.in_color_space := JCS_GRAYSCALE; + end; + tfRGB8ub3, tfBGR8ub3: begin + jpeg.input_components := 3; + jpeg.in_color_space := JCS_RGB; + end; + end; + + jpeg_set_defaults(@jpeg); + jpeg_set_quality(@jpeg, 95, true); + jpeg_start_compress(@jpeg, true); + pTemp := Data; + + if Format = tfBGR8ub3 then + GetMem(pTemp2, fRowSize) + else + pTemp2 := pTemp; + + try + for Row := 0 to jpeg.image_height -1 do begin + // prepare row + if Format = tfBGR8ub3 then + CopyRow(pTemp2, pTemp) + else + pTemp2 := pTemp; + + // write row + jpeg_write_scanlines(@jpeg, @pTemp2, 1); + inc(pTemp, fRowSize); + end; + finally + // free memory + if Format = tfBGR8ub3 then + FreeMem(pTemp2); + end; + jpeg_finish_compress(@jpeg); + jpeg_destroy_compress(@jpeg); + finally + quit_libJPEG; + end; end; +{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; +procedure TglBitmapData.SaveJPEG(const aStream: TStream); var - f: TglBitmapFormat; - FormatDesc: TFormatDescriptor; - ImageData: PByte; - ImageSize: Integer; - CanCopy: Boolean; - Mask: TglBitmapRec4ul; + Bmp: TBitmap; + Jpg: TJPEGImage; +begin + if not (ftJPEG in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); - procedure CopyConvert; - var - bfFormat: TbmpBitfieldFormat; - pSourceLine, pDestLine: PByte; - pSourceMD, pDestMD: Pointer; - Shift, Prec: TglBitmapRec4ub; - x, y: Integer; - pixel: TglBitmapPixelData; - begin - bfFormat := TbmpBitfieldFormat.Create; - with aImage.DataDescription do begin - Prec.r := RedPrec; - Prec.g := GreenPrec; - Prec.b := BluePrec; - Prec.a := AlphaPrec; - Shift.r := RedShift; - Shift.g := GreenShift; - Shift.b := BlueShift; - Shift.a := AlphaShift; - bfFormat.SetCustomValues(BitsPerPixel, Prec, Shift); - end; - pSourceMD := bfFormat.CreateMappingData; - pDestMD := FormatDesc.CreateMappingData; + Bmp := TBitmap.Create; + try + Jpg := TJPEGImage.Create; try - for y := 0 to aImage.Height-1 do begin - pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine; - pDestLine := ImageData + y * Round(FormatDesc.BytesPerPixel * aImage.Width); - for x := 0 to aImage.Width-1 do begin - bfFormat.Unmap(pSourceLine, pixel, pSourceMD); - FormatDesc.Map(pixel, pDestLine, pDestMD); - end; + AssignToBitmap(Bmp); + if (Format in [tfAlpha8ub1, tfLuminance8ub1]) then begin + Jpg.Grayscale := true; + Jpg.PixelFormat := jf8Bit; end; + Jpg.Assign(Bmp); + Jpg.SaveToStream(aStream); finally - FormatDesc.FreeMappingData(pDestMD); - bfFormat.FreeMappingData(pSourceMD); - bfFormat.Free; + FreeAndNil(Jpg); end; + finally + FreeAndNil(Bmp); + end; +end; +{$IFEND} +{$ENDIF} + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//RAW///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +type + RawHeader = packed record + Magic: String[5]; + Version: Byte; + Width: Integer; + Height: Integer; + DataSize: Integer; + BitsPerPixel: Integer; + Precision: TglBitmapRec4ub; + Shift: TglBitmapRec4ub; end; +function TglBitmapData.LoadRAW(const aStream: TStream): Boolean; +var + header: RawHeader; + StartPos: Int64; + fd: TFormatDescriptor; + buf: PByte; begin result := false; - if not Assigned(aImage) then + StartPos := aStream.Position; + aStream.Read(header{%H-}, SizeOf(header)); + if (header.Magic <> 'glBMP') then begin + aStream.Position := StartPos; exit; - - with aImage.DataDescription do begin - Mask.r := (QWord(1 shl RedPrec )-1) shl RedShift; - Mask.g := (QWord(1 shl GreenPrec)-1) shl GreenShift; - Mask.b := (QWord(1 shl BluePrec )-1) shl BlueShift; - Mask.a := (QWord(1 shl AlphaPrec)-1) shl AlphaShift; end; - FormatDesc := TFormatDescriptor.GetFromMask(Mask); - f := FormatDesc.Format; - if (f = tfEmpty) then - exit; - CanCopy := - (FormatDesc.BitsPerPixel = aImage.DataDescription.Depth) and - (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth); + fd := TFormatDescriptor.GetFromPrecShift(header.Precision, header.Shift, header.BitsPerPixel); + if (fd.Format = tfEmpty) then + raise EglBitmapUnsupportedFormat.Create('no supported format found'); - ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height); - ImageData := GetMem(ImageSize); - try - if CanCopy then - Move(aImage.PixelData^, ImageData^, ImageSize) - else - CopyConvert; - SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method - except - if Assigned(ImageData) then - FreeMem(ImageData); - raise; - end; + buf := GetMemory(header.DataSize); + aStream.Read(buf^, header.DataSize); + SetData(buf, fd.Format, header.Width, header.Height); result := true; end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; +procedure TglBitmapData.SaveRAW(const aStream: TStream); var - rid: TRawImageDescription; - FormatDesc: TFormatDescriptor; - Pixel: TglBitmapPixelData; - x, y: Integer; - srcMD: Pointer; - src, dst: PByte; -begin - result := false; - if not Assigned(aImage) or (Format = tfEmpty) then - exit; - FormatDesc := TFormatDescriptor.Get(Format); - if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then - exit; - - FillChar(rid{%H-}, SizeOf(rid), 0); - rid.Format := ricfGray; - rid.Width := Width; - rid.Height := Height; - rid.Depth := CountSetBits(FormatDesc.Range.a); - rid.BitOrder := riboBitsInOrder; - rid.ByteOrder := riboLSBFirst; - rid.LineOrder := riloTopToBottom; - rid.LineEnd := rileTight; - rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8); - rid.RedPrec := CountSetBits(FormatDesc.Range.a); - rid.GreenPrec := 0; - rid.BluePrec := 0; - rid.AlphaPrec := 0; - rid.RedShift := 0; - rid.GreenShift := 0; - rid.BlueShift := 0; - rid.AlphaShift := 0; - - rid.MaskBitsPerPixel := 0; - rid.PaletteColorCount := 0; - - aImage.DataDescription := rid; - aImage.CreateData; - - srcMD := FormatDesc.CreateMappingData; - try - FormatDesc.PreparePixel(Pixel); - src := Data; - dst := aImage.PixelData; - for y := 0 to Height-1 do - for x := 0 to Width-1 do begin - FormatDesc.Unmap(src, Pixel, srcMD); - case rid.BitsPerPixel of - 8: begin - dst^ := Pixel.Data.a; - inc(dst); - end; - 16: begin - PWord(dst)^ := Pixel.Data.a; - inc(dst, 2); - end; - 24: begin - PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0]; - PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1]; - PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2]; - inc(dst, 3); - end; - 32: begin - PCardinal(dst)^ := Pixel.Data.a; - inc(dst, 4); - end; - else - raise EglBitmapUnsupportedFormat.Create(Format); - end; - end; - finally - FormatDesc.FreeMappingData(srcMD); - end; - result := true; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - tex: TglBitmap2D; + header: RawHeader; + fd: TFormatDescriptor; begin - tex := TglBitmap2D.Create; - try - tex.AssignFromLazIntfImage(aImage); - result := AddAlphaFromglBitmap(tex, aFunc, aArgs); - finally - tex.Free; - end; + fd := TFormatDescriptor.Get(Format); + header.Magic := 'glBMP'; + header.Version := 1; + header.Width := Width; + header.Height := Height; + header.DataSize := fd.GetSize(fDimension); + header.BitsPerPixel := fd.BitsPerPixel; + header.Precision := fd.Precision; + header.Shift := fd.Shift; + aStream.Write(header, SizeOf(header)); + aStream.Write(Data^, header.DataSize); end; -{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar; - const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - rs: TResourceStream; -begin - PrepareResType(aResource, aResType); - rs := TResourceStream.Create(aInstance, aResource, aResType); - try - result := AddAlphaFromStream(rs, aFunc, aArgs); - finally - rs.Free; - end; -end; - +//BMP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; - const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - rs: TResourceStream; -begin - rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); - try - result := AddAlphaFromStream(rs, aFunc, aArgs); - finally - rs.Free; - end; -end; +const + BMP_MAGIC = $4D42; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -begin - if TFormatDescriptor.Get(Format).IsCompressed then - raise EglBitmapUnsupportedFormat.Create(Format); - result := Convert(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs); -end; + BMP_COMP_RGB = 0; + BMP_COMP_RLE8 = 1; + BMP_COMP_RLE4 = 2; + BMP_COMP_BITFIELDS = 3; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - FS: TFileStream; -begin - FS := TFileStream.Create(aFileName, fmOpenRead); - try - result := AddAlphaFromStream(FS, aFunc, aArgs); - finally - FS.Free; +type + TBMPHeader = packed record + bfType: Word; + bfSize: Cardinal; + bfReserved1: Word; + bfReserved2: Word; + bfOffBits: Cardinal; end; -end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - tex: TglBitmap2D; -begin - tex := TglBitmap2D.Create(aStream); - try - result := AddAlphaFromglBitmap(tex, aFunc, aArgs); - finally - tex.Free; + TBMPInfo = packed record + biSize: Cardinal; + biWidth: Longint; + biHeight: Longint; + biPlanes: Word; + biBitCount: Word; + biCompression: Cardinal; + biSizeImage: Cardinal; + biXPelsPerMeter: Longint; + biYPelsPerMeter: Longint; + biClrUsed: Cardinal; + biClrImportant: Cardinal; end; -end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; -var - DestData, DestData2, SourceData: pByte; - TempHeight, TempWidth: Integer; - SourceFD, DestFD: TFormatDescriptor; - SourceMD, DestMD, DestMD2: Pointer; - - FuncRec: TglBitmapFunctionRec; -begin - result := false; +function TglBitmapData.LoadBMP(const aStream: TStream): Boolean; - Assert(Assigned(Data)); - Assert(Assigned(aBitmap)); - Assert(Assigned(aBitmap.Data)); + ////////////////////////////////////////////////////////////////////////////////////////////////// + function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapRec4ul): TglBitmapFormat; + var + tmp, i: Cardinal; + begin + result := tfEmpty; + aStream.Read(aInfo{%H-}, SizeOf(aInfo)); + FillChar(aMask{%H-}, SizeOf(aMask), 0); - if ((aBitmap.Width = Width) and (aBitmap.Height = Height)) then begin - result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha); + //Read Compression + case aInfo.biCompression of + BMP_COMP_RLE4, + BMP_COMP_RLE8: begin + raise EglBitmap.Create('RLE compression is not supported'); + end; + BMP_COMP_BITFIELDS: begin + if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin + for i := 0 to 2 do begin + aStream.Read(tmp{%H-}, SizeOf(tmp)); + aMask.arr[i] := tmp; + end; + end else + raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats'); + end; + end; - SourceFD := TFormatDescriptor.Get(aBitmap.Format); - DestFD := TFormatDescriptor.Get(Format); + //get suitable format + case aInfo.biBitCount of + 8: result := tfLuminance8ub1; + 16: result := tfX1RGB5us1; + 24: result := tfBGR8ub3; + 32: result := tfXRGB8ui1; + end; + end; - if not Assigned(aFunc) then begin - aFunc := glBitmapAlphaFunc; - FuncRec.Args := {%H-}Pointer(SourceFD.HasAlpha); - end else - FuncRec.Args := aArgs; + function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat; + var + i, c: Integer; + fd: TFormatDescriptor; + ColorTable: TbmpColorTable; + begin + result := nil; + if (aInfo.biBitCount >= 16) then + exit; + aFormat := tfLuminance8ub1; + c := aInfo.biClrUsed; + if (c = 0) then + c := 1 shl aInfo.biBitCount; + SetLength(ColorTable, c); + for i := 0 to c-1 do begin + aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty)); + if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then + aFormat := tfRGB8ub3; + end; - // Values - TempHeight := aBitmap.FileHeight; - TempWidth := aBitmap.FileWidth; + fd := TFormatDescriptor.Get(aFormat); + result := TbmpColorTableFormat.Create; + result.ColorTable := ColorTable; + result.SetCustomValues(aFormat, aInfo.biBitCount, fd.Precision, fd.Shift); + end; - FuncRec.Sender := Self; - FuncRec.Size := Dimension; - FuncRec.Position.Fields := FuncRec.Size.Fields; + ////////////////////////////////////////////////////////////////////////////////////////////////// + function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapRec4ul; const aInfo: TBMPInfo): TbmpBitfieldFormat; + var + fd: TFormatDescriptor; + begin + result := nil; + if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin - DestData := Data; - DestData2 := Data; - SourceData := aBitmap.Data; + // find suitable format ... + fd := TFormatDescriptor.GetFromMask(aMask); + if (fd.Format <> tfEmpty) then begin + aFormat := fd.Format; + exit; + end; - // Mapping - SourceFD.PreparePixel(FuncRec.Source); - DestFD.PreparePixel (FuncRec.Dest); + // or create custom bitfield format + result := TbmpBitfieldFormat.Create; + result.SetCustomValues(aInfo.biBitCount, aMask); + end; + end; - SourceMD := SourceFD.CreateMappingData; - DestMD := DestFD.CreateMappingData; - DestMD2 := DestFD.CreateMappingData; - try - FuncRec.Position.Y := 0; - while FuncRec.Position.Y < TempHeight do begin - FuncRec.Position.X := 0; - while FuncRec.Position.X < TempWidth do begin - SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD); - DestFD.Unmap (DestData, FuncRec.Dest, DestMD); - aFunc(FuncRec); - DestFD.Map(FuncRec.Dest, DestData2, DestMD2); - inc(FuncRec.Position.X); - end; - inc(FuncRec.Position.Y); - end; - finally - SourceFD.FreeMappingData(SourceMD); - DestFD.FreeMappingData(DestMD); - DestFD.FreeMappingData(DestMD2); - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean; -begin - result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal): Boolean; var - PixelData: TglBitmapPixelData; -begin - TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); - result := AddAlphaFromColorKeyFloat( - aRed / PixelData.Range.r, - aGreen / PixelData.Range.g, - aBlue / PixelData.Range.b, - aDeviation / Max(PixelData.Range.r, Max(PixelData.Range.g, PixelData.Range.b))); -end; + //simple types + StartPos: Int64; + ImageSize, rbLineSize, wbLineSize, Padding, i: Integer; + PaddingBuff: Cardinal; + LineBuf, ImageData, TmpData: PByte; + SourceMD, DestMD: Pointer; + BmpFormat: TglBitmapFormat; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single): Boolean; -var - values: array[0..2] of Single; - tmp: Cardinal; - i: Integer; - PixelData: TglBitmapPixelData; -begin - TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); - with PixelData do begin - values[0] := aRed; - values[1] := aGreen; - values[2] := aBlue; + //records + Mask: TglBitmapRec4ul; + Header: TBMPHeader; + Info: TBMPInfo; - for i := 0 to 2 do begin - tmp := Trunc(Range.arr[i] * aDeviation); - Data.arr[i] := Min(Range.arr[i], Trunc(Range.arr[i] * values[i] + tmp)); - Range.arr[i] := Max(0, Trunc(Range.arr[i] * values[i] - tmp)); + //classes + SpecialFormat: TFormatDescriptor; + FormatDesc: TFormatDescriptor; + + ////////////////////////////////////////////////////////////////////////////////////////////////// + procedure SpecialFormatReadLine(aData: PByte; aLineBuf: PByte); + var + i: Integer; + Pixel: TglBitmapPixelData; + begin + aStream.Read(aLineBuf^, rbLineSize); + SpecialFormat.PreparePixel(Pixel); + for i := 0 to Info.biWidth-1 do begin + SpecialFormat.Unmap(aLineBuf, Pixel, SourceMD); + glBitmapConvertPixel(Pixel, SpecialFormat, FormatDesc); + FormatDesc.Map(Pixel, aData, DestMD); end; - Data.a := 0; - Range.a := 0; end; - result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, @PixelData); -end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromValue(const aAlpha: Byte): Boolean; begin - result := AddAlphaFromValueFloat(aAlpha / $FF); -end; + result := false; + BmpFormat := tfEmpty; + SpecialFormat := nil; + LineBuf := nil; + SourceMD := nil; + DestMD := nil; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; -var - PixelData: TglBitmapPixelData; -begin - TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); - result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a); -end; + // Header + StartPos := aStream.Position; + aStream.Read(Header{%H-}, SizeOf(Header)); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean; -var - PixelData: TglBitmapPixelData; -begin - TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); - with PixelData do - Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha))); - result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a); + if Header.bfType = BMP_MAGIC then begin + try try + BmpFormat := ReadInfo(Info, Mask); + SpecialFormat := ReadColorTable(BmpFormat, Info); + if not Assigned(SpecialFormat) then + SpecialFormat := CheckBitfields(BmpFormat, Mask, Info); + aStream.Position := StartPos + Header.bfOffBits; + + if (BmpFormat <> tfEmpty) then begin + FormatDesc := TFormatDescriptor.Get(BmpFormat); + rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize + wbLineSize := Trunc(Info.biWidth * FormatDesc.BytesPerPixel); + Padding := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize; + + //get Memory + DestMD := FormatDesc.CreateMappingData; + ImageSize := FormatDesc.GetSize(Info.biWidth, abs(Info.biHeight)); + GetMem(ImageData, ImageSize); + if Assigned(SpecialFormat) then begin + GetMem(LineBuf, rbLineSize); //tmp Memory for converting Bitfields + SourceMD := SpecialFormat.CreateMappingData; + end; + + //read Data + try try + FillChar(ImageData^, ImageSize, $FF); + TmpData := ImageData; + if (Info.biHeight > 0) then + Inc(TmpData, wbLineSize * (Info.biHeight-1)); + for i := 0 to Abs(Info.biHeight)-1 do begin + if Assigned(SpecialFormat) then + SpecialFormatReadLine(TmpData, LineBuf) //if is special format read and convert data + else + aStream.Read(TmpData^, wbLineSize); //else only read data + if (Info.biHeight > 0) then + dec(TmpData, wbLineSize) + else + inc(TmpData, wbLineSize); + aStream.Read(PaddingBuff{%H-}, Padding); + end; + SetData(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); + result := true; + finally + if Assigned(LineBuf) then + FreeMem(LineBuf); + if Assigned(SourceMD) then + SpecialFormat.FreeMappingData(SourceMD); + FormatDesc.FreeMappingData(DestMD); + end; + except + if Assigned(ImageData) then + FreeMem(ImageData); + raise; + end; + end else + raise EglBitmap.Create('LoadBMP - No suitable format found'); + except + aStream.Position := StartPos; + raise; + end; + finally + FreeAndNil(SpecialFormat); + end; + end + else aStream.Position := StartPos; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.RemoveAlpha: Boolean; +procedure TglBitmapData.SaveBMP(const aStream: TStream); var + Header: TBMPHeader; + Info: TBMPInfo; + Converter: TFormatDescriptor; FormatDesc: TFormatDescriptor; -begin - result := false; - FormatDesc := TFormatDescriptor.Get(Format); - if Assigned(Data) then begin - if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then - raise EglBitmapUnsupportedFormat.Create(Format); - result := ConvertTo(FormatDesc.WithoutAlpha); - end; -end; + SourceFD, DestFD: Pointer; + pData, srcData, dstData, ConvertBuffer: pByte; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.Clone: TglBitmap; -var - Temp: TglBitmap; - TempPtr: PByte; - Size: Integer; -begin - result := nil; - Temp := (ClassType.Create as TglBitmap); - try - // copy texture data if assigned - if Assigned(Data) then begin - Size := TFormatDescriptor.Get(Format).GetSize(fDimension); - GetMem(TempPtr, Size); - try - Move(Data^, TempPtr^, Size); - Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method - except - if Assigned(TempPtr) then - FreeMem(TempPtr); - raise; - end; - end else begin - TempPtr := nil; - Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method - end; + Pixel: TglBitmapPixelData; + ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx: Integer; + RedMask, GreenMask, BlueMask, AlphaMask: Cardinal; - // copy properties - Temp.fID := ID; - Temp.fTarget := Target; - Temp.fFormat := Format; - Temp.fMipMap := MipMap; - Temp.fAnisotropic := Anisotropic; - Temp.fBorderColor := fBorderColor; - Temp.fDeleteTextureOnFree := DeleteTextureOnFree; - Temp.fFreeDataAfterGenTexture := FreeDataAfterGenTexture; - Temp.fFilterMin := fFilterMin; - Temp.fFilterMag := fFilterMag; - Temp.fWrapS := fWrapS; - Temp.fWrapT := fWrapT; - Temp.fWrapR := fWrapR; - Temp.fFilename := fFilename; - Temp.fCustomName := fCustomName; - Temp.fCustomNameW := fCustomNameW; - Temp.fCustomData := fCustomData; + PaddingBuff: Cardinal; - result := Temp; - except - FreeAndNil(Temp); - raise; + function GetLineWidth : Integer; + begin + result := ((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3; end; -end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean); begin - if aUseRGB or aUseAlpha then - Convert(glBitmapInvertFunc, false, {%H-}Pointer( - ((Byte(aUseAlpha) and 1) shl 1) or - (Byte(aUseRGB) and 1) )); -end; + if not (ftBMP in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.FreeData; -var - TempPtr: PByte; -begin - TempPtr := nil; - SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method -end; + Converter := nil; + FormatDesc := TFormatDescriptor.Get(Format); + ImageSize := FormatDesc.GetSize(Dimension); -{$IFNDEF OPENGL_ES} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); -begin - fBorderColor[0] := aRed; - fBorderColor[1] := aGreen; - fBorderColor[2] := aBlue; - fBorderColor[3] := aAlpha; - if (ID > 0) then begin - Bind(false); - glTexParameterfv(Target, GL_TEXTURE_BORDER_COLOR, @fBorderColor[0]); - end; -end; -{$ENDIF} + FillChar(Header{%H-}, SizeOf(Header), 0); + Header.bfType := BMP_MAGIC; + Header.bfSize := SizeOf(Header) + SizeOf(Info) + ImageSize; + Header.bfReserved1 := 0; + Header.bfReserved2 := 0; + Header.bfOffBits := SizeOf(Header) + SizeOf(Info); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.FillWithColor(const aRed, aGreen, aBlue: Byte; - const aAlpha: Byte); -begin - FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF); -end; + FillChar(Info{%H-}, SizeOf(Info), 0); + Info.biSize := SizeOf(Info); + Info.biWidth := Width; + Info.biHeight := Height; + Info.biPlanes := 1; + Info.biCompression := BMP_COMP_RGB; + Info.biSizeImage := ImageSize; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal); -var - PixelData: TglBitmapPixelData; -begin - TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); - FillWithColorFloat( - aRed / PixelData.Range.r, - aGreen / PixelData.Range.g, - aBlue / PixelData.Range.b, - aAlpha / PixelData.Range.a); -end; + try + case Format of + tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1: + begin + Info.biBitCount := 8; + Header.bfSize := Header.bfSize + 256 * SizeOf(Cardinal); + Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries + Converter := TbmpColorTableFormat.Create; + with (Converter as TbmpColorTableFormat) do begin + SetCustomValues(fFormat, 8, FormatDesc.Precision, FormatDesc.Shift); + CreateColorTable; + end; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single); -var - PixelData: TglBitmapPixelData; -begin - TFormatDescriptor.Get(Format).PreparePixel(PixelData); - with PixelData do begin - Data.r := Max(0, Min(Range.r, Trunc(Range.r * aRed))); - Data.g := Max(0, Min(Range.g, Trunc(Range.g * aGreen))); - Data.b := Max(0, Min(Range.b, Trunc(Range.b * aBlue))); - Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha))); - end; - Convert(glBitmapFillWithColorFunc, false, @PixelData); -end; + tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, + tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1, + tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1: + begin + Info.biBitCount := 16; + Info.biCompression := BMP_COMP_BITFIELDS; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetFilter(const aMin, aMag: GLenum); -begin - //check MIN filter - case aMin of - GL_NEAREST: - fFilterMin := GL_NEAREST; - GL_LINEAR: - fFilterMin := GL_LINEAR; - GL_NEAREST_MIPMAP_NEAREST: - fFilterMin := GL_NEAREST_MIPMAP_NEAREST; - GL_LINEAR_MIPMAP_NEAREST: - fFilterMin := GL_LINEAR_MIPMAP_NEAREST; - GL_NEAREST_MIPMAP_LINEAR: - fFilterMin := GL_NEAREST_MIPMAP_LINEAR; - GL_LINEAR_MIPMAP_LINEAR: - fFilterMin := GL_LINEAR_MIPMAP_LINEAR; - else - raise EglBitmap.Create('SetFilter - Unknow MIN filter.'); - end; + tfBGR8ub3, tfRGB8ub3: + begin + Info.biBitCount := 24; + if (Format = tfRGB8ub3) then + Converter := TfdBGR8ub3.Create; //use BGR8 Format Descriptor to Swap RGB Values + end; - //check MAG filter - case aMag of - GL_NEAREST: - fFilterMag := GL_NEAREST; - GL_LINEAR: - fFilterMag := GL_LINEAR; + tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1, + tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1: + begin + Info.biBitCount := 32; + Info.biCompression := BMP_COMP_BITFIELDS; + end; else - raise EglBitmap.Create('SetFilter - Unknow MAG filter.'); - end; + raise EglBitmapUnsupportedFormat.Create(Format); + end; + Info.biXPelsPerMeter := 2835; + Info.biYPelsPerMeter := 2835; - //apply filter - if (ID > 0) then begin - Bind(false); - glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag); + // prepare bitmasks + if Info.biCompression = BMP_COMP_BITFIELDS then begin + Header.bfSize := Header.bfSize + 4 * SizeOf(Cardinal); + Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal); - if (MipMap = mmNone) {$IFNDEF OPENGL_ES}or (Target = GL_TEXTURE_RECTANGLE){$ENDIF} then begin - case fFilterMin of - GL_NEAREST, GL_LINEAR: - glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin); - GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR: - glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR: - glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - end; - end else - glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin); - end; -end; + RedMask := FormatDesc.Mask.r; + GreenMask := FormatDesc.Mask.g; + BlueMask := FormatDesc.Mask.b; + AlphaMask := FormatDesc.Mask.a; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum); + // headers + aStream.Write(Header, SizeOf(Header)); + aStream.Write(Info, SizeOf(Info)); - procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal); - begin - case aValue of -{$IFNDEF OPENGL_ES} - GL_CLAMP: - aTarget := GL_CLAMP; -{$ENDIF} + // colortable + if Assigned(Converter) and (Converter is TbmpColorTableFormat) then + with (Converter as TbmpColorTableFormat) do + aStream.Write(ColorTable[0].b, + SizeOf(TbmpColorTableEnty) * Length(ColorTable)); - GL_REPEAT: - aTarget := GL_REPEAT; + // bitmasks + if Info.biCompression = BMP_COMP_BITFIELDS then begin + aStream.Write(RedMask, SizeOf(Cardinal)); + aStream.Write(GreenMask, SizeOf(Cardinal)); + aStream.Write(BlueMask, SizeOf(Cardinal)); + aStream.Write(AlphaMask, SizeOf(Cardinal)); + end; - GL_CLAMP_TO_EDGE: begin -{$IFNDEF OPENGL_ES} - if not GL_VERSION_1_2 and not GL_EXT_texture_edge_clamp then - aTarget := GL_CLAMP - else -{$ENDIF} - aTarget := GL_CLAMP_TO_EDGE; - end; + // image data + rbLineSize := Round(Info.biWidth * FormatDesc.BytesPerPixel); + wbLineSize := Round(Info.biWidth * Info.biBitCount / 8); + Padding := GetLineWidth - wbLineSize; + PaddingBuff := 0; -{$IFNDEF OPENGL_ES} - GL_CLAMP_TO_BORDER: begin - if GL_VERSION_1_3 or GL_ARB_texture_border_clamp then - aTarget := GL_CLAMP_TO_BORDER - else - aTarget := GL_CLAMP; - end; -{$ENDIF} + pData := Data; + inc(pData, (Height-1) * rbLineSize); -{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} - GL_MIRRORED_REPEAT: begin - {$IFNDEF OPENGL_ES} - if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then - {$ELSE} - if GL_VERSION_2_0 then - {$ENDIF} - aTarget := GL_MIRRORED_REPEAT - else - raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).'); + // prepare row buffer. But only for RGB because RGBA supports color masks + // so it's possible to change color within the image. + if Assigned(Converter) then begin + FormatDesc.PreparePixel(Pixel); + GetMem(ConvertBuffer, wbLineSize); + SourceFD := FormatDesc.CreateMappingData; + DestFD := Converter.CreateMappingData; + end else + ConvertBuffer := nil; + + try + for LineIdx := 0 to Height - 1 do begin + // preparing row + if Assigned(Converter) then begin + srcData := pData; + dstData := ConvertBuffer; + for PixelIdx := 0 to Info.biWidth-1 do begin + FormatDesc.Unmap(srcData, Pixel, SourceFD); + glBitmapConvertPixel(Pixel, FormatDesc, Converter); + Converter.Map(Pixel, dstData, DestFD); + end; + aStream.Write(ConvertBuffer^, wbLineSize); + end else begin + aStream.Write(pData^, rbLineSize); + end; + dec(pData, rbLineSize); + if (Padding > 0) then + aStream.Write(PaddingBuff, Padding); + end; + finally + // destroy row buffer + if Assigned(ConvertBuffer) then begin + FormatDesc.FreeMappingData(SourceFD); + Converter.FreeMappingData(DestFD); + FreeMem(ConvertBuffer); end; -{$IFEND} - else - raise EglBitmap.Create('SetWrap - Unknow Texturewrap'); end; - end; - -begin - CheckAndSetWrap(S, fWrapS); - CheckAndSetWrap(T, fWrapT); - CheckAndSetWrap(R, fWrapR); - - if (ID > 0) then begin - Bind(false); - glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS); - glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT); -{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} - {$IFDEF OPENGL_ES} if GL_VERSION_3_0 then{$ENDIF} - glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR); -{$IFEND} + finally + if Assigned(Converter) then + Converter.Free; end; end; -{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum); - - procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer); - begin - if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or - (aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then - fSwizzle[aIndex] := aValue - else - raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value'); - end; - -begin -{$IFNDEF OPENGL_ES} - if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then - raise EglBitmapNotSupported.Create('texture swizzle is not supported'); -{$ELSE} - if not GL_VERSION_3_0 then - raise EglBitmapNotSupported.Create('texture swizzle is not supported'); -{$ENDIF} - CheckAndSetValue(r, 0); - CheckAndSetValue(g, 1); - CheckAndSetValue(b, 2); - CheckAndSetValue(a, 3); - - if (ID > 0) then begin - Bind(false); -{$IFNDEF OPENGL_ES} - glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0])); -{$ELSE} - glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_R, PGLint(@fSwizzle[0])); - glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_G, PGLint(@fSwizzle[1])); - glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_B, PGLint(@fSwizzle[2])); - glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_A, PGLint(@fSwizzle[3])); -{$ENDIF} - end; -end; -{$IFEND} - +//TGA///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean); -begin - if aEnableTextureUnit then - glEnable(Target); - if (ID > 0) then - glBindTexture(Target, ID); -end; +type + TTGAHeader = packed record + ImageID: Byte; + ColorMapType: Byte; + ImageType: Byte; + //ColorMapSpec: Array[0..4] of Byte; + ColorMapStart: Word; + ColorMapLength: Word; + ColorMapEntrySize: Byte; + OrigX: Word; + OrigY: Word; + Width: Word; + Height: Word; + Bpp: Byte; + ImageDesc: Byte; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.Unbind(const aDisableTextureUnit: Boolean); -begin - if aDisableTextureUnit then - glDisable(Target); - glBindTexture(Target, 0); -end; +const + TGA_UNCOMPRESSED_RGB = 2; + TGA_UNCOMPRESSED_GRAY = 3; + TGA_COMPRESSED_RGB = 10; + TGA_COMPRESSED_GRAY = 11; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create; -begin - if (ClassType = TglBitmap) then - raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.'); - inherited Create; - fFormat := glBitmapGetDefaultFormat; - fFreeDataOnDestroy := true; -end; + TGA_NONE_COLOR_TABLE = 0; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aFileName: String); -begin - Create; - LoadFromFile(aFileName); -end; +function TglBitmapData.LoadTGA(const aStream: TStream): Boolean; +var + Header: TTGAHeader; + ImageData: System.PByte; + StartPosition: Int64; + PixelSize, LineSize: Integer; + tgaFormat: TglBitmapFormat; + FormatDesc: TFormatDescriptor; + Counter: packed record + X, Y: packed record + low, high, dir: Integer; + end; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aStream: TStream); -begin - Create; - LoadFromStream(aStream); -end; +const + CACHE_SIZE = $4000; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte); -var - ImageSize: Integer; -begin - Create; - if not Assigned(aData) then begin - ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize); - GetMem(aData, ImageSize); + //////////////////////////////////////////////////////////////////////////////////////// + procedure ReadUncompressed; + var + i, j: Integer; + buf, tmp1, tmp2: System.PByte; + begin + buf := nil; + if (Counter.X.dir < 0) then + GetMem(buf, LineSize); try - FillChar(aData^, ImageSize, #$FF); - SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method - except - if Assigned(aData) then - FreeMem(aData); - raise; + while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin + tmp1 := ImageData; + inc(tmp1, (Counter.Y.low * LineSize)); //pointer to LineStart + if (Counter.X.dir < 0) then begin //flip X + aStream.Read(buf^, LineSize); + tmp2 := buf; + inc(tmp2, LineSize - PixelSize); //pointer to last pixel in line + for i := 0 to Header.Width-1 do begin //for all pixels in line + for j := 0 to PixelSize-1 do begin //for all bytes in pixel + tmp1^ := tmp2^; + inc(tmp1); + inc(tmp2); + end; + dec(tmp2, 2*PixelSize); //move 2 backwards, because j-loop moved 1 forward + end; + end else + aStream.Read(tmp1^, LineSize); + inc(Counter.Y.low, Counter.Y.dir); //move to next line index + end; + finally + if Assigned(buf) then + FreeMem(buf); end; - end else begin - SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method end; -end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); -begin - Create; - LoadFromFunc(aSize, aFunc, aFormat, aArgs); -end; + //////////////////////////////////////////////////////////////////////////////////////// + procedure ReadCompressed; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar); -begin - Create; - LoadFromResource(aInstance, aResource, aResType); -end; + ///////////////////////////////////////////////////////////////// + var + TmpData: System.PByte; + LinePixelsRead: Integer; + procedure CheckLine; + begin + if (LinePixelsRead >= Header.Width) then begin + LinePixelsRead := 0; + inc(Counter.Y.low, Counter.Y.dir); //next line index + TmpData := ImageData; + inc(TmpData, Counter.Y.low * LineSize); //set line + if (Counter.X.dir < 0) then //if x flipped then + inc(TmpData, LineSize - PixelSize); //set last pixel + end; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TglBitmap.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); -begin - Create; - LoadFromResourceID(aInstance, aResourceID, aResType); -end; + ///////////////////////////////////////////////////////////////// + var + Cache: PByte; + CacheSize, CachePos: Integer; + procedure CachedRead(out Buffer; Count: Integer); + var + BytesRead: Integer; + begin + if (CachePos + Count > CacheSize) then begin + //if buffer overflow save non read bytes + BytesRead := 0; + if (CacheSize - CachePos > 0) then begin + BytesRead := CacheSize - CachePos; + Move(PByteArray(Cache)^[CachePos], Buffer{%H-}, BytesRead); + inc(CachePos, BytesRead); + end; -{$IFDEF GLB_SUPPORT_PNG_READ} -{$IF DEFINED(GLB_LAZ_PNG)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//PNG///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadPNG(const aStream: TStream): Boolean; -const - MAGIC_LEN = 8; - PNG_MAGIC: String[MAGIC_LEN] = #$89#$50#$4E#$47#$0D#$0A#$1A#$0A; -var - reader: TLazReaderPNG; - intf: TLazIntfImage; - StreamPos: Int64; - magic: String[MAGIC_LEN]; -begin - result := true; - StreamPos := aStream.Position; + //load cache from file + CacheSize := Min(CACHE_SIZE, aStream.Size - aStream.Position); + aStream.Read(Cache^, CacheSize); + CachePos := 0; - SetLength(magic, MAGIC_LEN); - aStream.Read(magic[1], MAGIC_LEN); - aStream.Position := StreamPos; - if (magic <> PNG_MAGIC) then begin - result := false; - exit; - end; + //read rest of requested bytes + if (Count - BytesRead > 0) then begin + Move(PByteArray(Cache)^[CachePos], TByteArray(Buffer)[BytesRead], Count - BytesRead); + inc(CachePos, Count - BytesRead); + end; + end else begin + //if no buffer overflow just read the data + Move(PByteArray(Cache)^[CachePos], Buffer, Count); + inc(CachePos, Count); + end; + end; - intf := TLazIntfImage.Create(0, 0); - reader := TLazReaderPNG.Create; - try try - reader.UpdateDescription := true; - reader.ImageRead(aStream, intf); - AssignFromLazIntfImage(intf); - except - result := false; - aStream.Position := StreamPos; - exit; + procedure PixelToBuffer(const aData: PByte; var aBuffer: PByte); + begin + case PixelSize of + 1: begin + aBuffer^ := aData^; + inc(aBuffer, Counter.X.dir); + end; + 2: begin + PWord(aBuffer)^ := PWord(aData)^; + inc(aBuffer, 2 * Counter.X.dir); + end; + 3: begin + PByteArray(aBuffer)^[0] := PByteArray(aData)^[0]; + PByteArray(aBuffer)^[1] := PByteArray(aData)^[1]; + PByteArray(aBuffer)^[2] := PByteArray(aData)^[2]; + inc(aBuffer, 3 * Counter.X.dir); + end; + 4: begin + PCardinal(aBuffer)^ := PCardinal(aData)^; + inc(aBuffer, 4 * Counter.X.dir); + end; + end; + end; + + var + TotalPixelsToRead, TotalPixelsRead: Integer; + Temp: Byte; + buf: array [0..3] of Byte; //1 pixel is max 32bit long + PixelRepeat: Boolean; + PixelsToRead, PixelCount: Integer; + begin + CacheSize := 0; + CachePos := 0; + + TotalPixelsToRead := Header.Width * Header.Height; + TotalPixelsRead := 0; + LinePixelsRead := 0; + + GetMem(Cache, CACHE_SIZE); + try + TmpData := ImageData; + inc(TmpData, Counter.Y.low * LineSize); //set line + if (Counter.X.dir < 0) then //if x flipped then + inc(TmpData, LineSize - PixelSize); //set last pixel + + repeat + //read CommandByte + CachedRead(Temp, 1); + PixelRepeat := (Temp and $80) > 0; + PixelsToRead := (Temp and $7F) + 1; + inc(TotalPixelsRead, PixelsToRead); + + if PixelRepeat then + CachedRead(buf[0], PixelSize); + while (PixelsToRead > 0) do begin + CheckLine; + PixelCount := Min(Header.Width - LinePixelsRead, PixelsToRead); //max read to EOL or EOF + while (PixelCount > 0) do begin + if not PixelRepeat then + CachedRead(buf[0], PixelSize); + PixelToBuffer(@buf[0], TmpData); + inc(LinePixelsRead); + dec(PixelsToRead); + dec(PixelCount); + end; + end; + until (TotalPixelsRead >= TotalPixelsToRead); + finally + FreeMem(Cache); + end; end; - finally - reader.Free; - intf.Free; + + function IsGrayFormat: Boolean; + begin + result := Header.ImageType in [TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_GRAY]; end; -end; -{$ELSEIF DEFINED(GLB_SDL_IMAGE)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadPNG(const aStream: TStream): Boolean; -var - Surface: PSDL_Surface; - RWops: PSDL_RWops; begin result := false; - RWops := glBitmapCreateRWops(aStream); - try - if IMG_isPNG(RWops) > 0 then begin - Surface := IMG_LoadPNG_RW(RWops); + + // reading header to test file and set cursor back to begin + StartPosition := aStream.Position; + aStream.Read(Header{%H-}, SizeOf(Header)); + + // no colormapped files + if (Header.ColorMapType = TGA_NONE_COLOR_TABLE) and (Header.ImageType in [ + TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY]) then + begin + try + if Header.ImageID <> 0 then // skip image ID + aStream.Position := aStream.Position + Header.ImageID; + + tgaFormat := tfEmpty; + case Header.Bpp of + 8: if IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfLuminance8ub1; + 8: tgaFormat := tfAlpha8ub1; + end; + + 16: if IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfLuminance16us1; + 8: tgaFormat := tfLuminance8Alpha8ub2; + end else case (Header.ImageDesc and $F) of + 0: tgaFormat := tfX1RGB5us1; + 1: tgaFormat := tfA1RGB5us1; + 4: tgaFormat := tfARGB4us1; + end; + + 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfBGR8ub3; + end; + + 32: if IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfDepth32ui1; + end else case (Header.ImageDesc and $F) of + 0: tgaFormat := tfX2RGB10ui1; + 2: tgaFormat := tfA2RGB10ui1; + 8: tgaFormat := tfARGB8ui1; + end; + end; + + if (tgaFormat = tfEmpty) then + raise EglBitmap.Create('LoadTga - unsupported format'); + + FormatDesc := TFormatDescriptor.Get(tgaFormat); + PixelSize := FormatDesc.GetSize(1, 1); + LineSize := FormatDesc.GetSize(Header.Width, 1); + + GetMem(ImageData, LineSize * Header.Height); try - AssignFromSurface(Surface); + //column direction + if ((Header.ImageDesc and (1 shl 4)) > 0) then begin + Counter.X.low := Header.Height-1;; + Counter.X.high := 0; + Counter.X.dir := -1; + end else begin + Counter.X.low := 0; + Counter.X.high := Header.Height-1; + Counter.X.dir := 1; + end; + + // Row direction + if ((Header.ImageDesc and (1 shl 5)) > 0) then begin + Counter.Y.low := 0; + Counter.Y.high := Header.Height-1; + Counter.Y.dir := 1; + end else begin + Counter.Y.low := Header.Height-1;; + Counter.Y.high := 0; + Counter.Y.dir := -1; + end; + + // Read Image + case Header.ImageType of + TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY: + ReadUncompressed; + TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY: + ReadCompressed; + end; + + SetData(ImageData, tgaFormat, Header.Width, Header.Height); result := true; - finally - SDL_FreeSurface(Surface); + except + if Assigned(ImageData) then + FreeMem(ImageData); + raise; end; + finally + aStream.Position := StartPosition; end; - finally - SDL_FreeRW(RWops); - end; -end; - -{$ELSEIF DEFINED(GLB_LIB_PNG)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmap_libPNG_read_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl; -begin - TStream(png_get_io_ptr(png)).Read(buffer^, size); + end + else aStream.Position := StartPosition; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadPNG(const aStream: TStream): Boolean; +procedure TglBitmapData.SaveTGA(const aStream: TStream); var - StreamPos: Int64; - signature: array [0..7] of byte; - png: png_structp; - png_info: png_infop; - - TempHeight, TempWidth: Integer; - Format: TglBitmapFormat; - - png_data: pByte; - png_rows: array of pByte; - Row, LineSize: Integer; + Header: TTGAHeader; + Size: Integer; + FormatDesc: TFormatDescriptor; begin - result := false; + if not (ftTGA in FormatGetSupportedFiles(Format)) then + raise EglBitmapUnsupportedFormat.Create(Format); - if not init_libPNG then - raise Exception.Create('LoadPNG - unable to initialize libPNG.'); + //prepare header + FormatDesc := TFormatDescriptor.Get(Format); + FillChar(Header{%H-}, SizeOf(Header), 0); + Header.ImageDesc := CountSetBits(FormatDesc.Range.a) and $F; + Header.Bpp := FormatDesc.BitsPerPixel; + Header.Width := Width; + Header.Height := Height; + Header.ImageDesc := Header.ImageDesc or $20; //flip y + if FormatDesc.IsGrayscale or (not FormatDesc.IsGrayscale and not FormatDesc.HasRed and FormatDesc.HasAlpha) then + Header.ImageType := TGA_UNCOMPRESSED_GRAY + else + Header.ImageType := TGA_UNCOMPRESSED_RGB; + aStream.Write(Header, SizeOf(Header)); - try - // signature - StreamPos := aStream.Position; - aStream.Read(signature{%H-}, 8); - aStream.Position := StreamPos; + // write Data + Size := FormatDesc.GetSize(Dimension); + aStream.Write(Data^, Size); +end; - if png_check_sig(@signature, 8) <> 0 then begin - // png read struct - png := png_create_read_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil); - if png = nil then - raise EglBitmapException.Create('LoadPng - couldn''t create read struct.'); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//DDS///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +const + DDS_MAGIC: Cardinal = $20534444; - // png info - png_info := png_create_info_struct(png); - if png_info = nil then begin - png_destroy_read_struct(@png, nil, nil); - raise EglBitmapException.Create('LoadPng - couldn''t create info struct.'); - end; + // DDS_header.dwFlags + DDSD_CAPS = $00000001; + DDSD_HEIGHT = $00000002; + DDSD_WIDTH = $00000004; + DDSD_PIXELFORMAT = $00001000; - // set read callback - png_set_read_fn(png, aStream, glBitmap_libPNG_read_func); + // DDS_header.sPixelFormat.dwFlags + DDPF_ALPHAPIXELS = $00000001; + DDPF_ALPHA = $00000002; + DDPF_FOURCC = $00000004; + DDPF_RGB = $00000040; + DDPF_LUMINANCE = $00020000; - // read informations - png_read_info(png, png_info); + // DDS_header.sCaps.dwCaps1 + DDSCAPS_TEXTURE = $00001000; - // size - TempHeight := png_get_image_height(png, png_info); - TempWidth := png_get_image_width(png, png_info); + // DDS_header.sCaps.dwCaps2 + DDSCAPS2_CUBEMAP = $00000200; - // format - case png_get_color_type(png, png_info) of - PNG_COLOR_TYPE_GRAY: - Format := tfLuminance8ub1; - PNG_COLOR_TYPE_GRAY_ALPHA: - Format := tfLuminance8Alpha8us1; - PNG_COLOR_TYPE_RGB: - Format := tfRGB8ub3; - PNG_COLOR_TYPE_RGB_ALPHA: - Format := tfRGBA8ub4; - else - raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); - end; + D3DFMT_DXT1 = $31545844; + D3DFMT_DXT3 = $33545844; + D3DFMT_DXT5 = $35545844; - // cut upper 8 bit from 16 bit formats - if png_get_bit_depth(png, png_info) > 8 then - png_set_strip_16(png); +type + TDDSPixelFormat = packed record + dwSize: Cardinal; + dwFlags: Cardinal; + dwFourCC: Cardinal; + dwRGBBitCount: Cardinal; + dwRBitMask: Cardinal; + dwGBitMask: Cardinal; + dwBBitMask: Cardinal; + dwABitMask: Cardinal; + end; - // expand bitdepth smaller than 8 - if png_get_bit_depth(png, png_info) < 8 then - png_set_expand(png); + TDDSCaps = packed record + dwCaps1: Cardinal; + dwCaps2: Cardinal; + dwDDSX: Cardinal; + dwReserved: Cardinal; + end; - // allocating mem for scanlines - LineSize := png_get_rowbytes(png, png_info); - GetMem(png_data, TempHeight * LineSize); - try - SetLength(png_rows, TempHeight); - for Row := Low(png_rows) to High(png_rows) do begin - png_rows[Row] := png_data; - Inc(png_rows[Row], Row * LineSize); - end; + TDDSHeader = packed record + dwSize: Cardinal; + dwFlags: Cardinal; + dwHeight: Cardinal; + dwWidth: Cardinal; + dwPitchOrLinearSize: Cardinal; + dwDepth: Cardinal; + dwMipMapCount: Cardinal; + dwReserved: array[0..10] of Cardinal; + PixelFormat: TDDSPixelFormat; + Caps: TDDSCaps; + dwReserved2: Cardinal; + end; - // read complete image into scanlines - png_read_image(png, @png_rows[0]); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.LoadDDS(const aStream: TStream): Boolean; +var + Header: TDDSHeader; + Converter: TbmpBitfieldFormat; - // read end - png_read_end(png, png_info); + function GetDDSFormat: TglBitmapFormat; + var + fd: TFormatDescriptor; + i: Integer; + Mask: TglBitmapRec4ul; + Range: TglBitmapRec4ui; + match: Boolean; + begin + result := tfEmpty; + with Header.PixelFormat do begin + // Compresses + if ((dwFlags and DDPF_FOURCC) > 0) then begin + case Header.PixelFormat.dwFourCC of + D3DFMT_DXT1: result := tfS3tcDtx1RGBA; + D3DFMT_DXT3: result := tfS3tcDtx3RGBA; + D3DFMT_DXT5: result := tfS3tcDtx5RGBA; + end; + end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE or DDPF_ALPHA)) > 0) then begin + // prepare masks + if ((dwFlags and DDPF_LUMINANCE) = 0) then begin + Mask.r := dwRBitMask; + Mask.g := dwGBitMask; + Mask.b := dwBBitMask; + end else begin + Mask.r := dwRBitMask; + Mask.g := dwRBitMask; + Mask.b := dwRBitMask; + end; + if (dwFlags and DDPF_ALPHAPIXELS > 0) then + Mask.a := dwABitMask + else + Mask.a := 0;; - // destroy read struct - png_destroy_read_struct(@png, @png_info, nil); + //find matching format + fd := TFormatDescriptor.GetFromMask(Mask, dwRGBBitCount); + result := fd.Format; + if (result <> tfEmpty) then + exit; - SetLength(png_rows, 0); + //find format with same Range + for i := 0 to 3 do + Range.arr[i] := (2 shl CountSetBits(Mask.arr[i])) - 1; + for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + fd := TFormatDescriptor.Get(result); + match := true; + for i := 0 to 3 do + if (fd.Range.arr[i] <> Range.arr[i]) then begin + match := false; + break; + end; + if match then + break; + end; - // set new data - SetDataPointer(png_data, Format, TempWidth, TempHeight); //be careful, Data could be freed by this method + //no format with same range found -> use default + if (result = tfEmpty) then begin + if (dwABitMask > 0) then + result := tfRGBA8ui1 + else + result := tfRGB8ub3; + end; - result := true; - except - if Assigned(png_data) then - FreeMem(png_data); - raise; + Converter := TbmpBitfieldFormat.Create; + Converter.SetCustomValues(dwRGBBitCount, glBitmapRec4ul(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask)); end; end; - finally - quit_libPNG; end; -end; -{$ELSEIF DEFINED(GLB_PNGIMAGE)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadPNG(const aStream: TStream): Boolean; var StreamPos: Int64; - Png: TPNGObject; - Header: String[8]; - Row, Col, PixSize, LineSize: Integer; - NewImage, pSource, pDest, pAlpha: pByte; - PngFormat: TglBitmapFormat; + x, y, LineSize, RowSize, Magic: Cardinal; + NewImage, TmpData, RowData, SrcData: System.PByte; + SourceMD, DestMD: Pointer; + Pixel: TglBitmapPixelData; + ddsFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; -const - PngHeader: String[8] = #137#80#78#71#13#10#26#10; - begin - result := false; - + result := false; + Converter := nil; StreamPos := aStream.Position; - aStream.Read(Header[0], SizeOf(Header)); - aStream.Position := StreamPos; - - {Test if the header matches} - if Header = PngHeader then begin - Png := TPNGObject.Create; - try - Png.LoadFromStream(aStream); - - case Png.Header.ColorType of - COLOR_GRAYSCALE: - PngFormat := tfLuminance8ub1; - COLOR_GRAYSCALEALPHA: - PngFormat := tfLuminance8Alpha8us1; - COLOR_RGB: - PngFormat := tfBGR8ub3; - COLOR_RGBALPHA: - PngFormat := tfBGRA8ub4; - else - raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); - end; - FormatDesc := TFormatDescriptor.Get(PngFormat); - PixSize := Round(FormatDesc.PixelSize); - LineSize := FormatDesc.GetSize(Png.Header.Width, 1); + // Magic + aStream.Read(Magic{%H-}, sizeof(Magic)); + if (Magic <> DDS_MAGIC) then begin + aStream.Position := StreamPos; + exit; + end; - GetMem(NewImage, LineSize * Integer(Png.Header.Height)); - try - pDest := NewImage; + //Header + aStream.Read(Header{%H-}, sizeof(Header)); + if (Header.dwSize <> SizeOf(Header)) or + ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <> + (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then + begin + aStream.Position := StreamPos; + exit; + end; - case Png.Header.ColorType of - COLOR_RGB, COLOR_GRAYSCALE: - begin - for Row := 0 to Png.Height -1 do begin - Move (Png.Scanline[Row]^, pDest^, LineSize); - Inc(pDest, LineSize); - end; - end; - COLOR_RGBALPHA, COLOR_GRAYSCALEALPHA: - begin - PixSize := PixSize -1; + if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then + raise EglBitmap.Create('LoadDDS - CubeMaps are not supported'); - for Row := 0 to Png.Height -1 do begin - pSource := Png.Scanline[Row]; - pAlpha := pByte(Png.AlphaScanline[Row]); + ddsFormat := GetDDSFormat; + try + if (ddsFormat = tfEmpty) then + raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); - for Col := 0 to Png.Width -1 do begin - Move (pSource^, pDest^, PixSize); - Inc(pSource, PixSize); - Inc(pDest, PixSize); + FormatDesc := TFormatDescriptor.Get(ddsFormat); + LineSize := Trunc(Header.dwWidth * FormatDesc.BytesPerPixel); + GetMem(NewImage, Header.dwHeight * LineSize); + try + TmpData := NewImage; - pDest^ := pAlpha^; - inc(pAlpha); - Inc(pDest); - end; - end; + //Converter needed + if Assigned(Converter) then begin + RowSize := Round(Header.dwWidth * Header.PixelFormat.dwRGBBitCount / 8); + GetMem(RowData, RowSize); + SourceMD := Converter.CreateMappingData; + DestMD := FormatDesc.CreateMappingData; + try + for y := 0 to Header.dwHeight-1 do begin + TmpData := NewImage; + inc(TmpData, y * LineSize); + SrcData := RowData; + aStream.Read(SrcData^, RowSize); + for x := 0 to Header.dwWidth-1 do begin + Converter.Unmap(SrcData, Pixel, SourceMD); + glBitmapConvertPixel(Pixel, Converter, FormatDesc); + FormatDesc.Map(Pixel, TmpData, DestMD); end; - else - raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); + end; + finally + Converter.FreeMappingData(SourceMD); + FormatDesc.FreeMappingData(DestMD); + FreeMem(RowData); end; + end else - SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); //be careful, Data could be freed by this method - - result := true; - except - if Assigned(NewImage) then - FreeMem(NewImage); - raise; - end; - finally - Png.Free; - end; - end; -end; -{$IFEND} -{$ENDIF} - -{$IFDEF GLB_SUPPORT_PNG_WRITE} -{$IFDEF GLB_LIB_PNG} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmap_libPNG_write_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl; -begin - TStream(png_get_io_ptr(png)).Write(buffer^, size); -end; -{$ENDIF} + // Compressed + if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin + RowSize := Header.dwPitchOrLinearSize div Header.dwWidth; + for Y := 0 to Header.dwHeight-1 do begin + aStream.Read(TmpData^, RowSize); + Inc(TmpData, LineSize); + end; + end else -{$IF DEFINED(GLB_LAZ_PNG)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SavePNG(const aStream: TStream); -var - png: TPortableNetworkGraphic; - intf: TLazIntfImage; - raw: TRawImage; -begin - png := TPortableNetworkGraphic.Create; - intf := TLazIntfImage.Create(0, 0); - try - if not AssignToLazIntfImage(intf) then - raise EglBitmap.Create('unable to create LazIntfImage from glBitmap'); - intf.GetRawImage(raw); - png.LoadFromRawImage(raw, false); - png.SaveToStream(aStream); + // Uncompressed + if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin + RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3; + for Y := 0 to Header.dwHeight-1 do begin + aStream.Read(TmpData^, RowSize); + Inc(TmpData, LineSize); + end; + end else + raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); + + SetData(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); + result := true; + except + if Assigned(NewImage) then + FreeMem(NewImage); + raise; + end; finally - png.Free; - intf.Free; + FreeAndNil(Converter); end; end; -{$ELSEIF DEFINED(GLB_LIB_PNG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SavePNG(const aStream: TStream); +procedure TglBitmapData.SaveDDS(const aStream: TStream); var - png: png_structp; - png_info: png_infop; - png_rows: array of pByte; - LineSize: Integer; - ColorType: Integer; - Row: Integer; + Header: TDDSHeader; FormatDesc: TFormatDescriptor; begin - if not (ftPNG in FormatGetSupportedFiles(Format)) then + if not (ftDDS in FormatGetSupportedFiles(Format)) then raise EglBitmapUnsupportedFormat.Create(Format); - if not init_libPNG then - raise Exception.Create('unable to initialize libPNG.'); - - try - case Format of - tfAlpha8ub1, tfLuminance8ub1: - ColorType := PNG_COLOR_TYPE_GRAY; - tfLuminance8Alpha8us1: - ColorType := PNG_COLOR_TYPE_GRAY_ALPHA; - tfBGR8ub3, tfRGB8ub3: - ColorType := PNG_COLOR_TYPE_RGB; - tfBGRA8ub4, tfRGBA8ub4: - ColorType := PNG_COLOR_TYPE_RGBA; - else - raise EglBitmapUnsupportedFormat.Create(Format); - end; - - FormatDesc := TFormatDescriptor.Get(Format); - LineSize := FormatDesc.GetSize(Width, 1); + FormatDesc := TFormatDescriptor.Get(Format); - // creating array for scanline - SetLength(png_rows, Height); - try - for Row := 0 to Height - 1 do begin - png_rows[Row] := Data; - Inc(png_rows[Row], Row * LineSize) - end; + // Generell + FillChar(Header{%H-}, SizeOf(Header), 0); + Header.dwSize := SizeOf(Header); + Header.dwFlags := DDSD_WIDTH or DDSD_HEIGHT or DDSD_CAPS or DDSD_PIXELFORMAT; - // write struct - png := png_create_write_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil); - if png = nil then - raise EglBitmapException.Create('SavePng - couldn''t create write struct.'); + Header.dwWidth := Max(1, Width); + Header.dwHeight := Max(1, Height); - // create png info - png_info := png_create_info_struct(png); - if png_info = nil then begin - png_destroy_write_struct(@png, nil); - raise EglBitmapException.Create('SavePng - couldn''t create info struct.'); - end; + // Caps + Header.Caps.dwCaps1 := DDSCAPS_TEXTURE; - // set read callback - png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil); + // Pixelformat + Header.PixelFormat.dwSize := sizeof(Header); + if (FormatDesc.IsCompressed) then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_FOURCC; + case Format of + tfS3tcDtx1RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT1; + tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3; + tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5; + end; + end else if not FormatDesc.HasColor and FormatDesc.HasAlpha then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; + end else if FormatDesc.IsGrayscale then begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; + end else begin + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; + Header.PixelFormat.dwGBitMask := FormatDesc.Mask.g; + Header.PixelFormat.dwBBitMask := FormatDesc.Mask.b; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; + end; - // set compression - png_set_compression_level(png, 6); + if (FormatDesc.HasAlpha) then + Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS; - if Format in [tfBGR8ub3, tfBGRA8ub4] then - png_set_bgr(png); + aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC)); + aStream.Write(Header, SizeOf(Header)); + aStream.Write(Data^, FormatDesc.GetSize(Dimension)); +end; - png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); - png_write_info(png, png_info); - png_write_image(png, @png_rows[0]); - png_write_end(png, png_info); - png_destroy_write_struct(@png, @png_info); - finally - SetLength(png_rows, 0); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.FlipHorz: Boolean; +var + fd: TglBitmapFormatDescriptor; + Col, RowSize, PixelSize: Integer; + pTempDest, pDest, pSource: PByte; +begin + result := false; + fd := FormatDescriptor; + PixelSize := Ceil(fd.BytesPerPixel); + RowSize := fd.GetSize(Width, 1); + if Assigned(Data) and not fd.IsCompressed then begin + pSource := Data; + GetMem(pDest, RowSize); + try + pTempDest := pDest; + Inc(pTempDest, RowSize); + for Col := 0 to Width-1 do begin + dec(pTempDest, PixelSize); //dec before, because ptr is behind last byte of data + Move(pSource^, pTempDest^, PixelSize); + Inc(pSource, PixelSize); + end; + SetData(pDest, Format, Width); + result := true; + except + if Assigned(pDest) then + FreeMem(pDest); + raise; end; - finally - quit_libPNG; end; end; -{$ELSEIF DEFINED(GLB_PNGIMAGE)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SavePNG(const aStream: TStream); +function TglBitmapData.FlipVert: Boolean; var - Png: TPNGObject; - - pSource, pDest: pByte; - X, Y, PixSize: Integer; - ColorType: Cardinal; - Alpha: Boolean; - - pTemp: pByte; - Temp: Byte; + fd: TglBitmapFormatDescriptor; + Row, RowSize, PixelSize: Integer; + TempDestData, DestData, SourceData: PByte; begin - if not (ftPNG in FormatGetSupportedFiles (Format)) then - raise EglBitmapUnsupportedFormat.Create(Format); - - case Format of - tfAlpha8ub1, tfLuminance8ub1: begin - ColorType := COLOR_GRAYSCALE; - PixSize := 1; - Alpha := false; - end; - tfLuminance8Alpha8us1: begin - ColorType := COLOR_GRAYSCALEALPHA; - PixSize := 1; - Alpha := true; - end; - tfBGR8ub3, tfRGB8ub3: begin - ColorType := COLOR_RGB; - PixSize := 3; - Alpha := false; - end; - tfBGRA8ub4, tfRGBA8ub4: begin - ColorType := COLOR_RGBALPHA; - PixSize := 3; - Alpha := true + result := false; + fd := FormatDescriptor; + PixelSize := Ceil(fd.BytesPerPixel); + RowSize := fd.GetSize(Width, 1); + if Assigned(Data) then begin + SourceData := Data; + GetMem(DestData, Height * RowSize); + try + TempDestData := DestData; + Inc(TempDestData, Width * (Height -1) * PixelSize); + for Row := 0 to Height -1 do begin + Move(SourceData^, TempDestData^, RowSize); + Dec(TempDestData, RowSize); + Inc(SourceData, RowSize); + end; + SetData(DestData, Format, Width, Height); + result := true; + except + if Assigned(DestData) then + FreeMem(DestData); + raise; end; - else - raise EglBitmapUnsupportedFormat.Create(Format); end; +end; - Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.LoadFromFile(const aFilename: String); +var + fs: TFileStream; +begin + if not FileExists(aFilename) then + raise EglBitmap.Create('file does not exist: ' + aFilename); + fs := TFileStream.Create(aFilename, fmOpenRead); try - // Copy ImageData - pSource := Data; - for Y := 0 to Height -1 do begin - pDest := png.ScanLine[Y]; - for X := 0 to Width -1 do begin - Move(pSource^, pDest^, PixSize); - Inc(pDest, PixSize); - Inc(pSource, PixSize); - if Alpha then begin - png.AlphaScanline[Y]^[X] := pSource^; - Inc(pSource); - end; - end; - - // convert RGB line to BGR - if Format in [tfRGB8ub3, tfRGBA8ub4] then begin - pTemp := png.ScanLine[Y]; - for X := 0 to Width -1 do begin - Temp := pByteArray(pTemp)^[0]; - pByteArray(pTemp)^[0] := pByteArray(pTemp)^[2]; - pByteArray(pTemp)^[2] := Temp; - Inc(pTemp, 3); - end; - end; - end; - - // Save to Stream - Png.CompressionLevel := 6; - Png.SaveToStream(aStream); + fs.Position := 0; + LoadFromStream(fs); + fFilename := aFilename; finally - FreeAndNil(Png); + fs.Free; end; end; -{$IFEND} -{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//JPEG//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -{$IFDEF GLB_LIB_JPEG} -type - glBitmap_libJPEG_source_mgr_ptr = ^glBitmap_libJPEG_source_mgr; - glBitmap_libJPEG_source_mgr = record - pub: jpeg_source_mgr; - - SrcStream: TStream; - SrcBuffer: array [1..4096] of byte; - end; - - glBitmap_libJPEG_dest_mgr_ptr = ^glBitmap_libJPEG_dest_mgr; - glBitmap_libJPEG_dest_mgr = record - pub: jpeg_destination_mgr; +procedure TglBitmapData.LoadFromStream(const aStream: TStream); +begin + {$IFDEF GLB_SUPPORT_PNG_READ} + if not LoadPNG(aStream) then + {$ENDIF} + {$IFDEF GLB_SUPPORT_JPEG_READ} + if not LoadJPEG(aStream) then + {$ENDIF} + if not LoadDDS(aStream) then + if not LoadTGA(aStream) then + if not LoadBMP(aStream) then + if not LoadRAW(aStream) then + raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.'); +end; - DestStream: TStream; - DestBuffer: array [1..4096] of byte; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.LoadFromFunc(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; + const aFunc: TglBitmapFunction; const aArgs: Pointer); +var + tmpData: PByte; + size: Integer; +begin + size := TFormatDescriptor.Get(aFormat).GetSize(aSize); + GetMem(tmpData, size); + try + FillChar(tmpData^, size, #$FF); + SetData(tmpData, aFormat, aSize.X, aSize.Y); + except + if Assigned(tmpData) then + FreeMem(tmpData); + raise; end; + Convert(Self, aFunc, false, aFormat, aArgs); +end; -procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar); +var + rs: TResourceStream; begin - //DUMMY + PrepareResType(aResource, aResType); + rs := TResourceStream.Create(aInstance, aResource, aResType); + try + LoadFromStream(rs); + finally + rs.Free; + end; end; - -procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); +var + rs: TResourceStream; begin - //DUMMY + rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); + try + LoadFromStream(rs); + finally + rs.Free; + end; end; - -procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType); +var + fs: TFileStream; begin - //DUMMY + fs := TFileStream.Create(aFileName, fmCreate); + try + fs.Position := 0; + SaveToStream(fs, aFileType); + finally + fs.Free; + end; end; -procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); begin - //DUMMY + case aFileType of + {$IFDEF GLB_SUPPORT_PNG_WRITE} + ftPNG: SavePNG(aStream); + {$ENDIF} + {$IFDEF GLB_SUPPORT_JPEG_WRITE} + ftJPEG: SaveJPEG(aStream); + {$ENDIF} + ftDDS: SaveDDS(aStream); + ftTGA: SaveTGA(aStream); + ftBMP: SaveBMP(aStream); + ftRAW: SaveRAW(aStream); + end; end; - -procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean; begin - //DUMMY + result := Convert(Self, aFunc, aCreateTemp, Format, aArgs); end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl; +function TglBitmapData.Convert(const aSource: TglBitmapData; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; + const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean; var - src: glBitmap_libJPEG_source_mgr_ptr; - bytes: integer; + DestData, TmpData, SourceData: pByte; + TempHeight, TempWidth: Integer; + SourceFD, DestFD: TFormatDescriptor; + SourceMD, DestMD: Pointer; + + FuncRec: TglBitmapFunctionRec; begin - src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src); + Assert(Assigned(Data)); + Assert(Assigned(aSource)); + Assert(Assigned(aSource.Data)); - bytes := src^.SrcStream.Read(src^.SrcBuffer[1], 4096); - if (bytes <= 0) then begin - src^.SrcBuffer[1] := $FF; - src^.SrcBuffer[2] := JPEG_EOI; - bytes := 2; - end; + result := false; + if Assigned(aSource.Data) and ((aSource.Height > 0) or (aSource.Width > 0)) then begin + SourceFD := TFormatDescriptor.Get(aSource.Format); + DestFD := TFormatDescriptor.Get(aFormat); - src^.pub.next_input_byte := @(src^.SrcBuffer[1]); - src^.pub.bytes_in_buffer := bytes; + if (SourceFD.IsCompressed) then + raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format); + if (DestFD.IsCompressed) then + raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format); - result := true; -end; + // inkompatible Formats so CreateTemp + if (SourceFD.BitsPerPixel <> DestFD.BitsPerPixel) then + aCreateTemp := true; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmap_libJPEG_skip_input_data(cinfo: j_decompress_ptr; num_bytes: Longint); cdecl; -var - src: glBitmap_libJPEG_source_mgr_ptr; -begin - src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src); + // Values + TempHeight := Max(1, aSource.Height); + TempWidth := Max(1, aSource.Width); - if num_bytes > 0 then begin - // wanted byte isn't in buffer so set stream position and read buffer - if num_bytes > src^.pub.bytes_in_buffer then begin - src^.SrcStream.Position := src^.SrcStream.Position + num_bytes - src^.pub.bytes_in_buffer; - src^.pub.fill_input_buffer(cinfo); - end else begin - // wanted byte is in buffer so only skip - inc(src^.pub.next_input_byte, num_bytes); - dec(src^.pub.bytes_in_buffer, num_bytes); - end; - end; -end; + FuncRec.Sender := Self; + FuncRec.Args := aArgs; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl; -var - dest: glBitmap_libJPEG_dest_mgr_ptr; -begin - dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest); + TmpData := nil; + if aCreateTemp then begin + GetMem(TmpData, DestFD.GetSize(TempWidth, TempHeight)); + DestData := TmpData; + end else + DestData := Data; - if dest^.pub.free_in_buffer < Cardinal(Length(dest^.DestBuffer)) then begin - // write complete buffer - dest^.DestStream.Write(dest^.DestBuffer[1], SizeOf(dest^.DestBuffer)); + try + SourceFD.PreparePixel(FuncRec.Source); + DestFD.PreparePixel (FuncRec.Dest); - // reset buffer - dest^.pub.next_output_byte := @dest^.DestBuffer[1]; - dest^.pub.free_in_buffer := Length(dest^.DestBuffer); - end; + SourceMD := SourceFD.CreateMappingData; + DestMD := DestFD.CreateMappingData; - result := true; -end; + FuncRec.Size := aSource.Dimension; + FuncRec.Position.Fields := FuncRec.Size.Fields; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmap_libJPEG_term_destination(cinfo: j_compress_ptr); cdecl; -var - Idx: Integer; - dest: glBitmap_libJPEG_dest_mgr_ptr; -begin - dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest); + try + SourceData := aSource.Data; + FuncRec.Position.Y := 0; + while FuncRec.Position.Y < TempHeight do begin + FuncRec.Position.X := 0; + while FuncRec.Position.X < TempWidth do begin + SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD); + aFunc(FuncRec); + DestFD.Map(FuncRec.Dest, DestData, DestMD); + inc(FuncRec.Position.X); + end; + inc(FuncRec.Position.Y); + end; - for Idx := Low(dest^.DestBuffer) to High(dest^.DestBuffer) do begin - // check for endblock - if (Idx < High(dest^.DestBuffer)) and (dest^.DestBuffer[Idx] = $FF) and (dest^.DestBuffer[Idx +1] = JPEG_EOI) then begin - // write endblock - dest^.DestStream.Write(dest^.DestBuffer[Idx], 2); + // Updating Image or InternalFormat + if aCreateTemp then + SetData(TmpData, aFormat, aSource.Width, aSource.Height) + else if (aFormat <> fFormat) then + Format := aFormat; - // leave - break; - end else - dest^.DestStream.Write(dest^.DestBuffer[Idx], 1); + result := true; + finally + SourceFD.FreeMappingData(SourceMD); + DestFD.FreeMappingData(DestMD); + end; + except + if aCreateTemp and Assigned(TmpData) then + FreeMem(TmpData); + raise; + end; end; end; -{$ENDIF} -{$IFDEF GLB_SUPPORT_JPEG_READ} -{$IF DEFINED(GLB_LAZ_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadJPEG(const aStream: TStream): Boolean; -const - MAGIC_LEN = 2; - JPEG_MAGIC: String[MAGIC_LEN] = #$FF#$D8; +function TglBitmapData.ConvertTo(const aFormat: TglBitmapFormat): Boolean; var - intf: TLazIntfImage; - reader: TFPReaderJPEG; - StreamPos: Int64; - magic: String[MAGIC_LEN]; -begin - result := true; - StreamPos := aStream.Position; + SourceFD, DestFD: TFormatDescriptor; + SourcePD, DestPD: TglBitmapPixelData; + ShiftData: TShiftData; - SetLength(magic, MAGIC_LEN); - aStream.Read(magic[1], MAGIC_LEN); - aStream.Position := StreamPos; - if (magic <> JPEG_MAGIC) then begin - result := false; - exit; + function DataIsIdentical: Boolean; + begin + result := SourceFD.MaskMatch(DestFD.Mask); end; - reader := TFPReaderJPEG.Create; - intf := TLazIntfImage.Create(0, 0); - try try - intf.DataDescription := GetDescriptionFromDevice(0, 0, 0); - reader.ImageRead(aStream, intf); - AssignFromLazIntfImage(intf); - except - result := false; - aStream.Position := StreamPos; - exit; + function CanCopyDirect: Boolean; + begin + result := + ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and + ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and + ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and + ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); end; - finally - reader.Free; - intf.Free; + + function CanShift: Boolean; + begin + result := + ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and + ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and + ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and + ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0)); + end; + + function GetShift(aSource, aDest: Cardinal) : ShortInt; + begin + result := 0; + while (aSource > aDest) and (aSource > 0) do begin + inc(result); + aSource := aSource shr 1; + end; end; -end; -{$ELSEIF DEFINED(GLB_SDL_IMAGE)} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadJPEG(const aStream: TStream): Boolean; -var - Surface: PSDL_Surface; - RWops: PSDL_RWops; begin - result := false; + if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin + SourceFD := TFormatDescriptor.Get(Format); + DestFD := TFormatDescriptor.Get(aFormat); - RWops := glBitmapCreateRWops(aStream); - try - if IMG_isJPG(RWops) > 0 then begin - Surface := IMG_LoadJPG_RW(RWops); - try - AssignFromSurface(Surface); - result := true; - finally - SDL_FreeSurface(Surface); - end; + if DataIsIdentical then begin + result := true; + Format := aFormat; + exit; end; - finally - SDL_FreeRW(RWops); - end; + + SourceFD.PreparePixel(SourcePD); + DestFD.PreparePixel (DestPD); + + if CanCopyDirect then + result := Convert(Self, glBitmapConvertCopyFunc, false, aFormat) + else if CanShift then begin + ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r); + ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g); + ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b); + ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a); + result := Convert(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData); + end else + result := Convert(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat); + end else + result := true; end; -{$ELSEIF DEFINED(GLB_LIB_JPEG)} +{$IFDEF GLB_SDL} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadJPEG(const aStream: TStream): Boolean; +function TglBitmapData.AssignToSurface(out aSurface: PSDL_Surface): Boolean; var - StreamPos: Int64; - Temp: array[0..1]of Byte; - - jpeg: jpeg_decompress_struct; - jpeg_err: jpeg_error_mgr; - - IntFormat: TglBitmapFormat; - pImage: pByte; - TempHeight, TempWidth: Integer; + Row, RowSize: Integer; + SourceData, TmpData: PByte; + TempDepth: Integer; + FormatDesc: TFormatDescriptor; - pTemp: pByte; - Row: Integer; + function GetRowPointer(Row: Integer): pByte; + begin + result := aSurface.pixels; + Inc(result, Row * RowSize); + end; - FormatDesc: TFormatDescriptor; begin result := false; - if not init_libJPEG then - raise Exception.Create('LoadJPG - unable to initialize libJPEG.'); - - try - // reading first two bytes to test file and set cursor back to begin - StreamPos := aStream.Position; - aStream.Read({%H-}Temp[0], 2); - aStream.Position := StreamPos; - - // if Bitmap then read file. - if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin - FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00); - FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); - - // error managment - jpeg.err := jpeg_std_error(@jpeg_err); - jpeg_err.error_exit := glBitmap_libJPEG_error_exit; - jpeg_err.output_message := glBitmap_libJPEG_output_message; - - // decompression struct - jpeg_create_decompress(@jpeg); - - // allocation space for streaming methods - jpeg.src := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_source_mgr)); - - // seeting up custom functions - with glBitmap_libJPEG_source_mgr_ptr(jpeg.src)^ do begin - pub.init_source := glBitmap_libJPEG_init_source; - pub.fill_input_buffer := glBitmap_libJPEG_fill_input_buffer; - pub.skip_input_data := glBitmap_libJPEG_skip_input_data; - pub.resync_to_restart := jpeg_resync_to_restart; // use default method - pub.term_source := glBitmap_libJPEG_term_source; - - pub.bytes_in_buffer := 0; // forces fill_input_buffer on first read - pub.next_input_byte := nil; // until buffer loaded - - SrcStream := aStream; - end; + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed then + raise EglBitmapUnsupportedFormat.Create(Format); - // set global decoding state - jpeg.global_state := DSTATE_START; + if Assigned(Data) then begin + case Trunc(FormatDesc.PixelSize) of + 1: TempDepth := 8; + 2: TempDepth := 16; + 3: TempDepth := 24; + 4: TempDepth := 32; + else + raise EglBitmapUnsupportedFormat.Create(Format); + end; - // read header of jpeg - jpeg_read_header(@jpeg, false); + aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth, + FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask); + SourceData := Data; + RowSize := FormatDesc.GetSize(FileWidth, 1); - // setting output parameter - case jpeg.jpeg_color_space of - JCS_GRAYSCALE: - begin - jpeg.out_color_space := JCS_GRAYSCALE; - IntFormat := tfLuminance8ub1; - end; - else - jpeg.out_color_space := JCS_RGB; - IntFormat := tfRGB8ub3; + for Row := 0 to FileHeight-1 do begin + TmpData := GetRowPointer(Row); + if Assigned(TmpData) then begin + Move(SourceData^, TmpData^, RowSize); + inc(SourceData, RowSize); end; + end; + result := true; + end; +end; - // reading image - jpeg_start_decompress(@jpeg); - - TempHeight := jpeg.output_height; - TempWidth := jpeg.output_width; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AssignFromSurface(const aSurface: PSDL_Surface): Boolean; +var + pSource, pData, pTempData: PByte; + Row, RowSize, TempWidth, TempHeight: Integer; + IntFormat: TglBitmapFormat; + fd: TFormatDescriptor; + Mask: TglBitmapMask; - FormatDesc := TFormatDescriptor.Get(IntFormat); + function GetRowPointer(Row: Integer): pByte; + begin + result := aSurface^.pixels; + Inc(result, Row * RowSize); + end; - // creating new image - GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight)); - try - pTemp := pImage; +begin + result := false; + if (Assigned(aSurface)) then begin + with aSurface^.format^ do begin + Mask.r := RMask; + Mask.g := GMask; + Mask.b := BMask; + Mask.a := AMask; + IntFormat := TFormatDescriptor.GetFromMask(Mask).Format; + if (IntFormat = tfEmpty) then + raise EglBitmap.Create('AssignFromSurface - Invalid Pixelformat.'); + end; - for Row := 0 to TempHeight -1 do begin - jpeg_read_scanlines(@jpeg, @pTemp, 1); - Inc(pTemp, FormatDesc.GetSize(TempWidth, 1)); + fd := TFormatDescriptor.Get(IntFormat); + TempWidth := aSurface^.w; + TempHeight := aSurface^.h; + RowSize := fd.GetSize(TempWidth, 1); + GetMem(pData, TempHeight * RowSize); + try + pTempData := pData; + for Row := 0 to TempHeight -1 do begin + pSource := GetRowPointer(Row); + if (Assigned(pSource)) then begin + Move(pSource^, pTempData^, RowSize); + Inc(pTempData, RowSize); end; - - // finish decompression - jpeg_finish_decompress(@jpeg); - - // destroy decompression - jpeg_destroy_decompress(@jpeg); - - SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method - - result := true; - except - if Assigned(pImage) then - FreeMem(pImage); - raise; end; + SetData(pData, IntFormat, TempWidth, TempHeight); + result := true; + except + if Assigned(pData) then + FreeMem(pData); + raise; end; - finally - quit_libJPEG; end; end; -{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadJPEG(const aStream: TStream): Boolean; +function TglBitmapData.AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean; var - bmp: TBitmap; - jpg: TJPEGImage; - StreamPos: Int64; - Temp: array[0..1]of Byte; + Row, Col, AlphaInterleave: Integer; + pSource, pDest: PByte; + + function GetRowPointer(Row: Integer): pByte; + begin + result := aSurface.pixels; + Inc(result, Row * Width); + end; + begin result := false; + if Assigned(Data) then begin + if Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfBGRA8ub4, tfRGBA8ub4] then begin + aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0); - // reading first two bytes to test file and set cursor back to begin - StreamPos := aStream.Position; - aStream.Read(Temp[0], 2); - aStream.Position := StreamPos; + AlphaInterleave := 0; + case Format of + tfLuminance8Alpha8ub2: + AlphaInterleave := 1; + tfBGRA8ub4, tfRGBA8ub4: + AlphaInterleave := 3; + end; - // if Bitmap then read file. - if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin - bmp := TBitmap.Create; - try - jpg := TJPEGImage.Create; - try - jpg.LoadFromStream(aStream); - bmp.Assign(jpg); - result := AssignFromBitmap(bmp); - finally - jpg.Free; + pSource := Data; + for Row := 0 to Height -1 do begin + pDest := GetRowPointer(Row); + if Assigned(pDest) then begin + for Col := 0 to Width -1 do begin + Inc(pSource, AlphaInterleave); + pDest^ := pSource^; + Inc(pDest); + Inc(pSource); + end; + end; end; - finally - bmp.Free; + result := true; end; end; end; -{$IFEND} -{$ENDIF} -{$IFDEF GLB_SUPPORT_JPEG_WRITE} -{$IF DEFINED(GLB_LAZ_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveJPEG(const aStream: TStream); +function TglBitmapData.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean; var - jpeg: TJPEGImage; - intf: TLazIntfImage; - raw: TRawImage; + bmp: TglBitmap2D; begin - jpeg := TJPEGImage.Create; - intf := TLazIntfImage.Create(0, 0); + bmp := TglBitmap2D.Create; try - if not AssignToLazIntfImage(intf) then - raise EglBitmap.Create('unable to create LazIntfImage from glBitmap'); - intf.GetRawImage(raw); - jpeg.LoadFromRawImage(raw, false); - jpeg.SaveToStream(aStream); + bmp.AssignFromSurface(aSurface); + result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs); finally - intf.Free; - jpeg.Free; + bmp.Free; end; end; +{$ENDIF} -{$ELSEIF DEFINED(GLB_LIB_JPEG)} +{$IFDEF GLB_DELPHI} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveJPEG(const aStream: TStream); +function CreateGrayPalette: HPALETTE; var - jpeg: jpeg_compress_struct; - jpeg_err: jpeg_error_mgr; - Row: Integer; - pTemp, pTemp2: pByte; - - procedure CopyRow(pDest, pSource: pByte); - var - X: Integer; - begin - for X := 0 to Width - 1 do begin - pByteArray(pDest)^[0] := pByteArray(pSource)^[2]; - pByteArray(pDest)^[1] := pByteArray(pSource)^[1]; - pByteArray(pDest)^[2] := pByteArray(pSource)^[0]; - Inc(pDest, 3); - Inc(pSource, 3); - end; - end; - + Idx: Integer; + Pal: PLogPalette; begin - if not (ftJPEG in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedFormat.Create(Format); - - if not init_libJPEG then - raise Exception.Create('SaveJPG - unable to initialize libJPEG.'); - - try - FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00); - FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00); - - // error managment - jpeg.err := jpeg_std_error(@jpeg_err); - jpeg_err.error_exit := glBitmap_libJPEG_error_exit; - jpeg_err.output_message := glBitmap_libJPEG_output_message; - - // compression struct - jpeg_create_compress(@jpeg); - - // allocation space for streaming methods - jpeg.dest := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_dest_mgr)); - - // seeting up custom functions - with glBitmap_libJPEG_dest_mgr_ptr(jpeg.dest)^ do begin - pub.init_destination := glBitmap_libJPEG_init_destination; - pub.empty_output_buffer := glBitmap_libJPEG_empty_output_buffer; - pub.term_destination := glBitmap_libJPEG_term_destination; - - pub.next_output_byte := @DestBuffer[1]; - pub.free_in_buffer := Length(DestBuffer); - - DestStream := aStream; - end; - - // very important state - jpeg.global_state := CSTATE_START; - jpeg.image_width := Width; - jpeg.image_height := Height; - case Format of - tfAlpha8ub1, tfLuminance8ub1: begin - jpeg.input_components := 1; - jpeg.in_color_space := JCS_GRAYSCALE; - end; - tfRGB8ub3, tfBGR8ub3: begin - jpeg.input_components := 3; - jpeg.in_color_space := JCS_RGB; - end; - end; - - jpeg_set_defaults(@jpeg); - jpeg_set_quality(@jpeg, 95, true); - jpeg_start_compress(@jpeg, true); - pTemp := Data; - - if Format = tfBGR8ub3 then - GetMem(pTemp2, fRowSize) - else - pTemp2 := pTemp; + GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256)); - try - for Row := 0 to jpeg.image_height -1 do begin - // prepare row - if Format = tfBGR8ub3 then - CopyRow(pTemp2, pTemp) - else - pTemp2 := pTemp; + Pal.palVersion := $300; + Pal.palNumEntries := 256; - // write row - jpeg_write_scanlines(@jpeg, @pTemp2, 1); - inc(pTemp, fRowSize); - end; - finally - // free memory - if Format = tfBGR8ub3 then - FreeMem(pTemp2); - end; - jpeg_finish_compress(@jpeg); - jpeg_destroy_compress(@jpeg); - finally - quit_libJPEG; + for Idx := 0 to Pal.palNumEntries - 1 do begin + Pal.palPalEntry[Idx].peRed := Idx; + Pal.palPalEntry[Idx].peGreen := Idx; + Pal.palPalEntry[Idx].peBlue := Idx; + Pal.palPalEntry[Idx].peFlags := 0; end; + Result := CreatePalette(Pal^); + FreeMem(Pal); end; -{$ELSEIF DEFINED(GLB_DELPHI_JPEG)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveJPEG(const aStream: TStream); +function TglBitmapData.AssignToBitmap(const aBitmap: TBitmap): Boolean; var - Bmp: TBitmap; - Jpg: TJPEGImage; + Row, RowSize: Integer; + pSource, pData: PByte; begin - if not (ftJPEG in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedFormat.Create(Format); + result := false; + if Assigned(Data) then begin + if Assigned(aBitmap) then begin + aBitmap.Width := Width; + aBitmap.Height := Height; - Bmp := TBitmap.Create; - try - Jpg := TJPEGImage.Create; - try - AssignToBitmap(Bmp); - if (Format in [tfAlpha8ub1, tfLuminance8ub1]) then begin - Jpg.Grayscale := true; - Jpg.PixelFormat := jf8Bit; + case Format of + tfAlpha8ub1, tfLuminance8ub1: begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + end; + tfRGB5A1us1: + aBitmap.PixelFormat := pf15bit; + tfR5G6B5us1: + aBitmap.PixelFormat := pf16bit; + tfRGB8ub3, tfBGR8ub3: + aBitmap.PixelFormat := pf24bit; + tfRGBA8ub4, tfBGRA8ub4: + aBitmap.PixelFormat := pf32bit; + else + raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.'); end; - Jpg.Assign(Bmp); - Jpg.SaveToStream(aStream); - finally - FreeAndNil(Jpg); + + RowSize := FormatDescriptor.GetSize(Width, 1); + pSource := Data; + for Row := 0 to Height-1 do begin + pData := aBitmap.Scanline[Row]; + Move(pSource^, pData^, RowSize); + Inc(pSource, RowSize); + if (Format in [tfRGB8ub3, tfRGBA8ub4]) then // swap RGB(A) to BGR(A) + SwapRGB(pData, Width, Format = tfRGBA8ub4); + end; + result := true; end; - finally - FreeAndNil(Bmp); end; end; -{$IFEND} -{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//RAW///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -type - RawHeader = packed record - Magic: String[5]; - Version: Byte; - Width: Integer; - Height: Integer; - DataSize: Integer; - BitsPerPixel: Integer; - Precision: TglBitmapRec4ub; - Shift: TglBitmapRec4ub; - end; - -function TglBitmap.LoadRAW(const aStream: TStream): Boolean; +function TglBitmapData.AssignFromBitmap(const aBitmap: TBitmap): Boolean; var - header: RawHeader; - StartPos: Int64; - fd: TFormatDescriptor; - buf: PByte; + pSource, pData, pTempData: PByte; + Row, RowSize, TempWidth, TempHeight: Integer; + IntFormat: TglBitmapFormat; begin result := false; - StartPos := aStream.Position; - aStream.Read(header{%H-}, SizeOf(header)); - if (header.Magic <> 'glBMP') then begin - aStream.Position := StartPos; - exit; - end; - - fd := TFormatDescriptor.GetFromPrecShift(header.Precision, header.Shift, header.BitsPerPixel); - if (fd.Format = tfEmpty) then - raise EglBitmapUnsupportedFormat.Create('no supported format found'); - buf := GetMemory(header.DataSize); - aStream.Read(buf^, header.DataSize); - SetDataPointer(buf, fd.Format, header.Width, header.Height); + if (Assigned(aBitmap)) then begin + case aBitmap.PixelFormat of + pf8bit: + IntFormat := tfLuminance8ub1; + pf15bit: + IntFormat := tfRGB5A1us1; + pf16bit: + IntFormat := tfR5G6B5us1; + pf24bit: + IntFormat := tfBGR8ub3; + pf32bit: + IntFormat := tfBGRA8ub4; + else + raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.'); + end; - result := true; + TempWidth := aBitmap.Width; + TempHeight := aBitmap.Height; + RowSize := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1); + GetMem(pData, TempHeight * RowSize); + try + pTempData := pData; + for Row := 0 to TempHeight -1 do begin + pSource := aBitmap.Scanline[Row]; + if (Assigned(pSource)) then begin + Move(pSource^, pTempData^, RowSize); + Inc(pTempData, RowSize); + end; + end; + SetData(pData, IntFormat, TempWidth, TempHeight); + result := true; + except + if Assigned(pData) then + FreeMem(pData); + raise; + end; + end; end; -procedure TglBitmap.SaveRAW(const aStream: TStream); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean; var - header: RawHeader; - fd: TFormatDescriptor; + Row, Col, AlphaInterleave: Integer; + pSource, pDest: PByte; begin - fd := TFormatDescriptor.Get(Format); - header.Magic := 'glBMP'; - header.Version := 1; - header.Width := Width; - header.Height := Height; - header.DataSize := fd.GetSize(fDimension); - header.BitsPerPixel := fd.BitsPerPixel; - header.Precision := fd.Precision; - header.Shift := fd.Shift; - aStream.Write(header, SizeOf(header)); - aStream.Write(Data^, header.DataSize); -end; + result := false; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//BMP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -const - BMP_MAGIC = $4D42; + if Assigned(Data) then begin + if (Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfRGBA8ub4, tfBGRA8ub4]) then begin + if Assigned(aBitmap) then begin + aBitmap.PixelFormat := pf8bit; + aBitmap.Palette := CreateGrayPalette; + aBitmap.Width := Width; + aBitmap.Height := Height; - BMP_COMP_RGB = 0; - BMP_COMP_RLE8 = 1; - BMP_COMP_RLE4 = 2; - BMP_COMP_BITFIELDS = 3; + case Format of + tfLuminance8Alpha8ub2: + AlphaInterleave := 1; + tfRGBA8ub4, tfBGRA8ub4: + AlphaInterleave := 3; + else + AlphaInterleave := 0; + end; -type - TBMPHeader = packed record - bfType: Word; - bfSize: Cardinal; - bfReserved1: Word; - bfReserved2: Word; - bfOffBits: Cardinal; + // Copy Data + pSource := Data; + + for Row := 0 to Height -1 do begin + pDest := aBitmap.Scanline[Row]; + if Assigned(pDest) then begin + for Col := 0 to Width -1 do begin + Inc(pSource, AlphaInterleave); + pDest^ := pSource^; + Inc(pDest); + Inc(pSource); + end; + end; + end; + result := true; + end; + end; end; +end; - TBMPInfo = packed record - biSize: Cardinal; - biWidth: Longint; - biHeight: Longint; - biPlanes: Word; - biBitCount: Word; - biCompression: Cardinal; - biSizeImage: Cardinal; - biXPelsPerMeter: Longint; - biYPelsPerMeter: Longint; - biClrUsed: Cardinal; - biClrImportant: Cardinal; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + data: TglBitmapData; +begin + data := TglBitmapData.Create; + try + data.AssignFromBitmap(aBitmap); + result := AddAlphaFromDataObj(data, aFunc, aArgs); + finally + data.Free; end; +end; +{$ENDIF} +{$IFDEF GLB_LAZARUS} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadBMP(const aStream: TStream): Boolean; +function TglBitmapData.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean; +var + rid: TRawImageDescription; + FormatDesc: TFormatDescriptor; +begin + if not Assigned(Data) then + raise EglBitmap.Create('no pixel data assigned. load data before save'); - ////////////////////////////////////////////////////////////////////////////////////////////////// - function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapRec4ul): TglBitmapFormat; - begin - result := tfEmpty; - aStream.Read(aInfo{%H-}, SizeOf(aInfo)); - FillChar(aMask{%H-}, SizeOf(aMask), 0); + result := false; + if not Assigned(aImage) or (Format = tfEmpty) then + exit; + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed then + exit; - //Read Compression - case aInfo.biCompression of - BMP_COMP_RLE4, - BMP_COMP_RLE8: begin - raise EglBitmap.Create('RLE compression is not supported'); - end; - BMP_COMP_BITFIELDS: begin - if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin - aStream.Read(aMask.r, SizeOf(aMask.r)); - aStream.Read(aMask.g, SizeOf(aMask.g)); - aStream.Read(aMask.b, SizeOf(aMask.b)); - aStream.Read(aMask.a, SizeOf(aMask.a)); - end else - raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats'); - end; - end; + FillChar(rid{%H-}, SizeOf(rid), 0); + if FormatDesc.IsGrayscale then + rid.Format := ricfGray + else + rid.Format := ricfRGBA; - //get suitable format - case aInfo.biBitCount of - 8: result := tfLuminance8ub1; - 16: result := tfX1RGB5us1; - 24: result := tfBGR8ub3; - 32: result := tfXRGB8ui1; - end; - end; + rid.Width := Width; + rid.Height := Height; + rid.Depth := FormatDesc.BitsPerPixel; + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := FormatDesc.BitsPerPixel; + rid.RedPrec := CountSetBits(FormatDesc.Range.r); + rid.GreenPrec := CountSetBits(FormatDesc.Range.g); + rid.BluePrec := CountSetBits(FormatDesc.Range.b); + rid.AlphaPrec := CountSetBits(FormatDesc.Range.a); + rid.RedShift := FormatDesc.Shift.r; + rid.GreenShift := FormatDesc.Shift.g; + rid.BlueShift := FormatDesc.Shift.b; + rid.AlphaShift := FormatDesc.Shift.a; - function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat; - var - i, c: Integer; - ColorTable: TbmpColorTable; - begin - result := nil; - if (aInfo.biBitCount >= 16) then - exit; - aFormat := tfLuminance8ub1; - c := aInfo.biClrUsed; - if (c = 0) then - c := 1 shl aInfo.biBitCount; - SetLength(ColorTable, c); - for i := 0 to c-1 do begin - aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty)); - if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then - aFormat := tfRGB8ub3; - end; + rid.MaskBitsPerPixel := 0; + rid.PaletteColorCount := 0; - result := TbmpColorTableFormat.Create; - result.BitsPerPixel := aInfo.biBitCount; - result.ColorTable := ColorTable; - result.CalcValues; - end; + aImage.DataDescription := rid; + aImage.CreateData; - ////////////////////////////////////////////////////////////////////////////////////////////////// - function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapRec4ul; const aInfo: TBMPInfo): TbmpBitfieldFormat; - var - FormatDesc: TFormatDescriptor; - begin - result := nil; - if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin - FormatDesc := TFormatDescriptor.GetFromMask(aMask); - if (FormatDesc.Format = tfEmpty) then - exit; - aFormat := FormatDesc.Format; - if (aMask.a = 0) and TFormatDescriptor.Get(aFormat).HasAlpha then - aFormat := TFormatDescriptor.Get(aFormat).WithoutAlpha; - if (aMask.a <> 0) and not TFormatDescriptor.Get(aFormat).HasAlpha then - aFormat := TFormatDescriptor.Get(aFormat).WithAlpha; + if not Assigned(aImage.PixelData) then + raise EglBitmap.Create('error while creating LazIntfImage'); + Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension)); - result := TbmpBitfieldFormat.Create; - result.SetCustomValues(aInfo.biBitCount, aMask); - end; - end; + result := true; +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean; var - //simple types - StartPos: Int64; - ImageSize, rbLineSize, wbLineSize, Padding, i: Integer; - PaddingBuff: Cardinal; - LineBuf, ImageData, TmpData: PByte; - SourceMD, DestMD: Pointer; - BmpFormat: TglBitmapFormat; - - //records - Mask: TglBitmapRec4ul; - Header: TBMPHeader; - Info: TBMPInfo; - - //classes - SpecialFormat: TFormatDescriptor; + f: TglBitmapFormat; FormatDesc: TFormatDescriptor; + ImageData: PByte; + ImageSize: Integer; + CanCopy: Boolean; + Mask: TglBitmapRec4ul; - ////////////////////////////////////////////////////////////////////////////////////////////////// - procedure SpecialFormatReadLine(aData: PByte; aLineBuf: PByte); + procedure CopyConvert; var - i: Integer; - Pixel: TglBitmapPixelData; + bfFormat: TbmpBitfieldFormat; + pSourceLine, pDestLine: PByte; + pSourceMD, pDestMD: Pointer; + Shift, Prec: TglBitmapRec4ub; + x, y: Integer; + pixel: TglBitmapPixelData; begin - aStream.Read(aLineBuf^, rbLineSize); - SpecialFormat.PreparePixel(Pixel); - for i := 0 to Info.biWidth-1 do begin - SpecialFormat.Unmap(aLineBuf, Pixel, SourceMD); - glBitmapConvertPixel(Pixel, SpecialFormat, FormatDesc); - FormatDesc.Map(Pixel, aData, DestMD); + bfFormat := TbmpBitfieldFormat.Create; + with aImage.DataDescription do begin + Prec.r := RedPrec; + Prec.g := GreenPrec; + Prec.b := BluePrec; + Prec.a := AlphaPrec; + Shift.r := RedShift; + Shift.g := GreenShift; + Shift.b := BlueShift; + Shift.a := AlphaShift; + bfFormat.SetCustomValues(BitsPerPixel, Prec, Shift); + end; + pSourceMD := bfFormat.CreateMappingData; + pDestMD := FormatDesc.CreateMappingData; + try + for y := 0 to aImage.Height-1 do begin + pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine; + pDestLine := ImageData + y * Round(FormatDesc.BytesPerPixel * aImage.Width); + for x := 0 to aImage.Width-1 do begin + bfFormat.Unmap(pSourceLine, pixel, pSourceMD); + FormatDesc.Map(pixel, pDestLine, pDestMD); + end; + end; + finally + FormatDesc.FreeMappingData(pDestMD); + bfFormat.FreeMappingData(pSourceMD); + bfFormat.Free; end; end; begin - result := false; - BmpFormat := tfEmpty; - SpecialFormat := nil; - LineBuf := nil; - SourceMD := nil; - DestMD := nil; - - // Header - StartPos := aStream.Position; - aStream.Read(Header{%H-}, SizeOf(Header)); + result := false; + if not Assigned(aImage) then + exit; - if Header.bfType = BMP_MAGIC then begin - try try - BmpFormat := ReadInfo(Info, Mask); - SpecialFormat := ReadColorTable(BmpFormat, Info); - if not Assigned(SpecialFormat) then - SpecialFormat := CheckBitfields(BmpFormat, Mask, Info); - aStream.Position := StartPos + Header.bfOffBits; + with aImage.DataDescription do begin + Mask.r := (QWord(1 shl RedPrec )-1) shl RedShift; + Mask.g := (QWord(1 shl GreenPrec)-1) shl GreenShift; + Mask.b := (QWord(1 shl BluePrec )-1) shl BlueShift; + Mask.a := (QWord(1 shl AlphaPrec)-1) shl AlphaShift; + end; + FormatDesc := TFormatDescriptor.GetFromMask(Mask); + f := FormatDesc.Format; + if (f = tfEmpty) then + exit; - if (BmpFormat <> tfEmpty) then begin - FormatDesc := TFormatDescriptor.Get(BmpFormat); - rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize - wbLineSize := Trunc(Info.biWidth * FormatDesc.BytesPerPixel); - Padding := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize; + CanCopy := + (FormatDesc.BitsPerPixel = aImage.DataDescription.Depth) and + (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth); - //get Memory - DestMD := FormatDesc.CreateMappingData; - ImageSize := FormatDesc.GetSize(Info.biWidth, abs(Info.biHeight)); - GetMem(ImageData, ImageSize); - if Assigned(SpecialFormat) then begin - GetMem(LineBuf, rbLineSize); //tmp Memory for converting Bitfields - SourceMD := SpecialFormat.CreateMappingData; - end; + ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height); + ImageData := GetMem(ImageSize); + try + if CanCopy then + Move(aImage.PixelData^, ImageData^, ImageSize) + else + CopyConvert; + SetData(ImageData, f, aImage.Width, aImage.Height); + except + if Assigned(ImageData) then + FreeMem(ImageData); + raise; + end; - //read Data - try try - FillChar(ImageData^, ImageSize, $FF); - TmpData := ImageData; - if (Info.biHeight > 0) then - Inc(TmpData, wbLineSize * (Info.biHeight-1)); - for i := 0 to Abs(Info.biHeight)-1 do begin - if Assigned(SpecialFormat) then - SpecialFormatReadLine(TmpData, LineBuf) //if is special format read and convert data - else - aStream.Read(TmpData^, wbLineSize); //else only read data - if (Info.biHeight > 0) then - dec(TmpData, wbLineSize) - else - inc(TmpData, wbLineSize); - aStream.Read(PaddingBuff{%H-}, Padding); - end; - SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); //be careful, Data could be freed by this method - result := true; - finally - if Assigned(LineBuf) then - FreeMem(LineBuf); - if Assigned(SourceMD) then - SpecialFormat.FreeMappingData(SourceMD); - FormatDesc.FreeMappingData(DestMD); - end; - except - if Assigned(ImageData) then - FreeMem(ImageData); - raise; - end; - end else - raise EglBitmap.Create('LoadBMP - No suitable format found'); - except - aStream.Position := StartPos; - raise; - end; - finally - FreeAndNil(SpecialFormat); - end; - end - else aStream.Position := StartPos; + result := true; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveBMP(const aStream: TStream); +function TglBitmapData.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean; var - Header: TBMPHeader; - Info: TBMPInfo; - Converter: TFormatDescriptor; + rid: TRawImageDescription; FormatDesc: TFormatDescriptor; - SourceFD, DestFD: Pointer; - pData, srcData, dstData, ConvertBuffer: pByte; - Pixel: TglBitmapPixelData; - ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx: Integer; - RedMask, GreenMask, BlueMask, AlphaMask: Cardinal; + x, y: Integer; + srcMD: Pointer; + src, dst: PByte; +begin + result := false; + if not Assigned(aImage) or (Format = tfEmpty) then + exit; + FormatDesc := TFormatDescriptor.Get(Format); + if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then + exit; - PaddingBuff: Cardinal; + FillChar(rid{%H-}, SizeOf(rid), 0); + rid.Format := ricfGray; + rid.Width := Width; + rid.Height := Height; + rid.Depth := CountSetBits(FormatDesc.Range.a); + rid.BitOrder := riboBitsInOrder; + rid.ByteOrder := riboLSBFirst; + rid.LineOrder := riloTopToBottom; + rid.LineEnd := rileTight; + rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8); + rid.RedPrec := CountSetBits(FormatDesc.Range.a); + rid.GreenPrec := 0; + rid.BluePrec := 0; + rid.AlphaPrec := 0; + rid.RedShift := 0; + rid.GreenShift := 0; + rid.BlueShift := 0; + rid.AlphaShift := 0; - function GetLineWidth : Integer; - begin - result := ((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3; + rid.MaskBitsPerPixel := 0; + rid.PaletteColorCount := 0; + + aImage.DataDescription := rid; + aImage.CreateData; + + srcMD := FormatDesc.CreateMappingData; + try + FormatDesc.PreparePixel(Pixel); + src := Data; + dst := aImage.PixelData; + for y := 0 to Height-1 do + for x := 0 to Width-1 do begin + FormatDesc.Unmap(src, Pixel, srcMD); + case rid.BitsPerPixel of + 8: begin + dst^ := Pixel.Data.a; + inc(dst); + end; + 16: begin + PWord(dst)^ := Pixel.Data.a; + inc(dst, 2); + end; + 24: begin + PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0]; + PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1]; + PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2]; + inc(dst, 3); + end; + 32: begin + PCardinal(dst)^ := Pixel.Data.a; + inc(dst, 4); + end; + else + raise EglBitmapUnsupportedFormat.Create(Format); + end; + end; + finally + FormatDesc.FreeMappingData(srcMD); end; + result := true; +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + data: TglBitmapData; begin - if not (ftBMP in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedFormat.Create(Format); + data := TglBitmapData.Create; + try + data.AssignFromLazIntfImage(aImage); + result := AddAlphaFromDataObj(data, aFunc, aArgs); + finally + data.Free; + end; +end; +{$ENDIF} - Converter := nil; - FormatDesc := TFormatDescriptor.Get(Format); - ImageSize := FormatDesc.GetSize(Dimension); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar; + const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + rs: TResourceStream; +begin + PrepareResType(aResource, aResType); + rs := TResourceStream.Create(aInstance, aResource, aResType); + try + result := AddAlphaFromStream(rs, aFunc, aArgs); + finally + rs.Free; + end; +end; - FillChar(Header{%H-}, SizeOf(Header), 0); - Header.bfType := BMP_MAGIC; - Header.bfSize := SizeOf(Header) + SizeOf(Info) + ImageSize; - Header.bfReserved1 := 0; - Header.bfReserved2 := 0; - Header.bfOffBits := SizeOf(Header) + SizeOf(Info); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; + const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + rs: TResourceStream; +begin + rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType); + try + result := AddAlphaFromStream(rs, aFunc, aArgs); + finally + rs.Free; + end; +end; - FillChar(Info{%H-}, SizeOf(Info), 0); - Info.biSize := SizeOf(Info); - Info.biWidth := Width; - Info.biHeight := Height; - Info.biPlanes := 1; - Info.biCompression := BMP_COMP_RGB; - Info.biSizeImage := ImageSize; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +begin + if TFormatDescriptor.Get(Format).IsCompressed then + raise EglBitmapUnsupportedFormat.Create(Format); + result := Convert(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs); +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + FS: TFileStream; +begin + FS := TFileStream.Create(aFileName, fmOpenRead); try - case Format of - tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1: - begin - Info.biBitCount := 8; - Header.bfSize := Header.bfSize + 256 * SizeOf(Cardinal); - Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries - Converter := TbmpColorTableFormat.Create; - with (Converter as TbmpColorTableFormat) do begin - SetCustomValues(fFormat, 1, FormatDesc.Precision, FormatDesc.Shift); - CreateColorTable; - end; - end; + result := AddAlphaFromStream(FS, aFunc, aArgs); + finally + FS.Free; + end; +end; - tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, - tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1, - tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1: - begin - Info.biBitCount := 16; - Info.biCompression := BMP_COMP_BITFIELDS; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + data: TglBitmapData; +begin + data := TglBitmapData.Create(aStream); + try + result := AddAlphaFromDataObj(data, aFunc, aArgs); + finally + data.Free; + end; +end; - tfBGR8ub3, tfRGB8ub3: - begin - Info.biBitCount := 24; - if (Format = tfRGB8ub3) then - Converter := TfdBGR8ub3.Create; //use BGR8 Format Descriptor to Swap RGB Values - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromDataObj(const aDataObj: TglBitmapData; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean; +var + DestData, DestData2, SourceData: pByte; + TempHeight, TempWidth: Integer; + SourceFD, DestFD: TFormatDescriptor; + SourceMD, DestMD, DestMD2: Pointer; - tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1, - tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1: - begin - Info.biBitCount := 32; - Info.biCompression := BMP_COMP_BITFIELDS; - end; - else - raise EglBitmapUnsupportedFormat.Create(Format); - end; - Info.biXPelsPerMeter := 2835; - Info.biYPelsPerMeter := 2835; + FuncRec: TglBitmapFunctionRec; +begin + result := false; - // prepare bitmasks - if Info.biCompression = BMP_COMP_BITFIELDS then begin - Header.bfSize := Header.bfSize + 4 * SizeOf(Cardinal); - Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal); + Assert(Assigned(Data)); + Assert(Assigned(aDataObj)); + Assert(Assigned(aDataObj.Data)); - RedMask := FormatDesc.Mask.r; - GreenMask := FormatDesc.Mask.g; - BlueMask := FormatDesc.Mask.b; - AlphaMask := FormatDesc.Mask.a; - end; + if ((aDataObj.Width = Width) and (aDataObj.Height = Height)) then begin + result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha); - // headers - aStream.Write(Header, SizeOf(Header)); - aStream.Write(Info, SizeOf(Info)); + SourceFD := TFormatDescriptor.Get(aDataObj.Format); + DestFD := TFormatDescriptor.Get(Format); - // colortable - if Assigned(Converter) and (Converter is TbmpColorTableFormat) then - with (Converter as TbmpColorTableFormat) do - aStream.Write(ColorTable[0].b, - SizeOf(TbmpColorTableEnty) * Length(ColorTable)); + if not Assigned(aFunc) then begin + aFunc := glBitmapAlphaFunc; + FuncRec.Args := {%H-}Pointer(SourceFD.HasAlpha); + end else + FuncRec.Args := aArgs; - // bitmasks - if Info.biCompression = BMP_COMP_BITFIELDS then begin - aStream.Write(RedMask, SizeOf(Cardinal)); - aStream.Write(GreenMask, SizeOf(Cardinal)); - aStream.Write(BlueMask, SizeOf(Cardinal)); - aStream.Write(AlphaMask, SizeOf(Cardinal)); - end; + // Values + TempWidth := aDataObj.Width; + TempHeight := aDataObj.Height; + if (TempWidth <= 0) or (TempHeight <= 0) then + exit; - // image data - rbLineSize := Round(Info.biWidth * FormatDesc.BytesPerPixel); - wbLineSize := Round(Info.biWidth * Info.biBitCount / 8); - Padding := GetLineWidth - wbLineSize; - PaddingBuff := 0; + FuncRec.Sender := Self; + FuncRec.Size := Dimension; + FuncRec.Position.Fields := FuncRec.Size.Fields; - pData := Data; - inc(pData, (Height-1) * rbLineSize); + DestData := Data; + DestData2 := Data; + SourceData := aDataObj.Data; - // prepare row buffer. But only for RGB because RGBA supports color masks - // so it's possible to change color within the image. - if Assigned(Converter) then begin - FormatDesc.PreparePixel(Pixel); - GetMem(ConvertBuffer, wbLineSize); - SourceFD := FormatDesc.CreateMappingData; - DestFD := Converter.CreateMappingData; - end else - ConvertBuffer := nil; + // Mapping + SourceFD.PreparePixel(FuncRec.Source); + DestFD.PreparePixel (FuncRec.Dest); + SourceMD := SourceFD.CreateMappingData; + DestMD := DestFD.CreateMappingData; + DestMD2 := DestFD.CreateMappingData; try - for LineIdx := 0 to Height - 1 do begin - // preparing row - if Assigned(Converter) then begin - srcData := pData; - dstData := ConvertBuffer; - for PixelIdx := 0 to Info.biWidth-1 do begin - FormatDesc.Unmap(srcData, Pixel, SourceFD); - glBitmapConvertPixel(Pixel, FormatDesc, Converter); - Converter.Map(Pixel, dstData, DestFD); - end; - aStream.Write(ConvertBuffer^, wbLineSize); - end else begin - aStream.Write(pData^, rbLineSize); + FuncRec.Position.Y := 0; + while FuncRec.Position.Y < TempHeight do begin + FuncRec.Position.X := 0; + while FuncRec.Position.X < TempWidth do begin + SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD); + DestFD.Unmap (DestData, FuncRec.Dest, DestMD); + aFunc(FuncRec); + DestFD.Map(FuncRec.Dest, DestData2, DestMD2); + inc(FuncRec.Position.X); end; - dec(pData, rbLineSize); - if (Padding > 0) then - aStream.Write(PaddingBuff, Padding); + inc(FuncRec.Position.Y); end; finally - // destroy row buffer - if Assigned(ConvertBuffer) then begin - FormatDesc.FreeMappingData(SourceFD); - Converter.FreeMappingData(DestFD); - FreeMem(ConvertBuffer); - end; + SourceFD.FreeMappingData(SourceMD); + DestFD.FreeMappingData(DestMD); + DestFD.FreeMappingData(DestMD2); end; - finally - if Assigned(Converter) then - Converter.Free; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TGA///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -type - TTGAHeader = packed record - ImageID: Byte; - ColorMapType: Byte; - ImageType: Byte; - //ColorMapSpec: Array[0..4] of Byte; - ColorMapStart: Word; - ColorMapLength: Word; - ColorMapEntrySize: Byte; - OrigX: Word; - OrigY: Word; - Width: Word; - Height: Word; - Bpp: Byte; - ImageDesc: Byte; - end; - -const - TGA_UNCOMPRESSED_RGB = 2; - TGA_UNCOMPRESSED_GRAY = 3; - TGA_COMPRESSED_RGB = 10; - TGA_COMPRESSED_GRAY = 11; +function TglBitmapData.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean; +begin + result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF); +end; - TGA_NONE_COLOR_TABLE = 0; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal): Boolean; +var + PixelData: TglBitmapPixelData; +begin + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); + result := AddAlphaFromColorKeyFloat( + aRed / PixelData.Range.r, + aGreen / PixelData.Range.g, + aBlue / PixelData.Range.b, + aDeviation / Max(PixelData.Range.r, Max(PixelData.Range.g, PixelData.Range.b))); +end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadTGA(const aStream: TStream): Boolean; +function TglBitmapData.AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single): Boolean; var - Header: TTGAHeader; - ImageData: System.PByte; - StartPosition: Int64; - PixelSize, LineSize: Integer; - tgaFormat: TglBitmapFormat; - FormatDesc: TFormatDescriptor; - Counter: packed record - X, Y: packed record - low, high, dir: Integer; + values: array[0..2] of Single; + tmp: Cardinal; + i: Integer; + PixelData: TglBitmapPixelData; +begin + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); + with PixelData do begin + values[0] := aRed; + values[1] := aGreen; + values[2] := aBlue; + + for i := 0 to 2 do begin + tmp := Trunc(Range.arr[i] * aDeviation); + Data.arr[i] := Min(Range.arr[i], Trunc(Range.arr[i] * values[i] + tmp)); + Range.arr[i] := Max(0, Trunc(Range.arr[i] * values[i] - tmp)); end; + Data.a := 0; + Range.a := 0; end; + result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, @PixelData); +end; -const - CACHE_SIZE = $4000; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromValue(const aAlpha: Byte): Boolean; +begin + result := AddAlphaFromValueFloat(aAlpha / $FF); +end; - //////////////////////////////////////////////////////////////////////////////////////// - procedure ReadUncompressed; - var - i, j: Integer; - buf, tmp1, tmp2: System.PByte; - begin - buf := nil; - if (Counter.X.dir < 0) then - GetMem(buf, LineSize); - try - while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin - tmp1 := ImageData; - inc(tmp1, (Counter.Y.low * LineSize)); //pointer to LineStart - if (Counter.X.dir < 0) then begin //flip X - aStream.Read(buf^, LineSize); - tmp2 := buf; - inc(tmp2, LineSize - PixelSize); //pointer to last pixel in line - for i := 0 to Header.Width-1 do begin //for all pixels in line - for j := 0 to PixelSize-1 do begin //for all bytes in pixel - tmp1^ := tmp2^; - inc(tmp1); - inc(tmp2); - end; - dec(tmp2, 2*PixelSize); //move 2 backwards, because j-loop moved 1 forward - end; - end else - aStream.Read(tmp1^, LineSize); - inc(Counter.Y.low, Counter.Y.dir); //move to next line index - end; - finally - if Assigned(buf) then - FreeMem(buf); - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; +var + PixelData: TglBitmapPixelData; +begin + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); + result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.AddAlphaFromValueFloat(const aAlpha: Single): Boolean; +var + PixelData: TglBitmapPixelData; +begin + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); + with PixelData do + Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha))); + result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.RemoveAlpha: Boolean; +var + FormatDesc: TFormatDescriptor; +begin + result := false; + FormatDesc := TFormatDescriptor.Get(Format); + if Assigned(Data) then begin + if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then + raise EglBitmapUnsupportedFormat.Create(Format); + result := ConvertTo(FormatDesc.WithoutAlpha); end; +end; - //////////////////////////////////////////////////////////////////////////////////////// - procedure ReadCompressed; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.FillWithColor(const aRed, aGreen, aBlue: Byte; + const aAlpha: Byte); +begin + FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF); +end; - ///////////////////////////////////////////////////////////////// - var - TmpData: System.PByte; - LinePixelsRead: Integer; - procedure CheckLine; - begin - if (LinePixelsRead >= Header.Width) then begin - LinePixelsRead := 0; - inc(Counter.Y.low, Counter.Y.dir); //next line index - TmpData := ImageData; - inc(TmpData, Counter.Y.low * LineSize); //set line - if (Counter.X.dir < 0) then //if x flipped then - inc(TmpData, LineSize - PixelSize); //set last pixel - end; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal); +var + PixelData: TglBitmapPixelData; +begin + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); + FillWithColorFloat( + aRed / PixelData.Range.r, + aGreen / PixelData.Range.g, + aBlue / PixelData.Range.b, + aAlpha / PixelData.Range.a); +end; - ///////////////////////////////////////////////////////////////// - var - Cache: PByte; - CacheSize, CachePos: Integer; - procedure CachedRead(out Buffer; Count: Integer); - var - BytesRead: Integer; - begin - if (CachePos + Count > CacheSize) then begin - //if buffer overflow save non read bytes - BytesRead := 0; - if (CacheSize - CachePos > 0) then begin - BytesRead := CacheSize - CachePos; - Move(PByteArray(Cache)^[CachePos], Buffer{%H-}, BytesRead); - inc(CachePos, BytesRead); - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single); +var + PixelData: TglBitmapPixelData; +begin + TFormatDescriptor.Get(Format).PreparePixel(PixelData); + with PixelData do begin + Data.r := Max(0, Min(Range.r, Trunc(Range.r * aRed))); + Data.g := Max(0, Min(Range.g, Trunc(Range.g * aGreen))); + Data.b := Max(0, Min(Range.b, Trunc(Range.b * aBlue))); + Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha))); + end; + Convert(glBitmapFillWithColorFunc, false, @PixelData); +end; - //load cache from file - CacheSize := Min(CACHE_SIZE, aStream.Size - aStream.Position); - aStream.Read(Cache^, CacheSize); - CachePos := 0; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.SetData(const aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer; const aHeight: Integer); +begin + if (Data <> aData) then begin + if (Assigned(Data)) then + FreeMem(Data); + fData := aData; + end; - //read rest of requested bytes - if (Count - BytesRead > 0) then begin - Move(PByteArray(Cache)^[CachePos], TByteArray(Buffer)[BytesRead], Count - BytesRead); - inc(CachePos, Count - BytesRead); - end; - end else begin - //if no buffer overflow just read the data - Move(PByteArray(Cache)^[CachePos], Buffer, Count); - inc(CachePos, Count); - end; + if Assigned(fData) then begin + FillChar(fDimension, SizeOf(fDimension), 0); + if aWidth <> -1 then begin + fDimension.Fields := fDimension.Fields + [ffX]; + fDimension.X := aWidth; end; - procedure PixelToBuffer(const aData: PByte; var aBuffer: PByte); - begin - case PixelSize of - 1: begin - aBuffer^ := aData^; - inc(aBuffer, Counter.X.dir); - end; - 2: begin - PWord(aBuffer)^ := PWord(aData)^; - inc(aBuffer, 2 * Counter.X.dir); - end; - 3: begin - PByteArray(aBuffer)^[0] := PByteArray(aData)^[0]; - PByteArray(aBuffer)^[1] := PByteArray(aData)^[1]; - PByteArray(aBuffer)^[2] := PByteArray(aData)^[2]; - inc(aBuffer, 3 * Counter.X.dir); - end; - 4: begin - PCardinal(aBuffer)^ := PCardinal(aData)^; - inc(aBuffer, 4 * Counter.X.dir); - end; - end; + if aHeight <> -1 then begin + fDimension.Fields := fDimension.Fields + [ffY]; + fDimension.Y := aHeight; end; - var - TotalPixelsToRead, TotalPixelsRead: Integer; - Temp: Byte; - buf: array [0..3] of Byte; //1 pixel is max 32bit long - PixelRepeat: Boolean; - PixelsToRead, PixelCount: Integer; - begin - CacheSize := 0; - CachePos := 0; - - TotalPixelsToRead := Header.Width * Header.Height; - TotalPixelsRead := 0; - LinePixelsRead := 0; - - GetMem(Cache, CACHE_SIZE); - try - TmpData := ImageData; - inc(TmpData, Counter.Y.low * LineSize); //set line - if (Counter.X.dir < 0) then //if x flipped then - inc(TmpData, LineSize - PixelSize); //set last pixel + fFormat := aFormat; + end else + fFormat := tfEmpty; - repeat - //read CommandByte - CachedRead(Temp, 1); - PixelRepeat := (Temp and $80) > 0; - PixelsToRead := (Temp and $7F) + 1; - inc(TotalPixelsRead, PixelsToRead); + UpdateScanlines; +end; - if PixelRepeat then - CachedRead(buf[0], PixelSize); - while (PixelsToRead > 0) do begin - CheckLine; - PixelCount := Min(Header.Width - LinePixelsRead, PixelsToRead); //max read to EOL or EOF - while (PixelCount > 0) do begin - if not PixelRepeat then - CachedRead(buf[0], PixelSize); - PixelToBuffer(@buf[0], TmpData); - inc(LinePixelsRead); - dec(PixelsToRead); - dec(PixelCount); - end; - end; - until (TotalPixelsRead >= TotalPixelsToRead); - finally - FreeMem(Cache); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapData.Clone: TglBitmapData; +var + Temp: TglBitmapData; + TempPtr: PByte; + Size: Integer; +begin + result := nil; + Temp := (ClassType.Create as TglBitmapData); + try + // copy texture data if assigned + if Assigned(Data) then begin + Size := TFormatDescriptor.Get(Format).GetSize(fDimension); + GetMem(TempPtr, Size); + try + Move(Data^, TempPtr^, Size); + Temp.SetData(TempPtr, Format, Width, Height); + except + if Assigned(TempPtr) then + FreeMem(TempPtr); + raise; + end; + end else begin + TempPtr := nil; + Temp.SetData(TempPtr, Format, Width, Height); end; - end; - function IsGrayFormat: Boolean; - begin - result := Header.ImageType in [TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_GRAY]; + // copy properties + Temp.fFormat := Format; + result := Temp; + except + FreeAndNil(Temp); + raise; end; +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapData.Invert(const aRed, aGreen, aBlue, aAlpha: Boolean); +var + mask: PtrInt; begin - result := false; - - // reading header to test file and set cursor back to begin - StartPosition := aStream.Position; - aStream.Read(Header{%H-}, SizeOf(Header)); + mask := + (Byte(aRed) and 1) or + ((Byte(aGreen) and 1) shl 1) or + ((Byte(aBlue) and 1) shl 2) or + ((Byte(aAlpha) and 1) shl 3); + if (mask > 0) then + Convert(glBitmapInvertFunc, false, {%H-}Pointer(mask)); +end; - // no colormapped files - if (Header.ColorMapType = TGA_NONE_COLOR_TABLE) and (Header.ImageType in [ - TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY]) then - begin - try - if Header.ImageID <> 0 then // skip image ID - aStream.Position := aStream.Position + Header.ImageID; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +type + TMatrixItem = record + X, Y: Integer; + W: Single; + end; - tgaFormat := tfEmpty; - case Header.Bpp of - 8: if IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfLuminance8ub1; - 8: tgaFormat := tfAlpha8ub1; - end; + PglBitmapToNormalMapRec = ^TglBitmapToNormalMapRec; + TglBitmapToNormalMapRec = Record + Scale: Single; + Heights: array of Single; + MatrixU : array of TMatrixItem; + MatrixV : array of TMatrixItem; + end; - 16: if IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfLuminance16us1; - 8: tgaFormat := tfLuminance8Alpha8ub2; - end else case (Header.ImageDesc and $F) of - 0: tgaFormat := tfX1RGB5us1; - 1: tgaFormat := tfA1RGB5us1; - 4: tgaFormat := tfARGB4us1; - end; +const + ONE_OVER_255 = 1 / 255; - 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfBGR8ub3; - end; + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapToNormalMapPrepareFunc(var FuncRec: TglBitmapFunctionRec); +var + Val: Single; +begin + with FuncRec do begin + Val := + Source.Data.r * LUMINANCE_WEIGHT_R + + Source.Data.g * LUMINANCE_WEIGHT_G + + Source.Data.b * LUMINANCE_WEIGHT_B; + PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Val * ONE_OVER_255; + end; +end; - 32: if IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfDepth32ui1; - end else case (Header.ImageDesc and $F) of - 0: tgaFormat := tfX2RGB10ui1; - 2: tgaFormat := tfA2RGB10ui1; - 8: tgaFormat := tfARGB8ui1; - end; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapToNormalMapPrepareAlphaFunc(var FuncRec: TglBitmapFunctionRec); +begin + with FuncRec do + PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Source.Data.a * ONE_OVER_255; +end; - if (tgaFormat = tfEmpty) then - raise EglBitmap.Create('LoadTga - unsupported format'); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure glBitmapToNormalMapFunc (var FuncRec: TglBitmapFunctionRec); +type + TVec = Array[0..2] of Single; +var + Idx: Integer; + du, dv: Double; + Len: Single; + Vec: TVec; - FormatDesc := TFormatDescriptor.Get(tgaFormat); - PixelSize := FormatDesc.GetSize(1, 1); - LineSize := FormatDesc.GetSize(Header.Width, 1); + function GetHeight(X, Y: Integer): Single; + begin + with FuncRec do begin + X := Max(0, Min(Size.X -1, X)); + Y := Max(0, Min(Size.Y -1, Y)); + result := PglBitmapToNormalMapRec(Args)^.Heights[Y * Size.X + X]; + end; + end; - GetMem(ImageData, LineSize * Header.Height); - try - //column direction - if ((Header.ImageDesc and (1 shl 4)) > 0) then begin - Counter.X.low := Header.Height-1;; - Counter.X.high := 0; - Counter.X.dir := -1; - end else begin - Counter.X.low := 0; - Counter.X.high := Header.Height-1; - Counter.X.dir := 1; - end; +begin + with FuncRec do begin + with PglBitmapToNormalMapRec(Args)^ do begin + du := 0; + for Idx := Low(MatrixU) to High(MatrixU) do + du := du + GetHeight(Position.X + MatrixU[Idx].X, Position.Y + MatrixU[Idx].Y) * MatrixU[Idx].W; - // Row direction - if ((Header.ImageDesc and (1 shl 5)) > 0) then begin - Counter.Y.low := 0; - Counter.Y.high := Header.Height-1; - Counter.Y.dir := 1; - end else begin - Counter.Y.low := Header.Height-1;; - Counter.Y.high := 0; - Counter.Y.dir := -1; - end; + dv := 0; + for Idx := Low(MatrixU) to High(MatrixU) do + dv := dv + GetHeight(Position.X + MatrixV[Idx].X, Position.Y + MatrixV[Idx].Y) * MatrixV[Idx].W; - // Read Image - case Header.ImageType of - TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY: - ReadUncompressed; - TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY: - ReadCompressed; - end; + Vec[0] := -du * Scale; + Vec[1] := -dv * Scale; + Vec[2] := 1; + end; - SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); //be careful, Data could be freed by this method - result := true; - except - if Assigned(ImageData) then - FreeMem(ImageData); - raise; - end; - finally - aStream.Position := StartPosition; + // Normalize + Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2])); + if Len <> 0 then begin + Vec[0] := Vec[0] * Len; + Vec[1] := Vec[1] * Len; + Vec[2] := Vec[2] * Len; end; - end - else aStream.Position := StartPosition; + + // Farbe zuweisem + Dest.Data.r := Trunc((Vec[0] + 1) * 127.5); + Dest.Data.g := Trunc((Vec[1] + 1) * 127.5); + Dest.Data.b := Trunc((Vec[2] + 1) * 127.5); + end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveTGA(const aStream: TStream); +procedure TglBitmapData.GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean); var - Header: TTGAHeader; - Size: Integer; - FormatDesc: TFormatDescriptor; + Rec: TglBitmapToNormalMapRec; + + procedure SetEntry (var Matrix: array of TMatrixItem; Index, X, Y: Integer; W: Single); + begin + if (Index >= Low(Matrix)) and (Index <= High(Matrix)) then begin + Matrix[Index].X := X; + Matrix[Index].Y := Y; + Matrix[Index].W := W; + end; + end; + begin - if not (ftTGA in FormatGetSupportedFiles(Format)) then + if TFormatDescriptor.Get(Format).IsCompressed then raise EglBitmapUnsupportedFormat.Create(Format); - //prepare header - FormatDesc := TFormatDescriptor.Get(Format); - FillChar(Header{%H-}, SizeOf(Header), 0); - Header.ImageDesc := CountSetBits(FormatDesc.Range.a) and $F; - Header.Bpp := FormatDesc.BitsPerPixel; - Header.Width := Width; - Header.Height := Height; - Header.ImageDesc := Header.ImageDesc or $20; //flip y - if FormatDesc.IsGrayscale or (not FormatDesc.IsGrayscale and not FormatDesc.HasRed and FormatDesc.HasAlpha) then - Header.ImageType := TGA_UNCOMPRESSED_GRAY + if aScale > 100 then + Rec.Scale := 100 + else if aScale < -100 then + Rec.Scale := -100 else - Header.ImageType := TGA_UNCOMPRESSED_RGB; - aStream.Write(Header, SizeOf(Header)); + Rec.Scale := aScale; - // write Data - Size := FormatDesc.GetSize(Dimension); - aStream.Write(Data^, Size); -end; + SetLength(Rec.Heights, Width * Height); + try + case aFunc of + nm4Samples: begin + SetLength(Rec.MatrixU, 2); + SetEntry(Rec.MatrixU, 0, -1, 0, -0.5); + SetEntry(Rec.MatrixU, 1, 1, 0, 0.5); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//DDS///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -const - DDS_MAGIC: Cardinal = $20534444; + SetLength(Rec.MatrixV, 2); + SetEntry(Rec.MatrixV, 0, 0, 1, 0.5); + SetEntry(Rec.MatrixV, 1, 0, -1, -0.5); + end; - // DDS_header.dwFlags - DDSD_CAPS = $00000001; - DDSD_HEIGHT = $00000002; - DDSD_WIDTH = $00000004; - DDSD_PIXELFORMAT = $00001000; + nmSobel: begin + SetLength(Rec.MatrixU, 6); + SetEntry(Rec.MatrixU, 0, -1, 1, -1.0); + SetEntry(Rec.MatrixU, 1, -1, 0, -2.0); + SetEntry(Rec.MatrixU, 2, -1, -1, -1.0); + SetEntry(Rec.MatrixU, 3, 1, 1, 1.0); + SetEntry(Rec.MatrixU, 4, 1, 0, 2.0); + SetEntry(Rec.MatrixU, 5, 1, -1, 1.0); - // DDS_header.sPixelFormat.dwFlags - DDPF_ALPHAPIXELS = $00000001; - DDPF_ALPHA = $00000002; - DDPF_FOURCC = $00000004; - DDPF_RGB = $00000040; - DDPF_LUMINANCE = $00020000; + SetLength(Rec.MatrixV, 6); + SetEntry(Rec.MatrixV, 0, -1, 1, 1.0); + SetEntry(Rec.MatrixV, 1, 0, 1, 2.0); + SetEntry(Rec.MatrixV, 2, 1, 1, 1.0); + SetEntry(Rec.MatrixV, 3, -1, -1, -1.0); + SetEntry(Rec.MatrixV, 4, 0, -1, -2.0); + SetEntry(Rec.MatrixV, 5, 1, -1, -1.0); + end; - // DDS_header.sCaps.dwCaps1 - DDSCAPS_TEXTURE = $00001000; + nm3x3: begin + SetLength(Rec.MatrixU, 6); + SetEntry(Rec.MatrixU, 0, -1, 1, -1/6); + SetEntry(Rec.MatrixU, 1, -1, 0, -1/6); + SetEntry(Rec.MatrixU, 2, -1, -1, -1/6); + SetEntry(Rec.MatrixU, 3, 1, 1, 1/6); + SetEntry(Rec.MatrixU, 4, 1, 0, 1/6); + SetEntry(Rec.MatrixU, 5, 1, -1, 1/6); - // DDS_header.sCaps.dwCaps2 - DDSCAPS2_CUBEMAP = $00000200; + SetLength(Rec.MatrixV, 6); + SetEntry(Rec.MatrixV, 0, -1, 1, 1/6); + SetEntry(Rec.MatrixV, 1, 0, 1, 1/6); + SetEntry(Rec.MatrixV, 2, 1, 1, 1/6); + SetEntry(Rec.MatrixV, 3, -1, -1, -1/6); + SetEntry(Rec.MatrixV, 4, 0, -1, -1/6); + SetEntry(Rec.MatrixV, 5, 1, -1, -1/6); + end; - D3DFMT_DXT1 = $31545844; - D3DFMT_DXT3 = $33545844; - D3DFMT_DXT5 = $35545844; + nm5x5: begin + SetLength(Rec.MatrixU, 20); + SetEntry(Rec.MatrixU, 0, -2, 2, -1 / 16); + SetEntry(Rec.MatrixU, 1, -1, 2, -1 / 10); + SetEntry(Rec.MatrixU, 2, 1, 2, 1 / 10); + SetEntry(Rec.MatrixU, 3, 2, 2, 1 / 16); + SetEntry(Rec.MatrixU, 4, -2, 1, -1 / 10); + SetEntry(Rec.MatrixU, 5, -1, 1, -1 / 8); + SetEntry(Rec.MatrixU, 6, 1, 1, 1 / 8); + SetEntry(Rec.MatrixU, 7, 2, 1, 1 / 10); + SetEntry(Rec.MatrixU, 8, -2, 0, -1 / 2.8); + SetEntry(Rec.MatrixU, 9, -1, 0, -0.5); + SetEntry(Rec.MatrixU, 10, 1, 0, 0.5); + SetEntry(Rec.MatrixU, 11, 2, 0, 1 / 2.8); + SetEntry(Rec.MatrixU, 12, -2, -1, -1 / 10); + SetEntry(Rec.MatrixU, 13, -1, -1, -1 / 8); + SetEntry(Rec.MatrixU, 14, 1, -1, 1 / 8); + SetEntry(Rec.MatrixU, 15, 2, -1, 1 / 10); + SetEntry(Rec.MatrixU, 16, -2, -2, -1 / 16); + SetEntry(Rec.MatrixU, 17, -1, -2, -1 / 10); + SetEntry(Rec.MatrixU, 18, 1, -2, 1 / 10); + SetEntry(Rec.MatrixU, 19, 2, -2, 1 / 16); + + SetLength(Rec.MatrixV, 20); + SetEntry(Rec.MatrixV, 0, -2, 2, 1 / 16); + SetEntry(Rec.MatrixV, 1, -1, 2, 1 / 10); + SetEntry(Rec.MatrixV, 2, 0, 2, 0.25); + SetEntry(Rec.MatrixV, 3, 1, 2, 1 / 10); + SetEntry(Rec.MatrixV, 4, 2, 2, 1 / 16); + SetEntry(Rec.MatrixV, 5, -2, 1, 1 / 10); + SetEntry(Rec.MatrixV, 6, -1, 1, 1 / 8); + SetEntry(Rec.MatrixV, 7, 0, 1, 0.5); + SetEntry(Rec.MatrixV, 8, 1, 1, 1 / 8); + SetEntry(Rec.MatrixV, 9, 2, 1, 1 / 16); + SetEntry(Rec.MatrixV, 10, -2, -1, -1 / 16); + SetEntry(Rec.MatrixV, 11, -1, -1, -1 / 8); + SetEntry(Rec.MatrixV, 12, 0, -1, -0.5); + SetEntry(Rec.MatrixV, 13, 1, -1, -1 / 8); + SetEntry(Rec.MatrixV, 14, 2, -1, -1 / 10); + SetEntry(Rec.MatrixV, 15, -2, -2, -1 / 16); + SetEntry(Rec.MatrixV, 16, -1, -2, -1 / 10); + SetEntry(Rec.MatrixV, 17, 0, -2, -0.25); + SetEntry(Rec.MatrixV, 18, 1, -2, -1 / 10); + SetEntry(Rec.MatrixV, 19, 2, -2, -1 / 16); + end; + end; -type - TDDSPixelFormat = packed record - dwSize: Cardinal; - dwFlags: Cardinal; - dwFourCC: Cardinal; - dwRGBBitCount: Cardinal; - dwRBitMask: Cardinal; - dwGBitMask: Cardinal; - dwBBitMask: Cardinal; - dwABitMask: Cardinal; + // Daten Sammeln + if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then + Convert(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec) + else + Convert(glBitmapToNormalMapPrepareFunc, false, @Rec); + Convert(glBitmapToNormalMapFunc, false, @Rec); + finally + SetLength(Rec.Heights, 0); end; +end; - TDDSCaps = packed record - dwCaps1: Cardinal; - dwCaps2: Cardinal; - dwDDSX: Cardinal; - dwReserved: Cardinal; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmapData.Create; +begin + inherited Create; + fFormat := glBitmapDefaultFormat; +end; - TDDSHeader = packed record - dwSize: Cardinal; - dwFlags: Cardinal; - dwHeight: Cardinal; - dwWidth: Cardinal; - dwPitchOrLinearSize: Cardinal; - dwDepth: Cardinal; - dwMipMapCount: Cardinal; - dwReserved: array[0..10] of Cardinal; - PixelFormat: TDDSPixelFormat; - Caps: TDDSCaps; - dwReserved2: Cardinal; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmapData.Create(const aFileName: String); +begin + Create; + LoadFromFile(aFileName); +end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap.LoadDDS(const aStream: TStream): Boolean; -var - Header: TDDSHeader; - Converter: TbmpBitfieldFormat; +constructor TglBitmapData.Create(const aStream: TStream); +begin + Create; + LoadFromStream(aStream); +end; - function GetDDSFormat: TglBitmapFormat; - var - fd: TFormatDescriptor; - i: Integer; - Mask: TglBitmapRec4ul; - Range: TglBitmapRec4ui; - match: Boolean; - begin - result := tfEmpty; - with Header.PixelFormat do begin - // Compresses - if ((dwFlags and DDPF_FOURCC) > 0) then begin - case Header.PixelFormat.dwFourCC of - D3DFMT_DXT1: result := tfS3tcDtx1RGBA; - D3DFMT_DXT3: result := tfS3tcDtx3RGBA; - D3DFMT_DXT5: result := tfS3tcDtx5RGBA; - end; - end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE or DDPF_ALPHA)) > 0) then begin - // prepare masks - if ((dwFlags and DDPF_LUMINANCE) = 0) then begin - Mask.r := dwRBitMask; - Mask.g := dwGBitMask; - Mask.b := dwBBitMask; - end else begin - Mask.r := dwRBitMask; - Mask.g := dwRBitMask; - Mask.b := dwRBitMask; - end; - if (dwFlags and DDPF_ALPHAPIXELS > 0) then - Mask.a := dwABitMask - else - Mask.a := 0;; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmapData.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte); +var + ImageSize: Integer; +begin + Create; + if not Assigned(aData) then begin + ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize); + GetMem(aData, ImageSize); + try + FillChar(aData^, ImageSize, #$FF); + SetData(aData, aFormat, aSize.X, aSize.Y); + except + if Assigned(aData) then + FreeMem(aData); + raise; + end; + end else begin + SetData(aData, aFormat, aSize.X, aSize.Y); + end; +end; - //find matching format - fd := TFormatDescriptor.GetFromMask(Mask, dwRGBBitCount); - result := fd.Format; - if (result <> tfEmpty) then - exit; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmapData.Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer); +begin + Create; + LoadFromFunc(aSize, aFormat, aFunc, aArgs); +end; - //find format with same Range - for i := 0 to 3 do - Range.arr[i] := (2 shl CountSetBits(Mask.arr[i])) - 1; - for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin - fd := TFormatDescriptor.Get(result); - match := true; - for i := 0 to 3 do - if (fd.Range.arr[i] <> Range.arr[i]) then begin - match := false; - break; - end; - if match then - break; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmapData.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar); +begin + Create; + LoadFromResource(aInstance, aResource, aResType); +end; - //no format with same range found -> use default - if (result = tfEmpty) then begin - if (dwABitMask > 0) then - result := tfRGBA8ui1 - else - result := tfRGB8ub3; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +constructor TglBitmapData.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); +begin + Create; + LoadFromResourceID(aInstance, aResourceID, aResType); +end; - Converter := TbmpBitfieldFormat.Create; - Converter.SetCustomValues(dwRGBBitCount, glBitmapRec4ul(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask)); - end; - end; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +destructor TglBitmapData.Destroy; +begin + SetData(nil, tfEmpty); + inherited Destroy; +end; -var - StreamPos: Int64; - x, y, LineSize, RowSize, Magic: Cardinal; - NewImage, TmpData, RowData, SrcData: System.PByte; - SourceMD, DestMD: Pointer; - Pixel: TglBitmapPixelData; - ddsFormat: TglBitmapFormat; - FormatDesc: TFormatDescriptor; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap - PROTECTED/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.GetWidth: Integer; +begin + if (ffX in fDimension.Fields) then + result := fDimension.X + else + result := -1; +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmap.GetHeight: Integer; begin - result := false; - Converter := nil; - StreamPos := aStream.Position; + if (ffY in fDimension.Fields) then + result := fDimension.Y + else + result := -1; +end; - // Magic - aStream.Read(Magic{%H-}, sizeof(Magic)); - if (Magic <> DDS_MAGIC) then begin - aStream.Position := StreamPos; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetCustomData(const aValue: Pointer); +begin + if fCustomData = aValue then exit; - end; + fCustomData := aValue; +end; - //Header - aStream.Read(Header{%H-}, sizeof(Header)); - if (Header.dwSize <> SizeOf(Header)) or - ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <> - (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then - begin - aStream.Position := StreamPos; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetCustomName(const aValue: String); +begin + if fCustomName = aValue then exit; - end; - - if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then - raise EglBitmap.Create('LoadDDS - CubeMaps are not supported'); - - ddsFormat := GetDDSFormat; - try - if (ddsFormat = tfEmpty) then - raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); - - FormatDesc := TFormatDescriptor.Get(ddsFormat); - LineSize := Trunc(Header.dwWidth * FormatDesc.BytesPerPixel); - GetMem(NewImage, Header.dwHeight * LineSize); - try - TmpData := NewImage; + fCustomName := aValue; +end; - //Converter needed - if Assigned(Converter) then begin - RowSize := Round(Header.dwWidth * Header.PixelFormat.dwRGBBitCount / 8); - GetMem(RowData, RowSize); - SourceMD := Converter.CreateMappingData; - DestMD := FormatDesc.CreateMappingData; - try - for y := 0 to Header.dwHeight-1 do begin - TmpData := NewImage; - inc(TmpData, y * LineSize); - SrcData := RowData; - aStream.Read(SrcData^, RowSize); - for x := 0 to Header.dwWidth-1 do begin - Converter.Unmap(SrcData, Pixel, SourceMD); - glBitmapConvertPixel(Pixel, Converter, FormatDesc); - FormatDesc.Map(Pixel, TmpData, DestMD); - end; - end; - finally - Converter.FreeMappingData(SourceMD); - FormatDesc.FreeMappingData(DestMD); - FreeMem(RowData); - end; - end else +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetCustomNameW(const aValue: WideString); +begin + if fCustomNameW = aValue then + exit; + fCustomNameW := aValue; +end; - // Compressed - if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin - RowSize := Header.dwPitchOrLinearSize div Header.dwWidth; - for Y := 0 to Header.dwHeight-1 do begin - aStream.Read(TmpData^, RowSize); - Inc(TmpData, LineSize); - end; - end else +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean); +begin + if fDeleteTextureOnFree = aValue then + exit; + fDeleteTextureOnFree := aValue; +end; - // Uncompressed - if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin - RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3; - for Y := 0 to Header.dwHeight-1 do begin - aStream.Read(TmpData^, RowSize); - Inc(TmpData, LineSize); - end; - end else - raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetID(const aValue: Cardinal); +begin + if fID = aValue then + exit; + fID := aValue; +end; - SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method - result := true; - except - if Assigned(NewImage) then - FreeMem(NewImage); - raise; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap); +begin + if fMipMap = aValue then + exit; + fMipMap := aValue; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetTarget(const aValue: Cardinal); +begin + if fTarget = aValue then + exit; + fTarget := aValue; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetAnisotropic(const aValue: Integer); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)} +var + MaxAnisotropic: Integer; +{$IFEND} +begin + fAnisotropic := aValue; + if (ID > 0) then begin +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_EXT)} + if GL_EXT_texture_filter_anisotropic then begin + if fAnisotropic > 0 then begin + Bind(false); + 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; - finally - FreeAndNil(Converter); +{$ELSE} + fAnisotropic := 0; +{$IFEND} end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap.SaveDDS(const aStream: TStream); -var - Header: TDDSHeader; - FormatDesc: TFormatDescriptor; +procedure TglBitmap.CreateID; begin - if not (ftDDS in FormatGetSupportedFiles(Format)) then - raise EglBitmapUnsupportedFormat.Create(Format); + if (ID <> 0) then + glDeleteTextures(1, @fID); + glGenTextures(1, @fID); + Bind(false); +end; - FormatDesc := TFormatDescriptor.Get(Format); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.SetupParameters({$IFNDEF OPENGL_ES}out aBuildWithGlu: Boolean{$ENDIF}); +begin + // Set Up Parameters + SetWrap(fWrapS, fWrapT, fWrapR); + SetFilter(fFilterMin, fFilterMag); + SetAnisotropic(fAnisotropic); - // Generell - FillChar(Header{%H-}, SizeOf(Header), 0); - Header.dwSize := SizeOf(Header); - Header.dwFlags := DDSD_WIDTH or DDSD_HEIGHT or DDSD_CAPS or DDSD_PIXELFORMAT; +{$IFNDEF OPENGL_ES} + SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]); + if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then + SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); +{$ENDIF} - Header.dwWidth := Max(1, Width); - Header.dwHeight := Max(1, Height); +{$IFNDEF OPENGL_ES} + // 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 + aBuildWithGlu := true; + end else if (MipMap = mmMipmapGlu) then + aBuildWithGlu := true; +{$ELSE} + if (MipMap = mmMipmap) then + glTexParameteri(Target, GL_GENERATE_MIPMAP, GL_TRUE); +{$ENDIF} +end; - // Caps - Header.Caps.dwCaps1 := DDSCAPS_TEXTURE; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmap - PUBLIC////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.AfterConstruction; +begin + inherited AfterConstruction; - // Pixelformat - Header.PixelFormat.dwSize := sizeof(Header); - if (FormatDesc.IsCompressed) then begin - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_FOURCC; - case Format of - tfS3tcDtx1RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT1; - tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3; - tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5; - end; - end else if not FormatDesc.HasColor and FormatDesc.HasAlpha then begin - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA; - Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; - Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; - end else if FormatDesc.IsGrayscale then begin - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE; - Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; - Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; - Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; - end else begin - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB; - Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; - Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; - Header.PixelFormat.dwGBitMask := FormatDesc.Mask.g; - Header.PixelFormat.dwBBitMask := FormatDesc.Mask.b; - Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; - end; + fID := 0; + fTarget := 0; +{$IFNDEF OPENGL_ES} + fIsResident := false; +{$ENDIF} - if (FormatDesc.HasAlpha) then - Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS; + fMipMap := glBitmapDefaultMipmap; + fDeleteTextureOnFree := glBitmapGetDefaultDeleteTextureOnFree; - aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC)); - aStream.Write(Header, SizeOf(Header)); - aStream.Write(Data^, FormatDesc.GetSize(Dimension)); + glBitmapGetDefaultFilter (fFilterMin, fFilterMag); + glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR); +{$IFNDEF OPENGL_ES} + glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]); +{$ENDIF} end; -{$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap1D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer; const aHeight: Integer); -var - pTemp: pByte; - Size: Integer; +procedure TglBitmap.BeforeDestruction; begin - if (aHeight > 1) then begin - Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1); - GetMem(pTemp, Size); - try - Move(aData^, pTemp^, Size); - FreeMem(aData); - aData := nil; - except - FreeMem(pTemp); - raise; - end; - end else - pTemp := aData; - inherited SetDataPointer(pTemp, aFormat, aWidth); + if (fID > 0) and fDeleteTextureOnFree then + glDeleteTextures(1, @fID); + inherited BeforeDestruction; end; +{$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap1D.FlipHorz: Boolean; -var - Col: Integer; - pTempDest, pDest, pSource: PByte; +procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single); begin - result := inherited FlipHorz; - if Assigned(Data) and not TFormatDescriptor.Get(Format).IsCompressed then begin - pSource := Data; - GetMem(pDest, fRowSize); - try - pTempDest := pDest; - Inc(pTempDest, fRowSize); - for Col := 0 to Width-1 do begin - dec(pTempDest, fPixelSize); //dec before, because ptr is behind last byte of data - Move(pSource^, pTempDest^, fPixelSize); - Inc(pSource, fPixelSize); - end; - SetDataPointer(pDest, Format, Width); //be careful, Data could be freed by this method - result := true; - except - if Assigned(pDest) then - FreeMem(pDest); - raise; - end; + fBorderColor[0] := aRed; + fBorderColor[1] := aGreen; + fBorderColor[2] := aBlue; + fBorderColor[3] := aAlpha; + if (ID > 0) then begin + Bind(false); + glTexParameterfv(Target, GL_TEXTURE_BORDER_COLOR, @fBorderColor[0]); end; end; +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.UploadData(const aBuildWithGlu: Boolean); -var - FormatDesc: TFormatDescriptor; +procedure TglBitmap.SetFilter(const aMin, aMag: GLenum); begin - // Upload data - FormatDesc := TFormatDescriptor.Get(Format); - if (FormatDesc.glInternalFormat = 0) or (FormatDesc.glDataFormat = 0) then - raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data'); + //check MIN filter + case aMin of + GL_NEAREST: + fFilterMin := GL_NEAREST; + GL_LINEAR: + fFilterMin := GL_LINEAR; + GL_NEAREST_MIPMAP_NEAREST: + fFilterMin := GL_NEAREST_MIPMAP_NEAREST; + GL_LINEAR_MIPMAP_NEAREST: + fFilterMin := GL_LINEAR_MIPMAP_NEAREST; + GL_NEAREST_MIPMAP_LINEAR: + fFilterMin := GL_NEAREST_MIPMAP_LINEAR; + GL_LINEAR_MIPMAP_LINEAR: + fFilterMin := GL_LINEAR_MIPMAP_LINEAR; + else + raise EglBitmap.Create('SetFilter - Unknow MIN filter.'); + end; - if FormatDesc.IsCompressed then begin - if not Assigned(glCompressedTexImage1D) then - raise EglBitmap.Create('compressed formats not supported by video adapter'); - glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data) - end else if aBuildWithGlu then - gluBuild1DMipmaps(Target, FormatDesc.glInternalFormat, Width, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) - else - glTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data); + //check MAG filter + case aMag of + GL_NEAREST: + fFilterMag := GL_NEAREST; + GL_LINEAR: + fFilterMag := GL_LINEAR; + else + raise EglBitmap.Create('SetFilter - Unknow MAG filter.'); + end; + + //apply filter + if (ID > 0) then begin + Bind(false); + glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag); - // Free Data - if (FreeDataAfterGenTexture) then - FreeData; + if (MipMap = mmNone) {$IFNDEF OPENGL_ES}or (Target = GL_TEXTURE_RECTANGLE){$ENDIF} then begin + case fFilterMin of + GL_NEAREST, GL_LINEAR: + glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin); + GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR: + glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR: + glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + end; + end else + glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin); + end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean); -var - BuildWithGlu, TexRec: Boolean; - TexSize: Integer; -begin - if Assigned(Data) then begin - // Check Texture Size - if (aTestTextureSize) then begin - glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); +procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum); - if (Width > TexSize) then - raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.'); + procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal); + begin + case aValue of +{$IFNDEF OPENGL_ES} + GL_CLAMP: + aTarget := GL_CLAMP; +{$ENDIF} - TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and - (Target = GL_TEXTURE_RECTANGLE); - if not (IsPowerOfTwo(Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then - raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.'); - end; + GL_REPEAT: + aTarget := GL_REPEAT; - CreateId; - SetupParameters(BuildWithGlu); - UploadData(BuildWithGlu); - glAreTexturesResident(1, @fID, @fIsResident); - end; -end; + GL_CLAMP_TO_EDGE: begin +{$IFNDEF OPENGL_ES} + if not GL_VERSION_1_2 and not GL_EXT_texture_edge_clamp then + aTarget := GL_CLAMP + else +{$ENDIF} + aTarget := GL_CLAMP_TO_EDGE; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap1D.AfterConstruction; -begin - inherited; - Target := GL_TEXTURE_1D; -end; +{$IFNDEF OPENGL_ES} + GL_CLAMP_TO_BORDER: begin + if GL_VERSION_1_3 or GL_ARB_texture_border_clamp then + aTarget := GL_CLAMP_TO_BORDER + else + aTarget := GL_CLAMP; + end; {$ENDIF} -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap2D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer; -begin - if (aIndex >= Low(fLines)) and (aIndex <= High(fLines)) then - result := fLines[aIndex] - else - result := nil; -end; +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_2_0)} + GL_MIRRORED_REPEAT: begin + {$IFNDEF OPENGL_ES} + if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then + {$ELSE} + if GL_VERSION_2_0 then + {$ENDIF} + aTarget := GL_MIRRORED_REPEAT + else + raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).'); + end; +{$IFEND} + else + raise EglBitmap.Create('SetWrap - Unknow Texturewrap'); + end; + end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; - const aWidth: Integer; const aHeight: Integer); -var - Idx, LineWidth: Integer; begin - inherited SetDataPointer(aData, aFormat, aWidth, aHeight); - - if not TFormatDescriptor.Get(aFormat).IsCompressed then begin - // Assigning Data - if Assigned(Data) then begin - SetLength(fLines, GetHeight); - LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).BytesPerPixel); + CheckAndSetWrap(S, fWrapS); + CheckAndSetWrap(T, fWrapT); + CheckAndSetWrap(R, fWrapR); - for Idx := 0 to GetHeight-1 do begin - fLines[Idx] := Data; - Inc(fLines[Idx], Idx * LineWidth); - end; - end - else SetLength(fLines, 0); - end else begin - SetLength(fLines, 0); + if (ID > 0) then begin + Bind(false); + glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS); + glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT); +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} + {$IFDEF OPENGL_ES} if GL_VERSION_3_0 then{$ENDIF} + glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR); +{$IFEND} end; end; +{$IF NOT DEFINED(OPENGL_ES) OR DEFINED(OPENGL_ES_3_0)} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.UploadData(const aTarget: GLenum{$IFNDEF OPENGL_ES}; const aBuildWithGlu: Boolean{$ENDIF}); -var - FormatDesc: TFormatDescriptor; -begin - FormatDesc := TFormatDescriptor.Get(Format); - if (FormatDesc.glInternalFormat = 0) or (FormatDesc.glDataFormat = 0) then - raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data'); +procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer); + begin + if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or + (aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then + fSwizzle[aIndex] := aValue + else + raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value'); + end; - if FormatDesc.IsCompressed then begin - if not Assigned(glCompressedTexImage2D) then - raise EglBitmap.Create('compressed formats not supported by video adapter'); - glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) +begin {$IFNDEF OPENGL_ES} - end else if aBuildWithGlu then begin - gluBuild2DMipmaps(aTarget, FormatDesc.ChannelCount, Width, Height, - FormatDesc.glFormat, FormatDesc.glDataFormat, Data) + if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then + raise EglBitmapNotSupported.Create('texture swizzle is not supported'); +{$ELSE} + if not GL_VERSION_3_0 then + raise EglBitmapNotSupported.Create('texture swizzle is not supported'); +{$ENDIF} + CheckAndSetValue(r, 0); + CheckAndSetValue(g, 1); + CheckAndSetValue(b, 2); + CheckAndSetValue(a, 3); + + if (ID > 0) then begin + Bind(false); +{$IFNDEF OPENGL_ES} + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0])); +{$ELSE} + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_R, PGLint(@fSwizzle[0])); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_G, PGLint(@fSwizzle[1])); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_B, PGLint(@fSwizzle[2])); + glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_A, PGLint(@fSwizzle[3])); {$ENDIF} - end else begin - glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, - FormatDesc.glFormat, FormatDesc.glDataFormat, Data); end; +end; +{$IFEND} - // Freigeben - if (FreeDataAfterGenTexture) then - FreeData; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean); +begin + if aEnableTextureUnit then + glEnable(Target); + if (ID > 0) then + glBindTexture(Target, ID); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.AfterConstruction; +procedure TglBitmap.Unbind(const aDisableTextureUnit: Boolean); begin - inherited; - Target := GL_TEXTURE_2D; + if aDisableTextureUnit then + glDisable(Target); + glBindTexture(Target, 0); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat); +procedure TglBitmap.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean); var - Temp: pByte; - Size, w, h: Integer; - FormatDesc: TFormatDescriptor; + w, h: Integer; begin - FormatDesc := TFormatDescriptor.Get(aFormat); - if FormatDesc.IsCompressed then - raise EglBitmapUnsupportedFormat.Create(aFormat); - - w := aRight - aLeft; - h := aBottom - aTop; - Size := FormatDesc.GetSize(w, h); - GetMem(Temp, Size); - try - glPixelStorei(GL_PACK_ALIGNMENT, 1); - glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp); - SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method - FlipVert; - except - if Assigned(Temp) then - FreeMem(Temp); - raise; - end; + w := aDataObj.Width; + h := aDataObj.Height; + fDimension.Fields := []; + if (w > 0) then + fDimension.Fields := fDimension.Fields + [ffX]; + if (h > 0) then + fDimension.Fields := fDimension.Fields + [ffY]; + fDimension.X := w; + fDimension.Y := h; end; {$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.GetDataFromTexture; +function TglBitmap.DownloadData(const aDataObj: TglBitmapData): Boolean; var Temp: PByte; TempWidth, TempHeight: Integer; @@ -8290,6 +8399,7 @@ var IntFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; begin + result := false; Bind; // Request Data @@ -8310,7 +8420,8 @@ begin glGetCompressedTexImage(Target, 0, Temp) end else glGetTexImage(Target, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp); - SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method + aDataObj.SetData(Temp, IntFormat, TempWidth, TempHeight); + result := true; except if Assigned(Temp) then FreeMem(Temp); @@ -8320,326 +8431,183 @@ end; {$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.GenTexture(const aTestTextureSize: Boolean); -var - {$IFNDEF OPENGL_ES} - BuildWithGlu, TexRec: Boolean; - {$ENDIF} - PotTex: Boolean; - TexSize: Integer; -begin - if Assigned(Data) then begin - // Check Texture Size - if (aTestTextureSize) then begin - glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); - - if ((Height > TexSize) or (Width > TexSize)) then - raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.'); - - PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width); -{$IF NOT DEFINED(OPENGL_ES)} - TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE); - if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then - raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); -{$ELSEIF DEFINED(OPENGL_ES_EXT)} - if not PotTex and not GL_OES_texture_npot then - raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); -{$ELSE} - if not PotTex then - raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); -{$IFEND} - end; - - CreateId; - SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF}); - UploadData(Target{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF}); -{$IFNDEF OPENGL_ES} - glAreTexturesResident(1, @fID, @fIsResident); -{$ENDIF} - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap2D.FlipHorz: Boolean; -var - Col, Row: Integer; - TempDestData, DestData, SourceData: PByte; - ImgSize: Integer; -begin - result := inherited FlipHorz; - if Assigned(Data) then begin - SourceData := Data; - ImgSize := Height * fRowSize; - GetMem(DestData, ImgSize); - try - TempDestData := DestData; - Dec(TempDestData, fRowSize + fPixelSize); - for Row := 0 to Height -1 do begin - Inc(TempDestData, fRowSize * 2); - for Col := 0 to Width -1 do begin - Move(SourceData^, TempDestData^, fPixelSize); - Inc(SourceData, fPixelSize); - Dec(TempDestData, fPixelSize); - end; - end; - SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method - result := true; - except - if Assigned(DestData) then - FreeMem(DestData); - raise; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TglBitmap2D.FlipVert: Boolean; -var - Row: Integer; - TempDestData, DestData, SourceData: PByte; -begin - result := inherited FlipVert; - if Assigned(Data) then begin - SourceData := Data; - GetMem(DestData, Height * fRowSize); - try - TempDestData := DestData; - Inc(TempDestData, Width * (Height -1) * fPixelSize); - for Row := 0 to Height -1 do begin - Move(SourceData^, TempDestData^, fRowSize); - Dec(TempDestData, fRowSize); - Inc(SourceData, fRowSize); - end; - SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method - result := true; - except - if Assigned(DestData) then - FreeMem(DestData); - raise; - end; - end; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TglBitmap2D - ToNormalMap/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -type - TMatrixItem = record - X, Y: Integer; - W: Single; - end; - - PglBitmapToNormalMapRec = ^TglBitmapToNormalMapRec; - TglBitmapToNormalMapRec = Record - Scale: Single; - Heights: array of Single; - MatrixU : array of TMatrixItem; - MatrixV : array of TMatrixItem; - end; - -const - ONE_OVER_255 = 1 / 255; - - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapToNormalMapPrepareFunc(var FuncRec: TglBitmapFunctionRec); -var - Val: Single; -begin - with FuncRec do begin - Val := - Source.Data.r * LUMINANCE_WEIGHT_R + - Source.Data.g * LUMINANCE_WEIGHT_G + - Source.Data.b * LUMINANCE_WEIGHT_B; - PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Val * ONE_OVER_255; - end; +constructor TglBitmap.Create; +begin + if (ClassType = TglBitmap) then + raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.'); + inherited Create; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapToNormalMapPrepareAlphaFunc(var FuncRec: TglBitmapFunctionRec); +constructor TglBitmap.Create(const aData: TglBitmapData); begin - with FuncRec do - PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Source.Data.a * ONE_OVER_255; + Create; + UploadData(aData); end; +{$IFNDEF OPENGL_ES} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapToNormalMapFunc (var FuncRec: TglBitmapFunctionRec); -type - TVec = Array[0..2] of Single; +//TglBitmap1D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.UploadDataIntern(const aDataObj: TglBitmapData; const aBuildWithGlu: Boolean); var - Idx: Integer; - du, dv: Double; - Len: Single; - Vec: TVec; + fd: TglBitmapFormatDescriptor; +begin + // Upload data + fd := aDataObj.FormatDescriptor; + if (fd.glFormat = 0) or (fd.glInternalFormat = 0) or (fd.glDataFormat = 0) then + raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data'); - function GetHeight(X, Y: Integer): Single; - begin - with FuncRec do begin - X := Max(0, Min(Size.X -1, X)); - Y := Max(0, Min(Size.Y -1, Y)); - result := PglBitmapToNormalMapRec(Args)^.Heights[Y * Size.X + X]; - end; - end; + if fd.IsCompressed then begin + if not Assigned(glCompressedTexImage1D) then + raise EglBitmap.Create('compressed formats not supported by video adapter'); + glCompressedTexImage1D(Target, 0, fd.glInternalFormat, aDataObj.Width, 0, fd.GetSize(aDataObj.Width, 1), aDataObj.Data) + end else if aBuildWithGlu then + gluBuild1DMipmaps(Target, fd.glInternalFormat, aDataObj.Width, fd.glFormat, fd.glDataFormat, aDataObj.Data) + else + glTexImage1D(Target, 0, fd.glInternalFormat, aDataObj.Width, 0, fd.glFormat, fd.glDataFormat, aDataObj.Data); +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.AfterConstruction; begin - with FuncRec do begin - with PglBitmapToNormalMapRec(Args)^ do begin - du := 0; - for Idx := Low(MatrixU) to High(MatrixU) do - du := du + GetHeight(Position.X + MatrixU[Idx].X, Position.Y + MatrixU[Idx].Y) * MatrixU[Idx].W; + inherited; + Target := GL_TEXTURE_1D; +end; - dv := 0; - for Idx := Low(MatrixU) to High(MatrixU) do - dv := dv + GetHeight(Position.X + MatrixV[Idx].X, Position.Y + MatrixV[Idx].Y) * MatrixV[Idx].W; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap1D.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean); +var + BuildWithGlu, TexRec: Boolean; + TexSize: Integer; +begin + if not Assigned(aDataObj) then + exit; - Vec[0] := -du * Scale; - Vec[1] := -dv * Scale; - Vec[2] := 1; - end; + // Check Texture Size + if (aCheckSize) then begin + glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); - // Normalize - Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2])); - if Len <> 0 then begin - Vec[0] := Vec[0] * Len; - Vec[1] := Vec[1] * Len; - Vec[2] := Vec[2] * Len; - end; + if (aDataObj.Width > TexSize) then + raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.'); - // Farbe zuweisem - Dest.Data.r := Trunc((Vec[0] + 1) * 127.5); - Dest.Data.g := Trunc((Vec[1] + 1) * 127.5); - Dest.Data.b := Trunc((Vec[2] + 1) * 127.5); + TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and + (Target = GL_TEXTURE_RECTANGLE); + if not (IsPowerOfTwo(aDataObj.Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then + raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.'); end; + + if (fID = 0) then + CreateID; + SetupParameters(BuildWithGlu); + UploadDataIntern(aDataObj, BuildWithGlu); + glAreTexturesResident(1, @fID, @fIsResident); + + inherited UploadData(aDataObj, aCheckSize); end; +{$ENDIF} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmap2D.GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean); +//TglBitmap2D///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum; const aBuildWithGlu: Boolean); var - Rec: TglBitmapToNormalMapRec; + fd: TglBitmapFormatDescriptor; +begin + fd := aDataObj.FormatDescriptor; + if (fd.glFormat = 0) or (fd.glInternalFormat = 0) or (fd.glDataFormat = 0) then + raise EglBitmap.Create('format is not supported by video adapter, please convert before uploading data'); - procedure SetEntry (var Matrix: array of TMatrixItem; Index, X, Y: Integer; W: Single); - begin - if (Index >= Low(Matrix)) and (Index <= High(Matrix)) then begin - Matrix[Index].X := X; - Matrix[Index].Y := Y; - Matrix[Index].W := W; - end; + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + if fd.IsCompressed then begin + if not Assigned(glCompressedTexImage2D) then + raise EglBitmap.Create('compressed formats not supported by video adapter'); + glCompressedTexImage2D(aTarget, 0, fd.glInternalFormat, aDataObj.Width, aDataObj.Height, 0, fd.GetSize(fDimension), aDataObj.Data) +{$IFNDEF OPENGL_ES} + end else if aBuildWithGlu then begin + gluBuild2DMipmaps(aTarget, fd.ChannelCount, aDataObj.Width, aDataObj.Height, fd.glFormat, fd.glDataFormat, aDataObj.Data) +{$ENDIF} + end else begin + glTexImage2D(aTarget, 0, fd.glInternalFormat, aDataObj.Width, aDataObj.Height, 0, fd.glFormat, fd.glDataFormat, aDataObj.Data); end; +end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.AfterConstruction; begin - if TFormatDescriptor.Get(Format).IsCompressed then - raise EglBitmapUnsupportedFormat.Create(Format); - - if aScale > 100 then - Rec.Scale := 100 - else if aScale < -100 then - Rec.Scale := -100 - else - Rec.Scale := aScale; - - SetLength(Rec.Heights, Width * Height); - try - case aFunc of - nm4Samples: begin - SetLength(Rec.MatrixU, 2); - SetEntry(Rec.MatrixU, 0, -1, 0, -0.5); - SetEntry(Rec.MatrixU, 1, 1, 0, 0.5); + inherited; + Target := GL_TEXTURE_2D; +end; - SetLength(Rec.MatrixV, 2); - SetEntry(Rec.MatrixV, 0, 0, 1, 0.5); - SetEntry(Rec.MatrixV, 1, 0, -1, -0.5); - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmap2D.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean); +var + {$IFNDEF OPENGL_ES} + BuildWithGlu, TexRec: Boolean; + {$ENDIF} + PotTex: Boolean; + TexSize: Integer; +begin + if not Assigned(aDataObj) then + exit; - nmSobel: begin - SetLength(Rec.MatrixU, 6); - SetEntry(Rec.MatrixU, 0, -1, 1, -1.0); - SetEntry(Rec.MatrixU, 1, -1, 0, -2.0); - SetEntry(Rec.MatrixU, 2, -1, -1, -1.0); - SetEntry(Rec.MatrixU, 3, 1, 1, 1.0); - SetEntry(Rec.MatrixU, 4, 1, 0, 2.0); - SetEntry(Rec.MatrixU, 5, 1, -1, 1.0); + // Check Texture Size + if (aCheckSize) then begin + glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize); - SetLength(Rec.MatrixV, 6); - SetEntry(Rec.MatrixV, 0, -1, 1, 1.0); - SetEntry(Rec.MatrixV, 1, 0, 1, 2.0); - SetEntry(Rec.MatrixV, 2, 1, 1, 1.0); - SetEntry(Rec.MatrixV, 3, -1, -1, -1.0); - SetEntry(Rec.MatrixV, 4, 0, -1, -2.0); - SetEntry(Rec.MatrixV, 5, 1, -1, -1.0); - end; + if ((aDataObj.Width > TexSize) or (aDataObj.Height > TexSize)) then + raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.'); - nm3x3: begin - SetLength(Rec.MatrixU, 6); - SetEntry(Rec.MatrixU, 0, -1, 1, -1/6); - SetEntry(Rec.MatrixU, 1, -1, 0, -1/6); - SetEntry(Rec.MatrixU, 2, -1, -1, -1/6); - SetEntry(Rec.MatrixU, 3, 1, 1, 1/6); - SetEntry(Rec.MatrixU, 4, 1, 0, 1/6); - SetEntry(Rec.MatrixU, 5, 1, -1, 1/6); + PotTex := IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height); +{$IF NOT DEFINED(OPENGL_ES)} + TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE); + if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then + raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); +{$ELSEIF DEFINED(OPENGL_ES_EXT)} + if not PotTex and not GL_OES_texture_npot then + raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); +{$ELSE} + if not PotTex then + raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.'); +{$IFEND} + end; - SetLength(Rec.MatrixV, 6); - SetEntry(Rec.MatrixV, 0, -1, 1, 1/6); - SetEntry(Rec.MatrixV, 1, 0, 1, 1/6); - SetEntry(Rec.MatrixV, 2, 1, 1, 1/6); - SetEntry(Rec.MatrixV, 3, -1, -1, -1/6); - SetEntry(Rec.MatrixV, 4, 0, -1, -1/6); - SetEntry(Rec.MatrixV, 5, 1, -1, -1/6); - end; + if (fID = 0) then + CreateID; + SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF}); + UploadDataIntern(aDataObj, Target{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF}); +{$IFNDEF OPENGL_ES} + glAreTexturesResident(1, @fID, @fIsResident); +{$ENDIF} - nm5x5: begin - SetLength(Rec.MatrixU, 20); - SetEntry(Rec.MatrixU, 0, -2, 2, -1 / 16); - SetEntry(Rec.MatrixU, 1, -1, 2, -1 / 10); - SetEntry(Rec.MatrixU, 2, 1, 2, 1 / 10); - SetEntry(Rec.MatrixU, 3, 2, 2, 1 / 16); - SetEntry(Rec.MatrixU, 4, -2, 1, -1 / 10); - SetEntry(Rec.MatrixU, 5, -1, 1, -1 / 8); - SetEntry(Rec.MatrixU, 6, 1, 1, 1 / 8); - SetEntry(Rec.MatrixU, 7, 2, 1, 1 / 10); - SetEntry(Rec.MatrixU, 8, -2, 0, -1 / 2.8); - SetEntry(Rec.MatrixU, 9, -1, 0, -0.5); - SetEntry(Rec.MatrixU, 10, 1, 0, 0.5); - SetEntry(Rec.MatrixU, 11, 2, 0, 1 / 2.8); - SetEntry(Rec.MatrixU, 12, -2, -1, -1 / 10); - SetEntry(Rec.MatrixU, 13, -1, -1, -1 / 8); - SetEntry(Rec.MatrixU, 14, 1, -1, 1 / 8); - SetEntry(Rec.MatrixU, 15, 2, -1, 1 / 10); - SetEntry(Rec.MatrixU, 16, -2, -2, -1 / 16); - SetEntry(Rec.MatrixU, 17, -1, -2, -1 / 10); - SetEntry(Rec.MatrixU, 18, 1, -2, 1 / 10); - SetEntry(Rec.MatrixU, 19, 2, -2, 1 / 16); + inherited UploadData(aDataObj, aCheckSize); +end; - SetLength(Rec.MatrixV, 20); - SetEntry(Rec.MatrixV, 0, -2, 2, 1 / 16); - SetEntry(Rec.MatrixV, 1, -1, 2, 1 / 10); - SetEntry(Rec.MatrixV, 2, 0, 2, 0.25); - SetEntry(Rec.MatrixV, 3, 1, 2, 1 / 10); - SetEntry(Rec.MatrixV, 4, 2, 2, 1 / 16); - SetEntry(Rec.MatrixV, 5, -2, 1, 1 / 10); - SetEntry(Rec.MatrixV, 6, -1, 1, 1 / 8); - SetEntry(Rec.MatrixV, 7, 0, 1, 0.5); - SetEntry(Rec.MatrixV, 8, 1, 1, 1 / 8); - SetEntry(Rec.MatrixV, 9, 2, 1, 1 / 16); - SetEntry(Rec.MatrixV, 10, -2, -1, -1 / 16); - SetEntry(Rec.MatrixV, 11, -1, -1, -1 / 8); - SetEntry(Rec.MatrixV, 12, 0, -1, -0.5); - SetEntry(Rec.MatrixV, 13, 1, -1, -1 / 8); - SetEntry(Rec.MatrixV, 14, 2, -1, -1 / 10); - SetEntry(Rec.MatrixV, 15, -2, -2, -1 / 16); - SetEntry(Rec.MatrixV, 16, -1, -2, -1 / 10); - SetEntry(Rec.MatrixV, 17, 0, -2, -0.25); - SetEntry(Rec.MatrixV, 18, 1, -2, -1 / 10); - SetEntry(Rec.MatrixV, 19, 2, -2, -1 / 16); - end; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +class procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData); +var + Temp: pByte; + Size, w, h: Integer; + FormatDesc: TFormatDescriptor; +begin + FormatDesc := TFormatDescriptor.Get(aFormat); + if FormatDesc.IsCompressed then + raise EglBitmapUnsupportedFormat.Create(aFormat); - // Daten Sammeln - if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then - Convert(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec) - else - Convert(glBitmapToNormalMapPrepareFunc, false, @Rec); - Convert(glBitmapToNormalMapFunc, false, @Rec); - finally - SetLength(Rec.Heights, 0); + w := aRight - aLeft; + h := aBottom - aTop; + Size := FormatDesc.GetSize(w, h); + GetMem(Temp, Size); + try + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp); + aDataObj.SetData(Temp, aFormat, w, h); + aDataObj.FlipVert; + except + if Assigned(Temp) then + FreeMem(Temp); + raise; end; end; @@ -8647,12 +8615,6 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TglBitmapCubeMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean); -begin - Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.'); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TglBitmapCubeMap.AfterConstruction; begin inherited; @@ -8673,35 +8635,43 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean); +procedure TglBitmapCubeMap.UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean); +begin + Assert(false, 'TglBitmapCubeMap.UploadData - Don''t call UploadData directly, use UploadCubeMap instead'); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapCubeMap.UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean); var {$IFNDEF OPENGL_ES} BuildWithGlu: Boolean; {$ENDIF} TexSize: Integer; begin - if (aTestTextureSize) then begin + if (aCheckSize) then begin glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize); - if (Height > TexSize) or (Width > TexSize) then + if (aDataObj.Width > TexSize) or (aDataObj.Height > TexSize) then raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenerateCubeMap - The size for the Cubemap is to large. It''s may be not conform with the Hardware.'); {$IF NOT DEFINED(OPENGL_ES)} - if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then + if not ((IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.'); {$ELSEIF DEFINED(OPENGL_ES_EXT)} - if not (IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) and not GL_OES_texture_npot then + if not (IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) and not GL_OES_texture_npot then raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.'); {$ELSE} - if not (IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) then + if not (IsPowerOfTwo(aDataObj.Width) and IsPowerOfTwo(aDataObj.Height)) then raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenerateCubeMap - Cubemaps dosn''t support non power of two texture.'); {$IFEND} end; - if (ID = 0) then + if (fID = 0) then CreateID; SetupParameters({$IFNDEF OPENGL_ES}BuildWithGlu{$ENDIF}); - UploadData(aCubeTarget{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF}); + UploadDataIntern(aDataObj, aCubeTarget{$IFNDEF OPENGL_ES}, BuildWithGlu{$ENDIF}); + + inherited UploadData(aDataObj, aCheckSize); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -8837,47 +8807,52 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean); +procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aCheckSize: Boolean); var Rec: TglBitmapNormalMapRec; SizeRec: TglBitmapSize; + DataObj: TglBitmapData; begin Rec.HalfSize := aSize div 2; - FreeDataAfterGenTexture := false; SizeRec.Fields := [ffX, ffY]; SizeRec.X := aSize; SizeRec.Y := aSize; - // Positive X - Rec.Func := glBitmapNormalMapPosX; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize); - - // Negative X - Rec.Func := glBitmapNormalMapNegX; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize); - - // Positive Y - Rec.Func := glBitmapNormalMapPosY; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize); - - // Negative Y - Rec.Func := glBitmapNormalMapNegY; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize); - - // Positive Z - Rec.Func := glBitmapNormalMapPosZ; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize); - - // Negative Z - Rec.Func := glBitmapNormalMapNegZ; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); - GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize); + DataObj := TglBitmapData.Create; + try + // Positive X + Rec.Func := glBitmapNormalMapPosX; + DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec); + UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_X, aCheckSize); + + // Negative X + Rec.Func := glBitmapNormalMapNegX; + DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec); + UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aCheckSize); + + // Positive Y + Rec.Func := glBitmapNormalMapPosY; + DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec); + UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aCheckSize); + + // Negative Y + Rec.Func := glBitmapNormalMapNegY; + DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec); + UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aCheckSize); + + // Positive Z + Rec.Func := glBitmapNormalMapPosZ; + DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec); + UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aCheckSize); + + // Negative Z + Rec.Func := glBitmapNormalMapNegZ; + DataObj.LoadFromFunc(SizeRec, tfBGR8ub3, glBitmapNormalMapFunc, @Rec); + UploadCubeMap(DataObj, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aCheckSize); + finally + FreeAndNil(DataObj); + end; end; {$IFEND} -- 2.1.4

	`function GetScanline(const aIndex: Integer): Pointer;`
	`procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;`
	`procedure UploadData(const aTarget: GLenum);`	`procedure UploadDataIntern(const aDataObj: TglBitmapData; const aTarget: GLenum );`

	`procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);`	`procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat; const aDataObj: TglBitmapData);`
	`procedure GenTexture(const aTestTextureSize: Boolean = true); override;`
	`function FlipHorz: Boolean; override;`
	`function FlipVert: Boolean; override;`
	`procedure GenerateNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3; const aScale: Single = 2; const aUseAlpha: Boolean = false);`	`procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;`

`procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce;`		`procedure AfterConstruction; override;`
`procedure AfterConstruction; override;`	`procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); override;`
`procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true);`	`procedure UploadCubeMap(const aDataObj: TglBitmapData; const aCubeTarget: Cardinal; const aCheckSize: Boolean);`

	`function GetFormatDesc: TglBitmapFormatDescriptor;`
	`function GetWidth: Integer; virtual;`
	`function GetHeight: Integer; virtual;`
	`function GetFileWidth: Integer; virtual;`	`function GetHeight: Integer; virtual;`
	`function GetFileHeight: Integer; virtual;`
	`procedure SetCustomData(const aValue: Pointer);`
	`procedure SetCustomName(const aValue: String);`
	`procedure SetCustomNameW(const aValue: WideString);`	`procedure SetCustomName(const aValue: String);`
	`procedure SetFreeDataOnDestroy(const aValue: Boolean);`	`procedure SetCustomNameW(const aValue: WideString);`

	`procedure SetFormat(const aValue: TglBitmapFormat);`
	`procedure SetFreeDataAfterGenTexture(const aValue: Boolean);`
	`procedure SetID(const aValue: Cardinal);`
`procedure SetupParameters();`
	`procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat; const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;`
	`procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;`
	`function FlipHorz: Boolean; virtual;`
	`function FlipVert: Boolean; virtual;`
	`procedure AfterConstruction; override;`
	`procedure PrepareResType(var aResource: String; var aResType: PChar);`
	`procedure LoadFromFile(const aFilename: String);`
	`procedure LoadFromStream(const aStream: TStream); virtual;`
	`procedure LoadFromFunc(const aSize: TglBitmapSize; const aFunc: TglBitmapFunction; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);`
	`procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);`
	`procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);`
	`procedure SaveToFile(const aFilename: String; const aFileType: TglBitmapFileType);`
	`procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;`
	`function Convert(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;`
	`function Convert(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean; const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;`
	`function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;`
	`function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;`
	`function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;`
	`function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;`
	`function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;`
	`function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;`
	`function AddAlphaFromValue(const aAlpha: Byte): Boolean;`
	`function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;`
	`function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;`
	`function RemoveAlpha: Boolean; virtual;`
	`function Clone: TglBitmap;`
	`procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false);`
	`procedure FreeData;`
	`procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);`
	`procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);`
	`procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single = 1.0);`
	`procedure SetFilter(const aMin, aMag: GLenum);`
	`constructor Create; overload;`
	`constructor Create(const aFileName: String); overload;`
	`constructor Create(const aStream: TStream); overload;`
	`constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;`
	`constructor Create(const aSize: TglBitmapSize; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;`	`procedure UploadData(const aDataObj: TglBitmapData; const aCheckSize: Boolean = true); virtual;`
	`constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;`	`constructor Create; overload;`
	`constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;`
	`function LoadRAW(const aStream: TStream): Boolean;`
	`procedure SaveRAW(const aStream: TStream);`
	`function LoadBMP(const aStream: TStream): Boolean;`
	`procedure SaveBMP(const aStream: TStream);`
	`function LoadTGA(const aStream: TStream): Boolean;`
	`procedure SaveTGA(const aStream: TStream);`
	`function LoadDDS(const aStream: TStream): Boolean;`
	`procedure SaveDDS(const aStream: TStream);`	`constructor Create(const aData: TglBitmapData); overload;`

	`fFilterMin: GLenum;`
- -min filter to apply to the texture -

	`fFilterMag: GLenum;`
- -mag filter to apply to the texture -

	`procedure SetCustomData(const aValue: Pointer);`
@@ -798,742 +433,102 @@ set a new value for fCustomName

	`procedure SetCustomNameW(const aValue: WideString);`
- -set a new value for fCustomNameW -

	`procedure SetFreeDataOnDestroy(const aValue: Boolean);`
- -set new value for fFreeDataOnDestroy -

	`procedure SetDeleteTextureOnFree(const aValue: Boolean);`
- -set new value for fDeleteTextureOnFree -

	`procedure SetFormat(const aValue: TglBitmapFormat);`
- -set new value for the data format. only possible if new format has the same pixel size. if you want to convert the texture data, see ConvertTo function -

	`procedure SetFreeDataAfterGenTexture(const aValue: Boolean);`
- -set new value for fFreeDataAfterGenTexture -

	`procedure SetID(const aValue: Cardinal);`
- -set name of OpenGL texture object -

	`procedure SetMipMap(const aValue: TglBitmapMipMap);`
- -set new value for fMipMap -

	`procedure SetTarget(const aValue: Cardinal);`
- -set new value for target -

	`procedure SetAnisotropic(const aValue: Integer);`
- -set new value for fAnisotrophic -

	`procedure CreateID;`
- -create OpenGL texture object (delete exisiting object if exists) -

	`procedure AfterConstruction; override;`
- -this method is called after the constructor and sets the default values of this object -

	`procedure BeforeDestruction; override;`
- -this method is called before the destructor and does some cleanup -

	`constructor Create; overload;`
- -constructor - created an empty texture -

	`property FileWidth: Integer read GetFileWidth;`
- -the width of the texture or 1 if the width is zero -

	`property FileHeight: Integer read GetFileHeight;`
- -the height of the texture or 1 if the height is zero -

	`fLines: array of PByte;`
- -array to store scanline entry points in -

All Variables

Hierarchy

Hierarchy

Hierarchy

Hierarchy

Description

Hierarchy

Overview

Methods

Properties

Description

Fields

Methods

Returns

Returns

Returns

Parameters

Parameters

Returns

Returns

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Returns

Returns

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Returns

Parameters

Parameters

Returns

Parameters

Parameters

Returns

Parameters

Parameters

	`property Scanline[constaIndex:Integer]: Pointer read GetScanline;`
- -scanline to access texture data directly -