opengl
/
glBitmap
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

* added Swizzle Support 

* updated native OpenGL Support
master
Bergmann89 10 years ago
parent
5bce73c919
commit
370c0fbe8e
1 changed files with 184 additions and 92 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +184
    -92
      glBitmap.pas

+ 184
- 92
glBitmap.pas View File

@@ -375,21 +375,19 @@ unit glBitmap;
interface

uses
{$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF}
{$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF}
{$IF DEFINED(GLB_WIN) AND
DEFINED(GLB_NATIVE_OGL)} windows, {$IFEND}
DEFINED(GLB_NATIVE_OGL)} windows, {$IFEND}

{$IFDEF GLB_SDL} SDL, {$ENDIF}
{$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, {$ENDIF}
{$IFDEF GLB_DELPHI} Dialogs, Graphics, {$ENDIF}
{$IFDEF GLB_SDL} SDL, {$ENDIF}
{$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, {$ENDIF}
{$IFDEF GLB_DELPHI} Dialogs, Graphics, {$ENDIF}

{$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF}

{$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF}
{$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF}

{$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF}
{$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF}
{$IFDEF GLB_SDL_IMAGE} SDL_image, {$ENDIF}
{$IFDEF GLB_PNGIMAGE} pngimage, {$ENDIF}
{$IFDEF GLB_LIB_PNG} libPNG, {$ENDIF}
{$IFDEF GLB_DELPHI_JPEG} JPEG, {$ENDIF}
{$IFDEF GLB_LIB_JPEG} libJPEG, {$ENDIF}

Classes, SysUtils;

@@ -398,6 +396,9 @@ const
GL_TRUE = 1;
GL_FALSE = 0;

GL_ZERO = 0;
GL_ONE = 1;

GL_VERSION = $1F02;
GL_EXTENSIONS = $1F03;

@@ -405,9 +406,34 @@ const
GL_TEXTURE_2D = $0DE1;
GL_TEXTURE_RECTANGLE = $84F5;

GL_NORMAL_MAP = $8511;
GL_TEXTURE_CUBE_MAP = $8513;
GL_REFLECTION_MAP = $8512;
GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515;
GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516;
GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517;
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518;
GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519;
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A;

GL_TEXTURE_WIDTH = $1000;
GL_TEXTURE_HEIGHT = $1001;
GL_TEXTURE_INTERNAL_FORMAT = $1003;
GL_TEXTURE_SWIZZLE_RGBA = $8E46;

GL_S = $2000;
GL_T = $2001;
GL_R = $2002;
GL_Q = $2003;

GL_TEXTURE_GEN_S = $0C60;
GL_TEXTURE_GEN_T = $0C61;
GL_TEXTURE_GEN_R = $0C62;
GL_TEXTURE_GEN_Q = $0C63;

GL_RED = $1903;
GL_GREEN = $1904;
GL_BLUE = $1905;

GL_ALPHA = $1906;
GL_ALPHA4 = $803B;
@@ -509,6 +535,8 @@ const

GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C;
GL_TEXTURE_GEN_MODE = $2500;

{$IF DEFINED(GLB_WIN)}
libglu = 'glu32.dll';
@@ -551,12 +579,14 @@ type
TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}

TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}

TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
@@ -580,12 +610,14 @@ type
procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;

procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;

procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
@@ -607,6 +639,7 @@ var
GL_VERSION_1_3,
GL_VERSION_1_4,
GL_VERSION_2_0,
GL_VERSION_3_3,

GL_SGIS_generate_mipmap,

@@ -614,6 +647,8 @@ var
GL_ARB_texture_mirrored_repeat,
GL_ARB_texture_rectangle,
GL_ARB_texture_non_power_of_two,
GL_ARB_texture_swizzle,
GL_ARB_texture_cube_map,

GL_IBM_texture_mirrored_repeat,

@@ -621,6 +656,8 @@ var

GL_EXT_texture_edge_clamp,
GL_EXT_texture_rectangle,
GL_EXT_texture_swizzle,
GL_EXT_texture_cube_map,
GL_EXT_texture_filter_anisotropic: Boolean;

glCompressedTexImage1D: TglCompressedTexImage1D;
@@ -642,12 +679,14 @@ var
glGetIntegerv: TglGetIntegerv;

glTexParameteri: TglTexParameteri;
glTexParameteriv: TglTexParameteriv;
glTexParameterfv: TglTexParameterfv;
glGetTexParameteriv: TglGetTexParameteriv;
glGetTexParameterfv: TglGetTexParameterfv;
glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
glGetTexLevelParameterfv: TglGetTexLevelParameterfv;

