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;
GL_TRUE = 1;
GL_FALSE = 0;
+ GL_ZERO = 0;
+ GL_ONE = 1;
+
GL_VERSION = $1F02;
GL_EXTENSIONS = $1F03;
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;
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';
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}
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;
GL_VERSION_1_3,
GL_VERSION_1_4,
GL_VERSION_2_0,
+ GL_VERSION_3_3,
GL_SGIS_generate_mipmap,
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,
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;
glGetIntegerv: TglGetIntegerv;
glTexParameteri: TglTexParameteri;
+ glTexParameteriv: TglTexParameteriv;
glTexParameterfv: TglTexParameterfv;
glGetTexParameteriv: TglGetTexParameteriv;
glGetTexParameterfv: TglGetTexParameterfv;
glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
+ glTexGeni: TglTexGeni;
glGenTextures: TglGenTextures;
glBindTexture: TglBindTexture;
glDeleteTextures: TglDeleteTextures;
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;
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;
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;
glBitmapDefaultWrapS: Cardinal;
glBitmapDefaultWrapT: Cardinal;
glBitmapDefaultWrapR: Cardinal;
+ glDefaultSwizzle: array[0..3] of GLenum;
{$IFDEF GLB_DELPHI}
function CreateGrayPalette: HPALETTE;
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}
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)}
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');
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;
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');
end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
+begin
+ glDefaultSwizzle[0] := r;
+ glDefaultSwizzle[1] := g;
+ glDefaultSwizzle[2] := b;
+ glDefaultSwizzle[3] := a;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
begin
result := glBitmapDefaultDeleteTextureOnFree;
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;
end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
+begin
+ r := glDefaultSwizzle[0];
+ g := glDefaultSwizzle[1];
+ b := glDefaultSwizzle[2];
+ a := glDefaultSwizzle[3];
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TFormatDescriptor.GetRedMask: QWord;
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
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
begin
- raise EglBitmapException.Create('mapping for compressed formats is not supported');
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
end;
procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
begin
- raise EglBitmapException.Create('mapping for compressed formats is not supported');
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
end;
constructor TfdS3tcDtx1RGBA.Create;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
begin
- raise EglBitmapException.Create('mapping for compressed formats is not supported');
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
end;
procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
begin
- raise EglBitmapException.Create('mapping for compressed formats is not supported');
+ raise EglBitmap.Create('mapping for compressed formats is not supported');
end;
constructor TfdS3tcDtx3RGBA.Create;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure 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;
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;
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];
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)
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
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;
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
glBitmapGetDefaultFilter (fFilterMin, fFilterMag);
glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
+ glBitmapGetDefaultSwizzle (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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
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;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetFilter(const aMin, aMag: Cardinal);
+procedure TglBitmap.SetFilter(const aMin, aMag: GLenum);
begin
//check MIN filter
case aMin of
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
GL_LINEAR:
fFilterMag := GL_LINEAR;
else
- raise EglBitmapException.Create('SetFilter - Unknow MAG filter.');
+ raise EglBitmap.Create('SetFilter - Unknow MAG filter.');
end;
//apply filter
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
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;
end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum);
+
+ procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer);
+ begin
+ if (aValue = GL_ZERO) or (aValue = GL_ONE) or (aValue = GL_ALPHA) or
+ (aValue = GL_RED) or (aValue = GL_GREEN) or (aValue = GL_BLUE) then
+ fSwizzle[aIndex] := aValue
+ else
+ raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value');
+ end;
+
+begin
+ if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
+ raise EglBitmapNotSupported.Create('texture swizzle is not supported');
+ CheckAndSetValue(r, 0);
+ CheckAndSetValue(g, 1);
+ CheckAndSetValue(b, 2);
+ CheckAndSetValue(a, 3);
+
+ if (ID > 0) then begin
+ Bind(false);
+ glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, @fSwizzle[0]);
+ end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean);
begin
if aEnableTextureUnit then
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}
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
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;
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;
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);
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
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);
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;
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;
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;
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;
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
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);
projects / glBitmap.git / commitdiff