glTexGeni: TglTexGeni;
glGenTextures: TglGenTextures;
glBindTexture: TglBindTexture;
glDeleteTextures: TglDeleteTextures;
@@ -749,10 +788,11 @@ type
nm5x5);

////////////////////////////////////////////////////////////////////////////////////////////////////
EglBitmapException = class(Exception);
EglBitmapSizeToLargeException = class(EglBitmapException);
EglBitmapNonPowerOfTwoException = class(EglBitmapException);
EglBitmapUnsupportedFormat = class(EglBitmapException)
EglBitmap = class(Exception);
EglBitmapNotSupported = class(Exception);
EglBitmapSizeToLarge = class(EglBitmap);
EglBitmapNonPowerOfTwo = class(EglBitmap);
EglBitmapUnsupportedFormat = class(EglBitmap)
constructor Create(const aFormat: TglBitmapFormat); overload;
constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
end;
@@ -811,13 +851,16 @@ type
fRowSize: Integer;

// Filtering
fFilterMin: Cardinal;
fFilterMag: Cardinal;
fFilterMin: GLenum;
fFilterMag: GLenum;

// TexturWarp
fWrapS: Cardinal;
fWrapT: Cardinal;
fWrapR: Cardinal;
fWrapS: GLenum;
fWrapT: GLenum;
fWrapR: GLenum;

//Swizzle
fSwizzle: array[0..3] of GLenum;

// CustomData
fFilename: String;
@@ -958,11 +1001,12 @@ type
procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1);

//TexParameters
procedure SetFilter(const aMin, aMag: Cardinal);
procedure SetFilter(const aMin, aMag: GLenum);
procedure SetWrap(
const S: Cardinal = GL_CLAMP_TO_EDGE;
const T: Cardinal = GL_CLAMP_TO_EDGE;
const R: Cardinal = GL_CLAMP_TO_EDGE);
const S: GLenum = GL_CLAMP_TO_EDGE;
const T: GLenum = GL_CLAMP_TO_EDGE;
const R: GLenum = GL_CLAMP_TO_EDGE);
procedure SetSwizzle(const r, g, b, a: GLenum);

procedure Bind(const aEnableTextureUnit: Boolean = true); virtual;
procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;
@@ -1084,6 +1128,7 @@ var
glBitmapDefaultWrapS: Cardinal;
glBitmapDefaultWrapT: Cardinal;
glBitmapDefaultWrapR: Cardinal;
glDefaultSwizzle: array[0..3] of GLenum;

{$IFDEF GLB_DELPHI}
function CreateGrayPalette: HPALETTE;
@@ -1839,7 +1884,7 @@ begin
result := dlsym(aLibHandle, aProcName);
{$IFEND}
if not Assigned(result) then
raise EglBitmapException.Create('unable to load procedure form library: ' + aProcName);
raise EglBitmap.Create('unable to load procedure form library: ' + aProcName);
end;

{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
@@ -1886,11 +1931,11 @@ begin

GL_LibHandle := glbLoadLibrary(libopengl);
if not Assigned(GL_LibHandle) then
raise EglBitmapException.Create('unable to load library: ' + libopengl);
raise EglBitmap.Create('unable to load library: ' + libopengl);

GLU_LibHandle := glbLoadLibrary(libglu);
if not Assigned(GLU_LibHandle) then
raise EglBitmapException.Create('unable to load library: ' + libglu);
raise EglBitmap.Create('unable to load library: ' + libglu);

try
{$IF DEFINED(GLB_WIN)}
@@ -1905,11 +1950,13 @@ begin
glGetString := glbGetProcAddress('glGetString');
glGetIntegerv := glbGetProcAddress('glGetIntegerv');
glTexParameteri := glbGetProcAddress('glTexParameteri');
glTexParameteriv := glbGetProcAddress('glTexParameteriv');
glTexParameterfv := glbGetProcAddress('glTexParameterfv');
glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv');
glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv');
glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv');
glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv');
glTexGeni := glbGetProcAddress('glTexGeni');
glGenTextures := glbGetProcAddress('glGenTextures');
glBindTexture := glbGetProcAddress('glBindTexture');
glDeleteTextures := glbGetProcAddress('glDeleteTextures');
@@ -1977,6 +2024,12 @@ var
result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']);
end;

///////////////////////////////////////////////////////////////////////////////////////////
function CheckVersion(const aMajor, aMinor: Integer): Boolean;
begin
result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor));
end;

begin
{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
InitOpenGLCS.Enter;
@@ -1994,35 +2047,25 @@ begin
Buffer := glGetString(GL_VERSION);
TrimVersionString(Buffer, MajorVersion, MinorVersion);

GL_VERSION_1_2 := false;
GL_VERSION_1_3 := false;
GL_VERSION_1_4 := false;
GL_VERSION_2_0 := false;
if MajorVersion = 1 then begin
if MinorVersion >= 2 then
GL_VERSION_1_2 := true;

if MinorVersion >= 3 then
GL_VERSION_1_3 := true;

if MinorVersion >= 4 then
GL_VERSION_1_4 := true;
end else if MajorVersion >= 2 then begin
GL_VERSION_1_2 := true;
GL_VERSION_1_3 := true;
GL_VERSION_1_4 := true;
GL_VERSION_2_0 := true;
end;
GL_VERSION_1_2 := CheckVersion(1, 2);
GL_VERSION_1_3 := CheckVersion(1, 3);
GL_VERSION_1_4 := CheckVersion(1, 4);
GL_VERSION_2_0 := CheckVersion(2, 0);
GL_VERSION_3_3 := CheckVersion(3, 3);

// Extensions
Buffer := glGetString(GL_EXTENSIONS);
GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp');
GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two');
GL_ARB_texture_swizzle := CheckExtension('GL_ARB_texture_swizzle');
GL_ARB_texture_cube_map := CheckExtension('GL_ARB_texture_cube_map');
GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle');
GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat');
GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp');
GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');
GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle');
GL_EXT_texture_swizzle := CheckExtension('GL_EXT_texture_swizzle');
GL_EXT_texture_cube_map := CheckExtension('GL_EXT_texture_cube_map');
GL_NV_texture_rectangle := CheckExtension('GL_NV_texture_rectangle');
GL_IBM_texture_mirrored_repeat := CheckExtension('GL_IBM_texture_mirrored_repeat');
GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap');
@@ -2117,6 +2160,15 @@ begin
glBitmapDefaultWrapR := R;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
begin
glDefaultSwizzle[0] := r;
glDefaultSwizzle[1] := g;
glDefaultSwizzle[2] := b;
glDefaultSwizzle[3] := a;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
begin
@@ -2142,20 +2194,29 @@ begin
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
procedure glBitmapGetDefaultFilter(var aMin, aMag: GLenum);
begin
aMin := glBitmapDefaultFilterMin;
aMag := glBitmapDefaultFilterMag;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum);
begin
S := glBitmapDefaultWrapS;
T := glBitmapDefaultWrapT;
R := glBitmapDefaultWrapR;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
begin
r := glDefaultSwizzle[0];
g := glDefaultSwizzle[1];
b := glDefaultSwizzle[2];
a := glDefaultSwizzle[3];
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2244,7 +2305,7 @@ function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlp
begin
result := false;
if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then
raise EglBitmapException.Create('FormatCheckFormat - All Masks are 0');
raise EglBitmap.Create('FormatCheckFormat - All Masks are 0');
if (aRedMask <> RedMask) then
exit;
if (aGreenMask <> GreenMask) then
@@ -3445,12 +3506,12 @@ end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
begin
raise EglBitmapException.Create('mapping for compressed formats is not supported');
raise EglBitmap.Create('mapping for compressed formats is not supported');
end;

procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
begin
raise EglBitmapException.Create('mapping for compressed formats is not supported');
raise EglBitmap.Create('mapping for compressed formats is not supported');
end;

constructor TfdS3tcDtx1RGBA.Create;
@@ -3471,12 +3532,12 @@ end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
begin
raise EglBitmapException.Create('mapping for compressed formats is not supported');
raise EglBitmap.Create('mapping for compressed formats is not supported');
end;

procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
begin
raise EglBitmapException.Create('mapping for compressed formats is not supported');
raise EglBitmap.Create('mapping for compressed formats is not supported');
end;

constructor TfdS3tcDtx3RGBA.Create;
@@ -3497,12 +3558,12 @@ end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
begin
raise EglBitmapException.Create('mapping for compressed formats is not supported');
raise EglBitmap.Create('mapping for compressed formats is not supported');
end;

procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
begin
raise EglBitmapException.Create('mapping for compressed formats is not supported');
raise EglBitmap.Create('mapping for compressed formats is not supported');
end;

constructor TfdS3tcDtx5RGBA.Create;
@@ -3635,7 +3696,7 @@ begin
4: PCardinal(aData)^ := data;
8: PQWord(aData)^ := data;
else
raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
end;
inc(aData, s);
end;
@@ -3653,7 +3714,7 @@ begin
4: data := PCardinal(aData)^;
8: data := PQWord(aData)^;
else
raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
end;
for i := 0 to 3 do
aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i];
@@ -3668,7 +3729,7 @@ var
i: Integer;
begin
if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
raise EglBitmapException.Create(UNSUPPORTED_FORMAT);
raise EglBitmap.Create(UNSUPPORTED_FORMAT);

if (Format = tfLuminance4) then
SetLength(fColorTable, 16)
@@ -3711,7 +3772,7 @@ var
d: Byte;
begin
if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
raise EglBitmapException.Create(UNSUPPORTED_FORMAT);
raise EglBitmap.Create(UNSUPPORTED_FORMAT);

case Format of
tfLuminance4: begin
@@ -3759,10 +3820,10 @@ begin
4: idx := PCardinal(aData)^;
8: idx := PQWord(aData)^;
else
raise EglBitmapException.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
end;
if (idx >= Length(fColorTable)) then
raise EglBitmapException.CreateFmt('invalid color index: %d', [idx]);
raise EglBitmap.CreateFmt('invalid color index: %d', [idx]);
with fColorTable[idx] do begin
aPixel.Data.r := r;
aPixel.Data.g := g;
@@ -4087,6 +4148,9 @@ begin
SetAnisotropic(fAnisotropic);
SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);

if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);

// Mip Maps Generation Mode
aBuildWithGlu := false;
if (MipMap = mmMipmap) then begin
@@ -4163,6 +4227,7 @@ begin

glBitmapGetDefaultFilter (fFilterMin, fFilterMag);
glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -4195,7 +4260,7 @@ var
fs: TFileStream;
begin
if not FileExists(aFilename) then
raise EglBitmapException.Create('file does not exist: ' + aFilename);
raise EglBitmap.Create('file does not exist: ' + aFilename);
fFilename := aFilename;
fs := TFileStream.Create(fFilename, fmOpenRead);
try
@@ -4218,7 +4283,7 @@ begin
if not LoadDDS(aStream) then
if not LoadTGA(aStream) then
if not LoadBMP(aStream) then
raise EglBitmapException.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -5293,7 +5358,7 @@ begin
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TglBitmap.SetFilter(const aMin, aMag: Cardinal);
procedure TglBitmap.SetFilter(const aMin, aMag: GLenum);
begin
//check MIN filter
case aMin of
@@ -5310,7 +5375,7 @@ begin
GL_LINEAR_MIPMAP_LINEAR:
fFilterMin := GL_LINEAR_MIPMAP_LINEAR;
else
raise EglBitmapException.Create('SetFilter - Unknow MIN filter.');
raise EglBitmap.Create('SetFilter - Unknow MIN filter.');
end;

//check MAG filter
@@ -5320,7 +5385,7 @@ begin
GL_LINEAR:
fFilterMag := GL_LINEAR;
else
raise EglBitmapException.Create('SetFilter - Unknow MAG filter.');
raise EglBitmap.Create('SetFilter - Unknow MAG filter.');
end;

//apply filter
@@ -5343,7 +5408,7 @@ begin
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TglBitmap.SetWrap(const S: Cardinal; const T: Cardinal; const R: Cardinal);
procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum);

procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal);
begin
@@ -5372,10 +5437,10 @@ procedure TglBitmap.SetWrap(const S: Cardinal; const T: Cardinal; const R: Cardi
if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then
aTarget := GL_MIRRORED_REPEAT
else
raise EglBitmapException.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
end;
else
raise EglBitmapException.Create('SetWrap - Unknow Texturewrap (S).');
raise EglBitmap.Create('SetWrap - Unknow Texturewrap');
end;
end;

@@ -5392,6 +5457,32 @@ begin
end;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum);

procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer);
begin
if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or
(aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then
fSwizzle[aIndex] := aValue
else
raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value');
end;

begin
if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
raise EglBitmapNotSupported.Create('texture swizzle is not supported');
CheckAndSetValue(r, 0);
CheckAndSetValue(g, 1);
CheckAndSetValue(b, 2);
CheckAndSetValue(a, 3);

if (ID > 0) then begin
Bind(false);
glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, @fSwizzle[0]);
end;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean);
begin
@@ -5413,7 +5504,7 @@ end;
constructor TglBitmap.Create;
begin
if (ClassType = TglBitmap) then
raise EglBitmapException.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
{$IFDEF GLB_NATIVE_OGL}
glbReadOpenGLExtensions;
{$ENDIF}
@@ -6373,7 +6464,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
case aInfo.biCompression of
BMP_COMP_RLE4,
BMP_COMP_RLE8: begin
raise EglBitmapException.Create('RLE compression is not supported');
raise EglBitmap.Create('RLE compression is not supported');
end;
BMP_COMP_BITFIELDS: begin
if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin
@@ -6382,7 +6473,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
aStream.Read(aMask.b, SizeOf(aMask.b));
aStream.Read(aMask.a, SizeOf(aMask.a));
end else
raise EglBitmapException.Create('Bitfields are only supported for 16bit and 32bit formats');
raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats');
end;
end;

@@ -6551,7 +6642,7 @@ begin
raise;
end;
end else
raise EglBitmapException.Create('LoadBMP - No suitable format found');
raise EglBitmap.Create('LoadBMP - No suitable format found');
except
aStream.Position := StartPos;
raise;
@@ -6989,7 +7080,7 @@ begin
end;

if (tgaFormat = tfEmpty) then
raise EglBitmapException.Create('LoadTga - unsupported format');
raise EglBitmap.Create('LoadTga - unsupported format');

FormatDesc := TFormatDescriptor.Get(tgaFormat);
PixelSize := FormatDesc.GetSize(1, 1);
@@ -7099,11 +7190,11 @@ begin
Size := FormatDesc.GetSize(Dimension);
if Format in [tfRGB5, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin
if (FormatDesc.RGBInverted = tfEmpty) then
raise EglBitmapException.Create('inverted RGB format is empty');
raise EglBitmap.Create('inverted RGB format is empty');
Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted);
if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or
(Converter.PixelSize <> FormatDesc.PixelSize) then
raise EglBitmapException.Create('invalid inverted RGB format');
raise EglBitmap.Create('invalid inverted RGB format');
end;

if Assigned(Converter) then begin
@@ -7295,12 +7386,12 @@ begin
end;

if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then
raise EglBitmapException.Create('LoadDDS - CubeMaps are not supported');
raise EglBitmap.Create('LoadDDS - CubeMaps are not supported');

ddsFormat := GetDDSFormat;
try
if (ddsFormat = tfEmpty) then
raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.');
raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');

FormatDesc := TFormatDescriptor.Get(ddsFormat);
LineSize := Trunc(Header.dwWidth * FormatDesc.PixelSize);
@@ -7350,7 +7441,7 @@ begin
Inc(TmpData, LineSize);
end;
end else
raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.');
raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');

SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method
result := true;
@@ -7505,12 +7596,12 @@ begin
glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);

if (Width > TexSize) then
raise EglBitmapSizeToLargeException.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');

TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
(Target = GL_TEXTURE_RECTANGLE_ARB);
(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 EglBitmapNonPowerOfTwoException.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
end;

CreateId;
@@ -7673,12 +7764,12 @@ begin
glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);

if ((Height > TexSize) or (Width > TexSize)) then
raise EglBitmapSizeToLargeException.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');

PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width);
TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);
if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
raise EglBitmapNonPowerOfTwoException.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
end;

CreateId;
@@ -7986,7 +8077,7 @@ begin
inherited;

if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then
raise EglBitmapException.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');

SetWrap;
Target := GL_TEXTURE_CUBE_MAP;
@@ -8003,10 +8094,10 @@ begin
glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize);

if (Height > TexSize) or (Width > TexSize) then
raise EglBitmapSizeToLargeException.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');

if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
raise EglBitmapNonPowerOfTwoException.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.');
raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.');
end;

if (ID = 0) then
@@ -8185,10 +8276,11 @@ end;


initialization
glBitmapSetDefaultFormat(tfEmpty);
glBitmapSetDefaultMipmap(mmMipmap);
glBitmapSetDefaultFilter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
glBitmapSetDefaultWrap (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
glBitmapSetDefaultFormat (tfEmpty);
glBitmapSetDefaultMipmap (mmMipmap);
glBitmapSetDefaultFilter (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
glBitmapSetDefaultWrap (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA);

glBitmapSetDefaultFreeDataAfterGenTexture(true);
glBitmapSetDefaultDeleteTextureOnFree (true);


Write Preview
Loading…
Cancel
Save