Ooogles

Ooogles

Units

Class Hierarchy

Classes, Interfaces, Objects and Records

Types

Variables

Constants

Functions and Procedures

Identifiers

License

Class gl

DescriptionHierarchyFieldsMethodsProperties

Unit

Neslib.Ooogles

Declaration

type gl = class(TObject)

Description

Static class (or namespace) for OpenGL APIs that are not tied to a specific object.

Hierarchy

  • TObject
  • gl

Overview

Methods

Public class function GetError: TGLError; inline; static;
Public class procedure Viewport(const ALeft, ABottom, AWidth, AHeight: Integer); overload; inline; static;
Public class procedure Viewport(const AWidth, AHeight: Integer); overload; inline; static;
Public class procedure GetViewport(out ALeft, ABottom, AWidth, AHeight: Integer); inline; static;
Public class procedure GetMaxViewportDimensions(out AMaxWidth, AMaxHeight: Integer); inline; static;
Public class procedure DepthRange(const ANearVal, AFarVal: Single); inline; static;
Public class procedure GetDepthRange(out ANearVal, AFarVal: Single); inline; static;
Public class procedure ClearColor(const ARed, AGreen, ABlue, AAlpha: Single); overload; inline; static;
Public class procedure ClearColor(const AColor: TVector4); overload; inline; static;
Public class function GetClearColor: TVector4; inline; static;
Public class procedure ColorMask(const ARed, AGreen, ABlue, AAlpha: Boolean); inline; static;
Public class procedure GetColorMask(out ARed, AGreen, ABlue, AAlpha: Boolean); inline; static;
Public class procedure ClearDepth(const ADepth: Single); inline; static;
Public class function GetClearDepth: Single; inline; static;
Public class procedure DepthMask(const AEnable: Boolean); inline; static;
Public class function GetDepthMask: Boolean; inline; static;
Public class procedure ClearStencil(const AIndex: Integer); inline; static;
Public class function GetClearStencil: Integer; inline; static;
Public class procedure StencilMask(const AMask: Cardinal); inline; static;
Public class procedure StencilMaskSeparate(const AFace: TGLFace; const AMask: Cardinal); inline; static;
Public class function GetStencilWriteMask: Cardinal; inline; static;
Public class function GetStencilBackWriteMask: Cardinal; inline; static;
Public class procedure Clear(const ABuffers: TGLClearBuffers); inline; static;
Public class procedure BlendFunc(const ASrcFactor, ADstFactor: TGLBlendFunc); inline; static;
Public class procedure BlendFuncSeparate(const ASrcRgb, ADstRgb, ASrcAlpha, ADstAlpha: TGLBlendFunc); inline; static;
Public class function GetBlendSrcRgb: TGLBlendFunc; inline; static;
Public class function GetBlendSrcAlpha: TGLBlendFunc; inline; static;
Public class function GetBlendDstRgb: TGLBlendFunc; inline; static;
Public class function GetBlendDstAlpha: TGLBlendFunc; inline; static;
Public class procedure BlendEquation(const AEquation: TGLBlendEquation); inline; static;
Public class procedure BlendEquationSeparate(const AEquationRgb, AEquationAlpha: TGLBlendEquation); inline; static;
Public class function GetBlendEquationRgb: TGLBlendEquation; inline; static;
Public class function GetBlendEquationAlpha: TGLBlendEquation; inline; static;
Public class procedure BlendColor(const ARed, AGreen, ABlue, AAlpha: Single); overload; inline; static;
Public class procedure BlendColor(const AColor: TVector4); overload; inline; static;
Public class function GetBlendColor: TVector4; inline; static;
Public class procedure StencilFunc(const AFunc: TGLCompareFunc; const ARef: Integer = 0; const AMask: Cardinal = $FFFFFFFF); inline; static;
Public class procedure StencilFuncSeparate(const AFace: TGLFace; const AFunc: TGLCompareFunc; const ARef: Integer = 0; const AMask: Cardinal = $FFFFFFFF); inline; static;
Public class function GetStencilFunc: TGLCompareFunc; inline; static;
Public class function GetStencilValueMask: Cardinal; inline; static;
Public class function GetStencilRef: Integer; inline; static;
Public class function GetStencilBackFunc: TGLCompareFunc; inline; static;
Public class function GetStencilBackValueMask: Cardinal; inline; static;
Public class function GetStencilBackRef: Integer; inline; static;
Public class procedure StencilOp( const AStencilFail: TGLStencilOp = TGLStencilOp.Keep; const ADepthFail: TGLStencilOp = TGLStencilOp.Keep; const ABothPass: TGLStencilOp = TGLStencilOp.Keep); inline; static;
Public class procedure StencilOpSeparate( const AFace: TGLFace; const AStencilFail: TGLStencilOp = TGLStencilOp.Keep; const ADepthFail: TGLStencilOp = TGLStencilOp.Keep; const ABothPass: TGLStencilOp = TGLStencilOp.Keep); inline; static;
Public class function GetStencilFail: TGLStencilOp; inline; static;
Public class function GetStencilPassDepthPass: TGLStencilOp; inline; static;
Public class function GetStencilPassDepthFail: TGLStencilOp; inline; static;
Public class function GetStencilBackFail: TGLStencilOp; inline; static;
Public class function GetStencilBackPassDepthPass: TGLStencilOp; inline; static;
Public class function GetStencilBackPassDepthFail: TGLStencilOp; inline; static;
Public class procedure DepthFunc(const AFunc: TGLCompareFunc); inline; static;
Public class function GetDepthFunc: TGLCompareFunc; inline; static;
Public class procedure Scissor(const ALeft, ABottom, AWidth, AHeight: Integer); inline; static;
Public class procedure GetScissor(out ALeft, ABottom, AWidth, AHeight: Integer); inline; static;
Public class procedure SampleCoverage(const AValue: Single; const AInvert: Boolean = False); inline; static;
Public class function GetSampleCoverageValue: Single; inline; static;
Public class function GetSampleCoverageInvert: Boolean; inline; static;
Public class function GetSampleCoverage: Boolean; inline; static;
Public class function GetSampleAlphaToCoverage: Boolean; inline; static;
Public class procedure DrawArrays(const AType: TGLPrimitiveType; const ACount: Integer); overload; inline; static;
Public class procedure DrawArrays(const AType: TGLPrimitiveType; const AFirst, ACount: Integer); overload; inline; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: array of UInt8; const AFirst: Integer = 0; const ACount: Integer = 0); overload; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: TArray<UInt8>; const AFirst: Integer = 0; const ACount: Integer = 0); overload; inline; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: array of UInt16; const AFirst: Integer = 0; const ACount: Integer = 0); overload; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: TArray<UInt16>; const AFirst: Integer = 0; const ACount: Integer = 0); overload; inline; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const ACount: Integer; const AIndexType: TGLIndexType); overload; inline; static;
Public class procedure CullFace(const AMode: TGLFace); inline; static;
Public class function GetCullFace: TGLFace; inline; static;
Public class procedure FrontFace(const AOrientation: TGLFaceOrientation); inline; static;
Public class function GetFrontFace: TGLFaceOrientation; inline; static;
Public class procedure LineWidth(const AWidth: Single); inline; static;
Public class function GetLineWidth: Single; inline; static;
Public class procedure PolygonOffset(const AFactor, AUnits: Single); inline; static;
Public class function GetPolygonOffsetFactor: Single; inline; static;
Public class function GetPolygonOffsetUnits: Single; inline; static;
Public class procedure PixelStore(const AMode: TGLPixelStoreMode; const AValue: TGLPixelStoreValue); inline; static;
Public class function GetPixelStore(const AMode: TGLPixelStoreMode): TGLPixelStoreValue; inline; static;
Public class procedure GetAliasedLineWidthRange(out AMin, AMax: Single); inline; static;
Public class procedure GetAliasedPointSizeRange(out AMin, AMax: Single); inline; static;
Public class procedure Enable(const ACapability: TGLCapability); inline; static;
Public class procedure Disable(const ACapability: TGLCapability); inline; static;
Public class function IsEnabled(const ACapability: TGLCapability): Boolean; inline; static;
Public class procedure Finish; inline; static;
Public class procedure Flush; inline; static;
Public class function GetSubpixelBits: Integer; inline; static;
Public class function GetVendor: RawByteString; inline; static;
Public class function GetRenderer: RawByteString; inline; static;
Public class function GetVersion: RawByteString; inline; static;
Public class function GetShadingLanguageVersion: RawByteString; inline; static;
Public class function GetExtensions: RawByteString; inline; static;

Description

Methods

Public class function GetError: TGLError; inline; static;

Returns the last error that happened. You usually don't need to call this method yourself since all OpenGL calls are error checked automatically when compiling in DEBUG mode with Assertions enabled.

OpenGL API: glGetError

Returns

The last error that happened.

Public class procedure Viewport(const ALeft, ABottom, AWidth, AHeight: Integer); overload; inline; static;
Public class procedure Viewport(const AWidth, AHeight: Integer); overload; inline; static;

Set the viewport.

When a GL context is first attached to a window, width and height are set to the dimensions of that window.

This method specifies the affine transformation of X and Y from normalized device coordinates to window coordinates.

Viewport width and height are silently clamped to a range that depends on the implementation. To query this range, call GetMaxViewportDimensions.

OpenGL API: glViewport

Parameters
ALeft
(optional) X-coordinate of the lower left corner of the viewport rectangle, in pixels. The initial value is 0.
ABottom
(optional) Y-coordinate of the lower left corner of the viewport rectangle, in pixels. The initial value is 0.
AWidth
width of the viewport.
AHeight
height of the viewport.
Exceptions raised
TGLError.InvalidValue
if either AWidth or AHeight is negative.
See also
GetViewport
Returns the current viewport.
GetMaxViewportDimensions
Returns the maximum supported width and height of the viewport.
Public class procedure GetViewport(out ALeft, ABottom, AWidth, AHeight: Integer); inline; static;

Returns the current viewport. Initially the ALeft and ABottom window coordinates are both set to 0, and AWidth and AHeight are set to the width and height of the window into which the GL will do its rendering.

OpenGL API: glGetIntegerv(GL_VIEWPORT)

See also
Viewport
Public class procedure GetMaxViewportDimensions(out AMaxWidth, AMaxHeight: Integer); inline; static;

Returns the maximum supported width and height of the viewport. These must be at least as large as the visible dimensions of the display being rendered to.

OpenGL API: glGetIntegerv(GL_MAX_VIEWPORT_DIMS)

See also
Viewport
Public class procedure DepthRange(const ANearVal, AFarVal: Single); inline; static;

Specify mapping of depth values from normalized device coordinates to window coordinates.

After clipping and division by W, depth coordinates range from -1 to 1, corresponding to the near and far clipping planes. This method specifies a linear mapping of the normalized depth coordinates in this range to window depth coordinates. Regardless of the actual depth buffer implementation, window coordinate depth values are treated as though they range from 0 through 1 (like color components). Thus, the values accepted by DepthRange are both clamped to this range before they are accepted.

The setting of (0, 1) maps the near plane to 0 and the far plane to 1. With this mapping, the depth buffer range is fully utilized.

Note: it is not necessary that ANearVal be less than AFarVal. Reverse mappings such as ANearVal = 1, and AFarVal = 0 are acceptable.

OpenGL API: glDepthRangef

Parameters
ANearValue
specifies the mapping of the near clipping plane to window coordinates. The initial value is 0.
AFarValue
specifies the mapping of the far clipping plane to window coordinates. The initial value is 1.
See also
GetDepthRange
Gets the near and far clipping planes.
DepthFunc
Specify the value used for depth buffer comparisons.
PolygonOffset
Set the scale and units used to calculate polygon depth values.
Viewport
Public class procedure GetDepthRange(out ANearVal, AFarVal: Single); inline; static;

Gets the near and far clipping planes.

OpenGL API: glGetFloatv(GL_DEPTH_RANGE)

Parameters
ANearValue
is set to the mapping of the near clipping plane.
AFarValue
is set to the mapping of the far clipping plane.
See also
DepthRange
Specify mapping of depth values from normalized device coordinates to window coordinates.
Public class procedure ClearColor(const ARed, AGreen, ABlue, AAlpha: Single); overload; inline; static;

Specify clear values used by gl.Clear to clear the color buffers.

All values are clamped to the range 0..1.

OpenGL API: glClearColor

Parameters
ARed
red component.
AGreen
green component.
ABlue
blue component.
AAlpha
alpha component.
See also
Clear
Clear buffers to preset values.
GetClearColor
Returns the current color used to clear the color buffers.
Public class procedure ClearColor(const AColor: TVector4); overload; inline; static;

Specify clear values used by gl.Clear to clear the color buffers.

The R, G, B and A values in AColor are clamped to the range 0..1.

OpenGL API: glClearColor

Parameters
AColor
the clear color.
See also
Clear
Clear buffers to preset values.
GetClearColor
Returns the current color used to clear the color buffers.
Public class function GetClearColor: TVector4; inline; static;

Returns the current color used to clear the color buffers.

OpenGL API: glGetFloatv(GL_COLOR_CLEAR_VALUE)

See also
ClearColor
Specify clear values used by gl.Clear to clear the color buffers.
Public class procedure ColorMask(const ARed, AGreen, ABlue, AAlpha: Boolean); inline; static;

Enable and disable writing of frame buffer color components.

The initial values of the parameters are all True, indicating that the color components can be written.

This method specifies whether the individual color components in the frame buffer can or cannot be written. If red is False, for example, no change is made to the red component of any pixel in any of the color buffers, regardless of the drawing operation attempted.

Changes to individual bits of components cannot be controlled. Rather, changes are either enabled or disabled for entire color components.

OpenGL API: glColorMask

Parameters
ARed
whether red can or cannot be written into the frame buffer.
AGreen
whether green can or cannot be written into the frame buffer.
ABlue
whether blue can or cannot be written into the frame buffer.
AAlpha
whether alpha can or cannot be written into the frame buffer.
See also
GetColorMask
Get whether writing of frame buffer color components is enabled.
Clear
Clear buffers to preset values.
DepthMask
Enable or disable writing into the depth buffer.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
Public class procedure GetColorMask(out ARed, AGreen, ABlue, AAlpha: Boolean); inline; static;

Get whether writing of frame buffer color components is enabled.

OpenGL API: glGetIntegerv(GL_COLOR_WRITEMASK)

Parameters
ARed
is set to True of red can be written. False otherwise.
AGreen
is set to True of green can be written. False otherwise.
ABlue
is set to True of blue can be written. False otherwise.
AAlpha
is set to True of alpha can be written. False otherwise.
See also
ColorMask
Enable and disable writing of frame buffer color components.
Public class procedure ClearDepth(const ADepth: Single); inline; static;

Specify the clear value used by gl.Clear to clear the depth buffer.

OpenGL API: glClearDepthf/glClearDepth

Parameters
ADepth
the depth value used when the depth buffer is cleared. The initial value is 1. The value is clamped to the range 0..1.
See also
Clear
Clear buffers to preset values.
GetClearDepth
Gets the current clear depth value.
Public class function GetClearDepth: Single; inline; static;

Gets the current clear depth value.

OpenGL API: glGetFloatv(GL_DEPTH_CLEAR_VALUE)

Returns

The current clear depth value.

See also
ClearDepth
Specify the clear value used by gl.Clear to clear the depth buffer.
Public class procedure DepthMask(const AEnable: Boolean); inline; static;

Enable or disable writing into the depth buffer.

OpenGL API: glDepthMask

Parameters
AEnable
specifies whether the depth buffer is enabled for writing. If False, depth buffer writing is disabled. Otherwise, it is enabled. Initially, depth buffer writing is enabled.
See also
GetDepthMask
Checks whether writing into the depth buffer is enabled.
ColorMask
Enable and disable writing of frame buffer color components.
DepthFunc
Specify the value used for depth buffer comparisons.
DepthRange
Specify mapping of depth values from normalized device coordinates to window coordinates.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
Public class function GetDepthMask: Boolean; inline; static;

Checks whether writing into the depth buffer is enabled.

OpenGL API: glGetIntegerv(GL_DEPTH_WRITEMASK)

Returns

True if writing into the depth buffer is enabled. False otherwise.

See also
DepthMask
Enable or disable writing into the depth buffer.
Public class procedure ClearStencil(const AIndex: Integer); inline; static;

Specify the index value used by gl.Clear to clear the stencil buffer.

OpenGL API: glClearStencil

Parameters
AIndex
the index used when the stencil buffer is cleared. The initial value is 0. Only the lowest TGLFramebuffer.GetStencilBits bits of the index are used.
See also
Clear
Clear buffers to preset values.
GetClearStencil
Returns the index to which the stencil bitplanes are cleared.
TGLFramebuffer.GetStencilBits
Get the number of bitplanes in the stencil buffer of the framebuffer.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetClearStencil: Integer; inline; static;

Returns the index to which the stencil bitplanes are cleared. The initial value is 0.

OpenGL API: glGetIntegerv(GL_STENCIL_CLEAR_VALUE)

See also
ClearStencil
Specify the index value used by gl.Clear to clear the stencil buffer.
Public class procedure StencilMask(const AMask: Cardinal); inline; static;

Control the front and back writing of individual bits in the stencil planes.

StencilMask controls the writing of individual bits in the stencil planes. The least significant n bits of AMask, where n is the number of bits in the stencil buffer, specify a mask. Where a 1 appears in the mask, it's possible to write to the corresponding bit in the stencil buffer. Where a 0 appears, the corresponding bit is write-protected. Initially, all bits are enabled for writing.

There can be two separate mask writemasks; one affects back-facing polygons, and the other affects front-facing polygons as well as other non-polygon primitives. StencilMask sets both front and back stencil writemasks to the same values. Use StencilMaskSeparate to set front and back stencil writemasks to different values.

Note: StencilMask is the same as calling gl.StencilMaskSeparate with face set to FrontAndBack.

OpenGL API: glStencilMask

Parameters
AMask
specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all 1's.
See also
GetStencilWriteMask
Get the mask that controls writing of the stencil bitplanes for front-facing polygons and non-polygons.
GetStencilBackWriteMask
Get the mask that controls writing of the stencil bitplanes for back-facing polygons.
TGLFramebuffer.GetStencilBits
Get the number of bitplanes in the stencil buffer of the framebuffer.
ColorMask
Enable and disable writing of frame buffer color components.
DepthMask
Enable or disable writing into the depth buffer.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class procedure StencilMaskSeparate(const AFace: TGLFace; const AMask: Cardinal); inline; static;

Control the front and/or back writing of individual bits in the stencil planes.

See StencilMask for more details.

OpenGL API: glStencilMaskSeparate

Parameters
AFace
specifies whether front and/or back stencil writemask is updated.
AMask
specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all 1's.
See also
GetStencilWriteMask
Get the mask that controls writing of the stencil bitplanes for front-facing polygons and non-polygons.
GetStencilBackWriteMask
Get the mask that controls writing of the stencil bitplanes for back-facing polygons.
TGLFramebuffer.GetStencilBits
Get the number of bitplanes in the stencil buffer of the framebuffer.
ColorMask
Enable and disable writing of frame buffer color components.
DepthMask
Enable or disable writing into the depth buffer.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetStencilWriteMask: Cardinal; inline; static;

Get the mask that controls writing of the stencil bitplanes for front-facing polygons and non-polygons. The initial value is all 1's.

OpenGL API: glGetIntegerv(GL_STENCIL_WRITEMASK)

See also
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
Public class function GetStencilBackWriteMask: Cardinal; inline; static;

Get the mask that controls writing of the stencil bitplanes for back-facing polygons. The initial value is all 1's.

OpenGL API: glGetIntegerv(GL_STENCIL_BACK_WRITEMASK)

See also
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
Public class procedure Clear(const ABuffers: TGLClearBuffers); inline; static;

Clear buffers to preset values.

The value to which each buffer is cleared depends on the setting of the clear value for that buffer, as set by ClearColor, ClearStencil and ClearDepth.

The pixel ownership test, the scissor test, dithering, and the buffer writemasks affect the operation of Clear. The scissor box bounds the cleared region. Blend function, stenciling, fragment shading, and depth-buffering are ignored by Clear.

OpenGL API: glClear

Parameters
ABuffers
the buffers to be cleared.
See also
ClearColor
Specify clear values used by gl.Clear to clear the color buffers.
GetClearColor
Returns the current color used to clear the color buffers.
ClearStencil
Specify the index value used by gl.Clear to clear the stencil buffer.
GetClearStencil
Returns the index to which the stencil bitplanes are cleared.
ClearDepth.
Specify the clear value used by gl.Clear to clear the depth buffer.
GetClearDepth
Gets the current clear depth value.
ColorMask
Enable and disable writing of frame buffer color components.
DepthMask
Enable or disable writing into the depth buffer.
Scissor
Define the scissor box.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
Public class procedure BlendFunc(const ASrcFactor, ADstFactor: TGLBlendFunc); inline; static;

Specify pixel arithmetic using blend functions.

Pixels can be drawn using a function that blends the incoming (source) RGBA values with the RGBA values that are already in the frame buffer (the destination values). Blending is initially disabled. Use Enable and Disable with argument TGLCapability.Blend to enable and disable blending.

BlendFunc defines the operation of blending when it is enabled. ASrcFactor specifies which method is used to scale the source color components. ADstFactor specifies which method is used to scale the destination color components. See TGLBlendFunc for a description of the possible operations.

Note: incoming (source) alpha is correctly thought of as a material opacity, ranging from 1.0, representing complete opacity, to 0.0, representing complete transparency.

Note: transparency is best implemented using blend function (SrcAlpha, OneMinusSrcAlpha) with primitives sorted from farthest to nearest. Note that this transparency calculation does not require the presence of alpha bitplanes in the frame buffer.

OpenGL API: glBlendFunc

Parameters
ASrcFactor
specifies how the red, green, blue, and alpha source blending factors are computed. The initial value is One.
ADstFactor
specifies how the red, green, blue, and alpha destination blending factors are computed. The initial value is Zero.
See also
GetBlendSrcRgb
Gets the current RGB source blend function.
GetBlendSrcAlpha
Gets the current alpha source blend function.
GetBlendDstRgb
Gets the current RGB destination blend function.
GetBlendDstAlpha
Gets the current alpha destination blend function.
BlendColor
Set the blend color.
BlendEquation
Specify the equation used for both the RGB blend equation and the Alpha blend equation.
BlendEquationSeparate
Set the RGB blend equation and the alpha blend equation separately.
Clear
Clear buffers to preset values.
Enable
Enable a server-side GL capability.
StencilFunc
Set front and back function and reference value for stencil testing.
BlendFuncSeparate
Specify pixel arithmetic for RGB and alpha components separately.
Public class procedure BlendFuncSeparate(const ASrcRgb, ADstRgb, ASrcAlpha, ADstAlpha: TGLBlendFunc); inline; static;

Specify pixel arithmetic for RGB and alpha components separately.

Pixels can be drawn using a function that blends the incoming (source) RGBA values with the RGBA values that are already in the frame buffer (the destination values). Blending is initially disabled. Use Enable and Disable with argument TGLCapability.Blend to enable and disable blending.

BlendFuncSeparate defines the operation of blending when it is enabled. ASrcRgb specifies which method is used to scale the source RGB-color components. ADstRGB specifies which method is used to scale the destination RGB-color components. Likewise, ASrcAlpha specifies which method is used to scale the source alpha color component, and ADstAlpha specifies which method is used to scale the destination alpha component. See TGLBlendFunc for a description of the possible operations.

Note: incoming (source) alpha is correctly thought of as a material opacity, ranging from 1.0, representing complete opacity, to 0.0, representing complete transparency.

OpenGL API: glBlendFuncSeparate

Parameters
ASrcRgb
specifies how the red, green and blue source blending factors are computed. The initial value is One.
ADstRgb
specifies how the red, green and blue destination blending factors are computed. The initial value is Zero.
ASrcAlpha
specifies how the alpha source blending factor is computed. The initial value is One.
ADstAlpha
specifies how the alpha destination blending factor is computed. The initial value is Zero.
See also
GetBlendSrcRgb
Gets the current RGB source blend function.
GetBlendSrcAlpha
Gets the current alpha source blend function.
GetBlendDstRgb
Gets the current RGB destination blend function.
GetBlendDstAlpha
Gets the current alpha destination blend function.
BlendColor
Set the blend color.
BlendEquation
Specify the equation used for both the RGB blend equation and the Alpha blend equation.
BlendEquationSeparate
Set the RGB blend equation and the alpha blend equation separately.
Clear
Clear buffers to preset values.
Enable
Enable a server-side GL capability.
StencilFunc
Set front and back function and reference value for stencil testing.
BlendFunc
Specify pixel arithmetic using blend functions.
Public class function GetBlendSrcRgb: TGLBlendFunc; inline; static;

Gets the current RGB source blend function.

OpenGL API: glGetIntegerv(GL_BLEND_SRC_RGB)

Returns

The blend function.

See also
BlendFunc
Specify pixel arithmetic using blend functions.
BlendFuncSeparate
Specify pixel arithmetic for RGB and alpha components separately.
Public class function GetBlendSrcAlpha: TGLBlendFunc; inline; static;

Gets the current alpha source blend function.

OpenGL API: glGetIntegerv(GL_BLEND_SRC_ALPHA)

Returns

The blend function.

See also
BlendFunc
Specify pixel arithmetic using blend functions.
BlendFuncSeparate
Specify pixel arithmetic for RGB and alpha components separately.
Public class function GetBlendDstRgb: TGLBlendFunc; inline; static;

Gets the current RGB destination blend function.

OpenGL API: glGetIntegerv(GL_BLEND_DST_RGB)

Returns

The blend function.

See also
BlendFunc
Specify pixel arithmetic using blend functions.
BlendFuncSeparate
Specify pixel arithmetic for RGB and alpha components separately.
Public class function GetBlendDstAlpha: TGLBlendFunc; inline; static;

Gets the current alpha destination blend function.

OpenGL API: glGetIntegerv(GL_BLEND_DST_ALPHA)

Returns

The blend function.

See also
BlendFunc
Specify pixel arithmetic using blend functions.
BlendFuncSeparate
Specify pixel arithmetic for RGB and alpha components separately.
Public class procedure BlendEquation(const AEquation: TGLBlendEquation); inline; static;

Specify the equation used for both the RGB blend equation and the Alpha blend equation.

The blend equations determine how a new pixel (the "source" color) is combined with a pixel already in the framebuffer (the "destination" color). This function sets both the RGB blend equation and the alpha blend equation to a single equation.

These equations use the source and destination blend factors specified by either BlendFunc or BlendFuncSeparate. See BlendFunc or BlendFuncSeparate for a description of the various blend factors.

See TGLBlendEquation for a description of the available options. The results of these equations are clamped to the range 0..1.

The Add equation is useful for antialiasing and transparency, among other things.

Initially, both the RGB blend equation and the alpha blend equation are set to Add.

OpenGL API: glBlendEquation

Parameters
AEquation
specifies how source and destination colors are combined.
See also
GetBlendEquationRgb
Gets the current RGB blend equation.
GetBlendEquationAlpha
Gets the current alpha blend equation.
BlendColor
Set the blend color.
BlendEquationSeparate
Set the RGB blend equation and the alpha blend equation separately.
BlendFunc
Specify pixel arithmetic using blend functions.
BlendFuncSeparate
Specify pixel arithmetic for RGB and alpha components separately.
Public class procedure BlendEquationSeparate(const AEquationRgb, AEquationAlpha: TGLBlendEquation); inline; static;

Set the RGB blend equation and the alpha blend equation separately.

The blend equations determine how a new pixel (the "source" color) is combined with a pixel already in the framebuffer (the "destination" color). This function specifies one blend equation for the RGB-color components and one blend equation for the alpha component.

These equations use the source and destination blend factors specified by either BlendFunc or BlendFuncSeparate. See BlendFunc or BlendFuncSeparate for a description of the various blend factors.

See TGLBlendEquation for a description of the available options. The results of these equations are clamped to the range 0..1.

The Add equation is useful for antialiasing and transparency, among other things.

Initially, both the RGB blend equation and the alpha blend equation are set to Add.

OpenGL API: glBlendEquation

Parameters
AEquationRgb
specifies how the red, green, and blue components of the source and destination colors are combined.
AEquationAlpha
specifies how the alpha component of the source and destination colors are combined
See also
GetBlendEquationRgb
Gets the current RGB blend equation.
GetBlendEquationAlpha
Gets the current alpha blend equation.
BlendColor
Set the blend color.
BlendEquation
Specify the equation used for both the RGB blend equation and the Alpha blend equation.
BlendFunc
Specify pixel arithmetic using blend functions.
BlendFuncSeparate
Specify pixel arithmetic for RGB and alpha components separately.
Public class function GetBlendEquationRgb: TGLBlendEquation; inline; static;

Gets the current RGB blend equation.

OpenGL API: glGetIntegerv(GL_BLEND_EQUATION_RGB)

Returns

The blend equation.

See also
BlendEquation
Specify the equation used for both the RGB blend equation and the Alpha blend equation.
BlendEquationSeparate
Set the RGB blend equation and the alpha blend equation separately.
Public class function GetBlendEquationAlpha: TGLBlendEquation; inline; static;

Gets the current alpha blend equation.

OpenGL API: glGetIntegerv(GL_BLEND_EQUATION_ALPHA)

Returns

The blend equation.

See also
BlendEquation
Specify the equation used for both the RGB blend equation and the Alpha blend equation.
BlendEquationSeparate
Set the RGB blend equation and the alpha blend equation separately.
Public class procedure BlendColor(const ARed, AGreen, ABlue, AAlpha: Single); overload; inline; static;

Set the blend color.

The blend color may be used to calculate the source and destination blending factors. The color components are clamped to the range 0..1 before being stored. See BlendFunc for a complete description of the blending operations. Initially the blend color is set to (0, 0, 0, 0).

OpenGL API: glBlendColor

Parameters
ARed
red component.
AGreen
green component.
ABlue
blue component.
AAlpha
alpha component.
See also
GetBlendColor
Gets the current blend color.
BlendEquation
Specify the equation used for both the RGB blend equation and the Alpha blend equation.
BlendFunc
Specify pixel arithmetic using blend functions.
Public class procedure BlendColor(const AColor: TVector4); overload; inline; static;

Set the blend color.

The blend color may be used to calculate the source and destination blending factors. The color components are clamped to the range 0..1 before being stored. See BlendFunc for a complete description of the blending operations. Initially the blend color is set to (0, 0, 0, 0).

OpenGL API: glBlendColor

Parameters
AColor
the blend color.
See also
GetBlendColor
Gets the current blend color.
BlendEquation
Specify the equation used for both the RGB blend equation and the Alpha blend equation.
BlendFunc
Specify pixel arithmetic using blend functions.
Public class function GetBlendColor: TVector4; inline; static;

Gets the current blend color.

OpenGL API: glGetFloatv(GL_BLEND_COLOR)

Returns

The blend color.

See also
BlendColor
Set the blend color.
Public class procedure StencilFunc(const AFunc: TGLCompareFunc; const ARef: Integer = 0; const AMask: Cardinal = $FFFFFFFF); inline; static;

Set front and back function and reference value for stencil testing.

Stenciling, like depth-buffering, enables and disables drawing on a per-pixel basis. Stencil planes are first drawn into using GL drawing primitives, then geometry and images are rendered using the stencil planes to mask out portions of the screen. Stenciling is typically used in multipass rendering algorithms to achieve special effects, such as decals, outlining, and constructive solid geometry rendering.

The stencil test conditionally eliminates a pixel based on the outcome of a comparison between the reference value and the value in the stencil buffer. To enable and disable the test, call gl.Enable and gl.Disable with argument TGLCapability.StencilTest. To specify actions based on the outcome of the stencil test, call gl.StencilOp or gl.StencilOpSeparate.

There can be two separate sets of AFunc, ARef, and AMask parameters; one affects back-facing polygons, and the other affects front-facing polygons as well as other non-polygon primitives. StencilFunc sets both front and back stencil state to the same values. Use StencilFuncSeparate to set front and back stencil state to different values.

AFunc is an enum that determines the stencil comparison function. It accepts one of eight values (see TGLCompareFunc).

ARef is an integer reference value that is used in the stencil comparison. It is clamped to the range [0, 2n - 1], where n is the number of bitplanes in the stencil buffer.

AMask is bitwise ANDed with both the reference value and the stored stencil value, with the ANDed values participating in the comparison.

Note: initially, the stencil test is disabled. If there is no stencil buffer, no stencil modification can occur and it is as if the stencil test always passes.

Note: StencilFunc is the same as calling StencilFuncSeparate with AFace set to FrontAndBack.

OpenGL API: glStencilFunc

Parameters
AFunc
the test function. Initial value is TGLCompareFunc.Always.
ARef
(optional) value that specifies the reference value for the stencil test. ARef is clamped to the range [0, 2n - 1], where n is the number of bitplanes in the stencil buffer. The initial value is 0.
AMask
(optional) value that specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's.
See also
GetStencilFunc
Get what function is used to compare the stencil reference value with the stencil buffer value for front-facing polygons and non-polygons.
GetStencilValueMask
Get the mask that is used to mask both the stencil reference value and the stencil buffer value before they are compared for front-facing polygons and non-polygons.
GetStencilRef
Get the reference value that is compared with the contents of the stencil buffer for front-facing polygons and non-polygons.
GetStencilBackFunc
Get what function is used for back-facing polygons to compare the stencil reference value with the stencil buffer value.
GetStencilBackValueMask
Get the mask that is used for back-facing polygons to mask both the stencil reference value and the stencil buffer value before they are compared.
GetStencilBackRef
Get the reference value that is compared with the contents of the stencil buffer for back-facing polygons.
TGLFramebuffer.GetStencilBits
Get the number of bitplanes in the stencil buffer of the framebuffer.
BlendFunc
Specify pixel arithmetic using blend functions.
DepthFunc
Specify the value used for depth buffer comparisons.
Enable
Enable a server-side GL capability.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class procedure StencilFuncSeparate(const AFace: TGLFace; const AFunc: TGLCompareFunc; const ARef: Integer = 0; const AMask: Cardinal = $FFFFFFFF); inline; static;

Set front and/or back function and reference value for stencil testing.

See StencilFunc for more details.

OpenGL API: glStencilFuncSeparate

Parameters
AFace
specifies whether front and/or back stencil state is updated.
AFunc
the test function. Initial value is TGLCompareFunc.Always.
ARef
(optional) value that specifies the reference value for the stencil test. ARef is clamped to the range [0, 2n - 1], where n is the number of bitplanes in the stencil buffer. The initial value is 0.
AMask
(optional) value that specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all 1's.
See also
GetStencilFunc
Get what function is used to compare the stencil reference value with the stencil buffer value for front-facing polygons and non-polygons.
GetStencilValueMask
Get the mask that is used to mask both the stencil reference value and the stencil buffer value before they are compared for front-facing polygons and non-polygons.
GetStencilRef
Get the reference value that is compared with the contents of the stencil buffer for front-facing polygons and non-polygons.
GetStencilBackFunc
Get what function is used for back-facing polygons to compare the stencil reference value with the stencil buffer value.
GetStencilBackValueMask
Get the mask that is used for back-facing polygons to mask both the stencil reference value and the stencil buffer value before they are compared.
GetStencilBackRef
Get the reference value that is compared with the contents of the stencil buffer for back-facing polygons.
TGLFramebuffer.GetStencilBits
Get the number of bitplanes in the stencil buffer of the framebuffer.
BlendFunc
Specify pixel arithmetic using blend functions.
DepthFunc
Specify the value used for depth buffer comparisons.
Enable
Enable a server-side GL capability.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetStencilFunc: TGLCompareFunc; inline; static;

Get what function is used to compare the stencil reference value with the stencil buffer value for front-facing polygons and non-polygons. The initial value is Always.

OpenGL API: glGetIntegerv(GL_STENCIL_FUNC)

See also
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
Public class function GetStencilValueMask: Cardinal; inline; static;

Get the mask that is used to mask both the stencil reference value and the stencil buffer value before they are compared for front-facing polygons and non-polygons. The initial value is all 1's.

OpenGL API: glGetIntegerv(GL_STENCIL_VALUE_MASK)

See also
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
Public class function GetStencilRef: Integer; inline; static;

Get the reference value that is compared with the contents of the stencil buffer for front-facing polygons and non-polygons. The initial value is 0.

OpenGL API: glGetIntegerv(GL_STENCIL_REF)

See also
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
Public class function GetStencilBackFunc: TGLCompareFunc; inline; static;

Get what function is used for back-facing polygons to compare the stencil reference value with the stencil buffer value. The initial value is Always.

OpenGL API: glGetIntegerv(GL_STENCIL_BACK_FUNC)

See also
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
Public class function GetStencilBackValueMask: Cardinal; inline; static;

Get the mask that is used for back-facing polygons to mask both the stencil reference value and the stencil buffer value before they are compared. The initial value is all 1's.

OpenGL API: glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK)

See also
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
Public class function GetStencilBackRef: Integer; inline; static;

Get the reference value that is compared with the contents of the stencil buffer for back-facing polygons. The initial value is 0.

OpenGL API: glGetIntegerv(GL_STENCIL_REF)

See also
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
Public class procedure StencilOp( const AStencilFail: TGLStencilOp = TGLStencilOp.Keep; const ADepthFail: TGLStencilOp = TGLStencilOp.Keep; const ABothPass: TGLStencilOp = TGLStencilOp.Keep); inline; static;

Set front and back stencil test actions.

Stenciling, like depth-buffering, enables and disables drawing on a per-pixel basis. You draw into the stencil planes using GL drawing primitives, then render geometry and images, using the stencil planes to mask out portions of the screen. Stenciling is typically used in multipass rendering algorithms to achieve special effects, such as decals, outlining, and constructive solid geometry rendering.

The stencil test conditionally eliminates a pixel based on the outcome of a comparison between the value in the stencil buffer and a reference value. To enable and disable the test, call gl.Enable and gl.Disable with argument TGLCapability.StencilTest; to control it, call gl.StencilFunc or gl.StencilFuncSeparate.

There can be two separate sets of AStencilFail, ADepthFail and ABothPass parameters; one affects back-facing polygons, and the other affects front-facing polygons as well as other non-polygon primitives. StencilOp sets both front and back stencil state to the same values. Use gl.StencilOpSeparate to set front and back stencil state to different values.

StencilOp takes three arguments that indicate what happens to the stored stencil value while stenciling is enabled. If the stencil test fails, no change is made to the pixel's color or depth buffers, and AStencilFail specifies what happens to the stencil buffer contents.

Stencil buffer values are treated as unsigned integers. When incremented and decremented, values are clamped to 0 and 2n - 1, where n is the value returned by TGLFramebuffer.GetStencilBits.

The other two arguments to StencilOp specify stencil buffer actions that depend on whether subsequent depth buffer tests succeed (ABothPass) or fail (ADepthFail) (see DepthFunc). Note that ADepthFail is ignored when there is no depth buffer, or when the depth buffer is not enabled. In these cases, AStencilFail and ABothPass specify stencil action when the stencil test fails and passes, respectively.

Note: initially the stencil test is disabled. If there is no stencil buffer, no stencil modification can occur and it is as if the stencil tests always pass, regardless of any call to StencilOp.

Note: StencilOp is the same as calling gl.StencilOpSeparate with face set to FrontAndBack.

OpenGL API: glStencilOp

Parameters
AStencilFail
(optional) value that specifies the action to take when the stencil test fails. The initial value is Keep.
ADepthFail
(optional) value that specifies the action to take when the stencil test passes, but the depth test fails. The initial value is Keep.
ABothPass
(optional) value that specifies the action to take when both the stencil test and depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled. The initial value is Keep.
See also
GetStencilFail
Get what action is taken when the stencil test fails for front-facing polygons and non-polygons.
GetStencilPassDepthPass
Get what action is taken when the stencil test passes and the depth test passes for front-facing polygons and non-polygons.
GetStencilPassDepthFail
Get what action is taken when the stencil test passes, but the depth test fails for front-facing polygons and non-polygons.
GetStencilBackFail
Get what action is taken for back-facing polygons when the stencil test fails.
GetStencilBackPassDepthPass
Get what action is taken for back-facing polygons when the stencil test passes and the depth test passes.
GetStencilBackPassDepthFail
Get what action is taken for back-facing polygons when the stencil test passes, but the depth test fails.
TGLFramebuffer.GetStencilBits
Get the number of bitplanes in the stencil buffer of the framebuffer.
BlendFunc
Specify pixel arithmetic using blend functions.
DepthFunc
Specify the value used for depth buffer comparisons.
Enable
Enable a server-side GL capability.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class procedure StencilOpSeparate( const AFace: TGLFace; const AStencilFail: TGLStencilOp = TGLStencilOp.Keep; const ADepthFail: TGLStencilOp = TGLStencilOp.Keep; const ABothPass: TGLStencilOp = TGLStencilOp.Keep); inline; static;

Set front and/or back stencil test actions.

See StencilOp for more details.

OpenGL API: glStencilOpSeparate

Parameters
AFace
specifies whether front and/or back stencil state is updated.
AStencilFail
(optional) value that specifies the action to take when the stencil test fails. The initial value is Keep.
ADepthFail
(optional) value that specifies the action to take when the stencil test passes, but the depth test fails. The initial value is Keep.
ABothPass
(optional) value that specifies the action to take when both the stencil test and depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled. The initial value is Keep.
See also
GetStencilFail
Get what action is taken when the stencil test fails for front-facing polygons and non-polygons.
GetStencilPassDepthPass
Get what action is taken when the stencil test passes and the depth test passes for front-facing polygons and non-polygons.
GetStencilPassDepthFail
Get what action is taken when the stencil test passes, but the depth test fails for front-facing polygons and non-polygons.
GetStencilBackFail
Get what action is taken for back-facing polygons when the stencil test fails.
GetStencilBackPassDepthPass
Get what action is taken for back-facing polygons when the stencil test passes and the depth test passes.
GetStencilBackPassDepthFail
Get what action is taken for back-facing polygons when the stencil test passes, but the depth test fails.
TGLFramebuffer.GetStencilBits
Get the number of bitplanes in the stencil buffer of the framebuffer.
BlendFunc
Specify pixel arithmetic using blend functions.
DepthFunc
Specify the value used for depth buffer comparisons.
Enable
Enable a server-side GL capability.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilFuncSeparate
Set front and/or back function and reference value for stencil testing.
StencilMask
Control the front and back writing of individual bits in the stencil planes.
StencilMaskSeparate
Control the front and/or back writing of individual bits in the stencil planes.
StencilOp
Set front and back stencil test actions.
Public class function GetStencilFail: TGLStencilOp; inline; static;

Get what action is taken when the stencil test fails for front-facing polygons and non-polygons. The initial value is Keep.

OpenGL API: glGetIntegerv(GL_STENCIL_FAIL)

See also
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetStencilPassDepthPass: TGLStencilOp; inline; static;

Get what action is taken when the stencil test passes and the depth test passes for front-facing polygons and non-polygons. The initial value is Keep.

OpenGL API: glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS)

See also
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetStencilPassDepthFail: TGLStencilOp; inline; static;

Get what action is taken when the stencil test passes, but the depth test fails for front-facing polygons and non-polygons. The initial value is Keep.

OpenGL API: glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL)

See also
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetStencilBackFail: TGLStencilOp; inline; static;

Get what action is taken for back-facing polygons when the stencil test fails. The initial value is Keep.

OpenGL API: glGetIntegerv(GL_STENCIL_BACK_FAIL)

See also
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetStencilBackPassDepthPass: TGLStencilOp; inline; static;

Get what action is taken for back-facing polygons when the stencil test passes and the depth test passes. The initial value is Keep.

OpenGL API: glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS)

See also
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class function GetStencilBackPassDepthFail: TGLStencilOp; inline; static;

Get what action is taken for back-facing polygons when the stencil test passes, but the depth test fails. The initial value is Keep.

OpenGL API: glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL)

See also
StencilOp
Set front and back stencil test actions.
StencilOpSeparate
Set front and/or back stencil test actions.
Public class procedure DepthFunc(const AFunc: TGLCompareFunc); inline; static;

Specify the value used for depth buffer comparisons.

This method specifies the function used to compare each incoming pixel depth value with the depth value present in the depth buffer. The comparison is performed only if depth testing is enabled. (See gl.Enable and gl.Disable of TGLCapability.DepthTest.)

Initially, depth testing is disabled. If depth testing is disabled or no depth buffer exists, it is as if the depth test always passes.

Note: even if the depth buffer exists and the depth mask is non-zero, the depth buffer is not updated if the depth test is disabled.

OpenGL API: glDepthFunc

Parameters
AFunc
specifies the depth comparison function. The initial value is TGLCompareFunc.Less.
See also
GetDepthFunc
Gets the current depth function.
Enable
Enable a server-side GL capability.
DepthRange
Specify mapping of depth values from normalized device coordinates to window coordinates.
PolygonOffset
Set the scale and units used to calculate polygon depth values.
Public class function GetDepthFunc: TGLCompareFunc; inline; static;

Gets the current depth function.

OpenGL API: glGetIntegerv(GL_DEPTH_FUNC)

Returns

The current depth function.

See also
DepthFunc
Specify the value used for depth buffer comparisons.
Public class procedure Scissor(const ALeft, ABottom, AWidth, AHeight: Integer); inline; static;

Define the scissor box.

When a GL context is first attached to a window, the width and height are set to the dimensions of that window.

This method defines a rectangle, called the scissor box, in window coordinates. The first two arguments, ALeft and ABottom, specify the lower left corner of the box. AWidth and AHeight specify the width and height of the box.

To enable and disable the scissor test, call Enable and Disable with TGLCapability.ScissorTest. The test is initially disabled. While the test is enabled, only pixels that lie within the scissor box can be modified by drawing commands. Window coordinates have integer values at the shared corners of frame buffer pixels. Scissor(0, 0, 1, 1) allows modification of only the lower left pixel in the window, and Scissor(0, 0, 0, 0) doesn't allow modification of any pixels in the window.

When the scissor test is disabled, it is as though the scissor box includes the entire window.

OpenGL API: glScissor

Parameters
ALeft
X-coordinate of the lower left corner of the scissor box. The initial value is 0.
ABottom
Y-coordinate of the lower left corner of the scissor box. The initial value is 0.
AWidth
width of the scissor box.
AHeight
height of the scissor box.
Exceptions raised
TGLError.InvalidValue
if either AWidth or AHeight is negative.
See also
GetScissor
Get the current scissor box.
Enable
Enable a server-side GL capability.
Viewport
Public class procedure GetScissor(out ALeft, ABottom, AWidth, AHeight: Integer); inline; static;

Get the current scissor box.

OpenGL API: glGetIntegerv(GL_SCISSOR_BOX)

Parameters
ALeft
is set to the X-coordinate of the lower left corner of the scissor box.
ABottom
is set to the Y-coordinate of the lower left corner of the scissor box.
AWidth
is set to the width of the scissor box.
AHeight
is set to the height of the scissor box.
See also
Scissor
Define the scissor box.
Public class procedure SampleCoverage(const AValue: Single; const AInvert: Boolean = False); inline; static;

Specify multisample coverage parameters.

Multisampling samples a pixel multiple times at various implementation-dependent subpixel locations to generate antialiasing effects. Multisampling transparently antialiases points, lines, and polygons if it is enabled.

AValue is used in constructing a temporary mask used in determining which samples will be used in resolving the final fragment color. This mask is bitwise-anded with the coverage mask generated from the multisampling computation. If the AInvert flag is set, the temporary mask is inverted (all bits flipped) and then the bitwise-and is computed.

If an implementation does not have any multisample buffers available, or multisampling is disabled, rasterization occurs with only a single sample computing a pixel's final RGB color.

Provided an implementation supports multisample buffers, and multisampling is enabled, then a pixel's final color is generated by combining several samples per pixel. Each sample contains color, depth, and stencil information, allowing those operations to be performed on each sample.

OpenGL API: glSampleCoverage

Parameters
AValue
sample coverage value. The value is clamped to the range 0..1. The initial value is 1.0.
AInvert
(optional) value representing if the coverage masks should be inverted. Defaults to False.
See also
GetSampleCoverageValue
Get the current sample coverage value.
GetSampleCoverageInvert
Get the current sample coverage invert flag.
GetSampleAlphaToCoverage
Get a boolean value indicating if the fragment coverage value should be ANDed with a temporary coverage value based on the fragment's alpha value.
GetSampleCoverage
Get a boolean value indicating if the fragment coverage value should be ANDed with a temporary coverage value based on the current sample coverage value.
TGLFramebuffer.GetSampleBuffers
Get the number of sample buffers associated with the framebuffer.
TGLFramebuffer.GetSamples
Get the coverage mask size of the framebuffer.
Enable
Enable a server-side GL capability.
Public class function GetSampleCoverageValue: Single; inline; static;

Get the current sample coverage value.

OpenGL API: glGetFloatv(GL_SAMPLE_COVERAGE_VALUE)

Returns

The current sample coverage value.

See also
SampleCoverage
Specify multisample coverage parameters.
GetSampleCoverageInvert
Get the current sample coverage invert flag.
Public class function GetSampleCoverageInvert: Boolean; inline; static;

Get the current sample coverage invert flag.

OpenGL API: glGetIntegerv(GL_SAMPLE_COVERAGE_INVERT)

Returns

The current sample coverage invert flag.

See also
SampleCoverage
Specify multisample coverage parameters.
GetSampleCoverageValue
Get the current sample coverage value.
Public class function GetSampleCoverage: Boolean; inline; static;

Get a boolean value indicating if the fragment coverage value should be ANDed with a temporary coverage value based on the current sample coverage value. The initial value is False.

OpenGL API: glGetIntegerv(GL_SAMPLE_COVERAGE)

See also
SampleCoverage
Specify multisample coverage parameters.
Public class function GetSampleAlphaToCoverage: Boolean; inline; static;

Get a boolean value indicating if the fragment coverage value should be ANDed with a temporary coverage value based on the fragment's alpha value. The initial value is False.

OpenGL API: glGetIntegerv(GL_SAMPLE_ALPHA_TO_COVERAGE)

See also
SampleCoverage
Specify multisample coverage parameters.
Public class procedure DrawArrays(const AType: TGLPrimitiveType; const ACount: Integer); overload; inline; static;
Public class procedure DrawArrays(const AType: TGLPrimitiveType; const AFirst, ACount: Integer); overload; inline; static;

Render primitives from array data, without using indices.

DrawArrays specifies multiple geometric primitives with very few subroutine calls. Instead of calling a GL procedure to pass each individual vertex attribute, you can use TGLVertexAttrib to prespecify separate arrays of vertices, normals, and colors and use them to construct a sequence of primitives with a single call to DrawArrays.

When DrawArrays is called, it uses ACount sequential elements from each enabled array to construct a sequence of geometric primitives, beginning with element AFirst. AType specifies what kind of primitives are constructed and how the array elements construct those primitives.

To enable and disable a generic vertex attribute array, call TGLVertexAttrib.Enable and TGLVertexAttrib.Disable.

Note: if the current program object, as set by TGLProgram.Use, is invalid, rendering results are undefined. However, no error is generated for this case.

OpenGL API: glDrawArrays

Parameters
AType
specifies what kind of primitives to render.
AFirst
(optional) the starting index in the enabled arrays.
ACount
the number of elements to be rendered.
Exceptions raised
TGLError.InvalidValue
if ACount is negative.
TGLError.InvalidFramebufferOperation
if the currently bound framebuffer is not framebuffer complete.
See also
TGLFramebuffer.Status
Return the framebuffer completeness status.
TGLVertexAttrib
Represents a single vertex attribute in a TGLProgram.
TGLVertexAttrib.Enable
Enables this vertex attribute.
TGLVertexAttrib.Disable
Disables this vertex attribute.
DrawElements
Render primitives from array data, using indices from a bound index buffer.
TGLProgram.Use
Installs the program object as part of current rendering state.
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: array of UInt8; const AFirst: Integer = 0; const ACount: Integer = 0); overload; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: TArray<UInt8>; const AFirst: Integer = 0; const ACount: Integer = 0); overload; inline; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: array of UInt16; const AFirst: Integer = 0; const ACount: Integer = 0); overload; static;
Public class procedure DrawElements(const AType: TGLPrimitiveType; const AIndices: TArray<UInt16>; const AFirst: Integer = 0; const ACount: Integer = 0); overload; inline; static;

Render primitives from array data, using supplied indices.

DrawElements specifies multiple geometric primitives with very few subroutine calls. Instead of calling a GL function to pass each vertex attribute, you can use TGLVertexAttrib to prespecify separate arrays of vertex attributes and use them to construct a sequence of primitives with a single call to DrawElements.

When DrawElements is called, it uses AIndices to located vertices in the vertex array. AType specifies what kind of primitives are constructed and how the array elements construct these primitives. If more than one array is enabled, each is used.

To enable and disable a generic vertex attribute array, call TGLVertexAttrib.Enable and TGLVertexAttrib.Disable.

Note: if the current program object, as set by TGLProgram.Use, is invalid, rendering results are undefined. However, no error is generated for this case.

OpenGL API: glDrawElements

Parameters
AType
specifies what kind of primitives to render.
AIndices
array of indices (of type UInt8 or UInt16).
AFirst
(optional) index to the first index in AIndices to use. Defaults to 0.
ACount
(optional) number of indices in AIndices to use, starting at AFirst. Defaults to 0 (all remaining indices).
Exceptions raised
TGLError.InvalidFramebufferOperation
if the currently bound framebuffer is not framebuffer complete.
See also
TGLFramebuffer.Status
Return the framebuffer completeness status.
TGLVertexAttrib
Represents a single vertex attribute in a TGLProgram.
TGLVertexAttrib.Enable
Enables this vertex attribute.
TGLVertexAttrib.Disable
Disables this vertex attribute.
DrawArrays
TGLProgram.Use
Installs the program object as part of current rendering state.
Public class procedure DrawElements(const AType: TGLPrimitiveType; const ACount: Integer; const AIndexType: TGLIndexType); overload; inline; static;

Render primitives from array data, using indices from a bound index buffer.

DrawElements specifies multiple geometric primitives with very few subroutine calls. Instead of calling a GL function to pass each vertex attribute, you can use TGLVertexAttrib to prespecify separate arrays of vertex attributes and use them to construct a sequence of primitives with a single call to DrawElements.

AType specifies what kind of primitives are constructed and how the array elements construct these primitives. If more than one array is enabled, each is used.

To enable and disable a generic vertex attribute array, call TGLVertexAttrib.Enable and TGLVertexAttrib.Disable.

Note: if the current program object, as set by TGLProgram.Use, is invalid, rendering results are undefined. However, no error is generated for this case.

OpenGL API: glDrawElements

Parameters
AType
specifies what kind of primitives to render.
ACount
the number of indices used to render.
AIndexType
the type of the indices in the bound index buffer. Only 8-bit (UnsignedByte) and 16-bit (UnsignedShort) indices are supported.
Exceptions raised
TGLError.InvalidFramebufferOperation
if the currently bound framebuffer is not framebuffer complete.
See also
TGLFramebuffer.Status
Return the framebuffer completeness status.
TGLVertexAttrib
Represents a single vertex attribute in a TGLProgram.
TGLVertexAttrib.Enable
Enables this vertex attribute.
TGLVertexAttrib.Disable
Disables this vertex attribute.
DrawArrays
TGLProgram.Use
Installs the program object as part of current rendering state.
Public class procedure CullFace(const AMode: TGLFace); inline; static;

Specify whether front- or back-facing polygons can be culled.

This method specifies whether front- or back-facing polygons are culled (as specified by AMode) when polygon culling is enabled. Polygon culling is initially disabled. To enable and disable polygon culling, call the gl.Enable and gl.Disable methods with the argument TGLCapability.CullFace.

gl.FrontFace specifies which of the clockwise and counterclockwise polygons are front-facing and back-facing.

Note: if mode is TGLFace.FrontAndBack, no polygons are drawn, but other primitives such as points and lines are drawn.

OpenGL API: glCullFace

Parameters
AMode
whether front- or back-facing polygons are candidates for culling.
See also
GetCullFace
Gets the current cull face mode.
Enable
Enable a server-side GL capability.
Disable
Disable a server-side GL capability.
IsEnabled
Checks if a server-side GL capability is enabled.
FrontFace.
Define front- and back-facing polygons.
Public class function GetCullFace: TGLFace; inline; static;

Gets the current cull face mode.

OpenGL API: glGetIntegerv(GL_CULL_FACE_MODE)

Returns

The current cull face mode.

See also
CullFace
Specify whether front- or back-facing polygons can be culled.
Public class procedure FrontFace(const AOrientation: TGLFaceOrientation); inline; static;

Define front- and back-facing polygons.

In a scene composed entirely of opaque closed surfaces, back-facing polygons are never visible. Eliminating these invisible polygons has the obvious benefit of speeding up the rendering of the image. To enable and disable elimination of back-facing polygons, call gl.Enable and gl.Disable with argument TGLCapability.CullFace.

The projection of a polygon to window coordinates is said to have clockwise winding if an imaginary object following the path from its first vertex, its second vertex, and so on, to its last vertex, and finally back to its first vertex, moves in a clockwise direction about the interior of the polygon. The polygon's winding is said to be counterclockwise if the imaginary object following the same path moves in a counterclockwise direction about the interior of the polygon. glFrontFace specifies whether polygons with clockwise winding in window coordinates, or counterclockwise winding in window coordinates, are taken to be front-facing. Passing TGLFaceOrientation.CounterClockwise selects counterclockwise polygons as front-facing; TGLFaceOrientation.Clockwise selects clockwise polygons as front-facing. By default, counterclockwise polygons are taken to be front-facing.

OpenGL API: glFrontFace

Parameters
AOrientation
the orientation of front-facing polygons. Initial value is TGLFaceOrientation.CounterClockwise.
See also
GetFrontFace
Gets the current front face orientation.
Enable
Enable a server-side GL capability.
Disable
Disable a server-side GL capability.
IsEnabled
Checks if a server-side GL capability is enabled.
CullFace.
Specify whether front- or back-facing polygons can be culled.
Public class function GetFrontFace: TGLFaceOrientation; inline; static;

Gets the current front face orientation.

OpenGL API: glGetIntegerv(GL_FRONT_FACE)

Returns

The current front face orientation.

See also
FrontFace
Define front- and back-facing polygons.
Public class procedure LineWidth(const AWidth: Single); inline; static;

Specify the width of rasterized lines.

The actual width is determined by rounding the supplied width to the nearest integer. (If the rounding results in the value 0, it is as if the line width were 1.)

There is a range of supported line widths. Only width 1 is guaranteed to be supported; others depend on the implementation. To query the range of supported widths, call GetAliasedLineWidthRange.

Note: the line width specified by LineWidth is always returned when GetLineWidth is queried. Clamping and rounding have no effect on the specified value.

OpenGL API: glLineWidth

Parameters
AWidth
the width of rasterized lines. The initial value is 1.
Exceptions raised
TGLError.InvalidValue
if AWidth is less than or equal to 0.
See also
GetLineWidth
Get the current line width.
GetAliasedLineWidthRange
Gets the smallest and largest supported widths for aliased lines.
Enable
Enable a server-side GL capability.
Public class function GetLineWidth: Single; inline; static;

Get the current line width.

OpenGL API: glGetFloatv(GL_LINE_WIDTH)

Returns

The current line width.

See also
LineWidth
Specify the width of rasterized lines.
Public class procedure PolygonOffset(const AFactor, AUnits: Single); inline; static;

Set the scale and units used to calculate polygon depth values.

When TGLCapability.PolygonOffsetFill is enabled, each fragment's depth value will be offset after it is interpolated from the depth values of the appropriate vertices. The value of the offset is (AFactor × DZ) + (r × AUnits), where DZ is a measurement of the change in depth relative to the screen area of the polygon, and r is the smallest value that is guaranteed to produce a resolvable offset for a given implementation. The offset is added before the depth test is performed and before the value is written into the depth buffer.

PolygonOffset is useful for rendering hidden-line images, for applying decals to surfaces, and for rendering solids with highlighted edges.

OpenGL API: glPolygonOffset

Parameters
AFactor
a scale factor that is used to create a variable depth offset for each polygon. The initial value is 0.
AUnits
is multiplied by an implementation-specific value to create a constant depth offset. The initial value is 0.
See also
Enable
Enable a server-side GL capability.
Disable
Disable a server-side GL capability.
IsEnabled
Checks if a server-side GL capability is enabled.
DepthFunc
Specify the value used for depth buffer comparisons.
GetPolygonOffsetFactor
Gets the current polygon offset factor.
GetPolygonOffsetUnits
Gets the current polygon offset units.
Public class function GetPolygonOffsetFactor: Single; inline; static;

Gets the current polygon offset factor.

OpenGL API: glGetFloatv(GL_POLYGON_OFFSET_FACTOR)

Returns

The polygon offset factor.

See also
PolygonOffset
Set the scale and units used to calculate polygon depth values.
GetPolygonOffsetUnits
Gets the current polygon offset units.
Public class function GetPolygonOffsetUnits: Single; inline; static;

Gets the current polygon offset units.

OpenGL API: glGetFloatv(GL_POLYGON_OFFSET_UNITS)

Returns

The polygon offset units.

See also
PolygonOffset
Set the scale and units used to calculate polygon depth values.
GetPolygonOffsetFactor
Gets the current polygon offset factor.
Public class procedure PixelStore(const AMode: TGLPixelStoreMode; const AValue: TGLPixelStoreValue); inline; static;

Set pixel storage alignment.

This method sets pixel storage modes that affect the operation of subsequent TGLFramebuffer.ReadPixels as well as the unpacking of texture patterns (see TGLTexture.Upload and TGLTexture.SubUpload).

The PackAlignment mode affects how pixel data is downloaded from the GPU into client memory. The UnpackAlignment mode affects how pixel data is uploaded from client memory to the GPU.

OpenGL API: glPixelStorei

Parameters
AMode
the mode to set.
AValue
the alignment value to set for the mode.
See also
TGLFramebuffer.ReadPixels
Read a block of pixels from the frame buffer.
TGLTexture.Upload
Uploads an image to the texture.
TGLTexture.SubUpload
Uploads a part of an image to the texture.
GetPixelStore
Returns to current pixel storage alignment.
Public class function GetPixelStore(const AMode: TGLPixelStoreMode): TGLPixelStoreValue; inline; static;

Returns to current pixel storage alignment.

OpenGL API: glGetIntegerv(GL_PACK_ALIGNMENT/GL_UNPACK_ALIGNMENT)

Parameters
AMode
the mode for which to return the storage value.
Returns

The storage alignment for the given node.

See also
PixelStore
Set pixel storage alignment.
Public class procedure GetAliasedLineWidthRange(out AMin, AMax: Single); inline; static;

Gets the smallest and largest supported widths for aliased lines.

The returned range always includes value 1.0.

OpenGL API: glGetIntegerv(GL_ALIASED_LINE_WIDTH_RANGE)

Parameters
AMin
is set to the smallest supported line width.
AMax
is set to the largest supported line width.
See also
LineWidth
Specify the width of rasterized lines.
GetLineWidth
Get the current line width.
Public class procedure GetAliasedPointSizeRange(out AMin, AMax: Single); inline; static;

Gets the smallest and largest supported sizes for aliased points.

The returned range always includes value 1.0.

OpenGL API: glGetIntegerv(GL_ALIASED_POINT_SIZE_RANGE)

Parameters
AMin
is set to the smallest supported point size.
AMax
is set to the largest supported point size.
Public class procedure Enable(const ACapability: TGLCapability); inline; static;

Enable a server-side GL capability.

Use IsEnabled to determine the current setting of any capability. The initial value for each capability with the exception of TGLCapability.Dither is False. The initial value for TGLCapability.Dither is True.

OpenGL API: glEnable

Parameters
ACapability
the GL capability to enable.
See also
IsEnabled
Checks if a server-side GL capability is enabled.
TGLTexture.BindToTextureUnit
Actives a texture unit and binds this texture to that unit.
BlendFunc
Specify pixel arithmetic using blend functions.
CullFace
Specify whether front- or back-facing polygons can be culled.
DepthFunc
Specify the value used for depth buffer comparisons.
DepthRange
Specify mapping of depth values from normalized device coordinates to window coordinates.
LineWidth
Specify the width of rasterized lines.
PolygonOffset
Set the scale and units used to calculate polygon depth values.
Scissor
Define the scissor box.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilOp
Set front and back stencil test actions.
TGLTexture
A texture
Public class procedure Disable(const ACapability: TGLCapability); inline; static;

Disable a server-side GL capability.

Use IsEnabled to determine the current setting of any capability. The initial value for each capability with the exception of TGLCapability.Dither is False. The initial value for TGLCapability.Dither is True.

OpenGL API: glDisable

Parameters
ACapability
the GL capability to disable.
See also
IsEnabled
Checks if a server-side GL capability is enabled.
TGLTexture.BindToTextureUnit
Actives a texture unit and binds this texture to that unit.
BlendFunc
Specify pixel arithmetic using blend functions.
CullFace
Specify whether front- or back-facing polygons can be culled.
DepthFunc
Specify the value used for depth buffer comparisons.
DepthRange
Specify mapping of depth values from normalized device coordinates to window coordinates.
LineWidth
Specify the width of rasterized lines.
PolygonOffset
Set the scale and units used to calculate polygon depth values.
Scissor
Define the scissor box.
StencilFunc
Set front and back function and reference value for stencil testing.
StencilOp
Set front and back stencil test actions.
TGLTexture
A texture
Public class function IsEnabled(const ACapability: TGLCapability): Boolean; inline; static;

Checks if a server-side GL capability is enabled.

OpenGL API: glIsEnabled

Parameters
ACapability
the GL capability to check.
Returns

True if ACapability is currently enabled. False otherwise.

See also
Enable
Enable a server-side GL capability.
Disable
Disable a server-side GL capability.
Public class procedure Finish; inline; static;

Block until all GL execution is complete.

This method does not return until the effects of all previously called GL commands are complete. Such effects include all changes to GL state, all changes to connection state, and all changes to the frame buffer contents.

Note: Finish requires a round trip to the server.

OpenGL API: glFinish

See also
Flush
Force execution of GL commands in finite time.
Public class procedure Flush; inline; static;

Force execution of GL commands in finite time.

Different GL implementations buffer commands in several different locations, including network buffers and the graphics accelerator itself. This method empties all of these buffers, causing all issued commands to be executed as quickly as they are accepted by the actual rendering engine. Though this execution may not be completed in any particular time period, it does complete in finite time.

Because any GL program might be executed over a network, or on an accelerator that buffers commands, all programs should call Flush whenever they count on having all of their previously issued commands completed. For example, call Flush before waiting for user input that depends on the generated image.

Note: Flush can return at any time. It does not wait until the execution of all previously issued GL commands is complete.

OpenGL API: glFlush

See also
Finish
Block until all GL execution is complete.
Public class function GetSubpixelBits: Integer; inline; static;

Get an estimate of the number of bits of subpixel resolution that are used to position rasterized geometry in window coordinates. The value must be at least 4.

OpenGL API: glGetIntegerv(GL_SUBPIXEL_BITS)

Public class function GetVendor: RawByteString; inline; static;

Get the company responsible for this GL implementation. This name does not change from release to release.

Because the GL does not include queries for the performance characteristics of an implementation, some applications are written to recognize known platforms and modify their GL usage based on known performance characteristics of these platforms. GetVendor and GetRenderer together uniquely specify a platform. They do not change from release to release and should be used by platform-recognition algorithms.

OpenGL API: glGetString(GL_VENDOR)

See also
GetRenderer
Get the name of the renderer.
Public class function GetRenderer: RawByteString; inline; static;

Get the name of the renderer. This name is typically specific to a particular configuration of a hardware platform. It does not change from release to release.

Because the GL does not include queries for the performance characteristics of an implementation, some applications are written to recognize known platforms and modify their GL usage based on known performance characteristics of these platforms. GetVendor and GetRenderer together uniquely specify a platform. They do not change from release to release and should be used by platform-recognition algorithms.

OpenGL API: glGetString(GL_RENDERER)

See also
GetVendor
Get the company responsible for this GL implementation.
Public class function GetVersion: RawByteString; inline; static;

Get a version or release number of the form OpenGL<space>ES<space><version number><space><vendor-specific information>.

OpenGL API: glGetString(GL_VERSION)

Public class function GetShadingLanguageVersion: RawByteString; inline; static;

Get a version or release number for the shading language of the form OpenGL<space>ES<space>GLSL<space>ES<space><version number><space><vendor-specific information>.

OpenGL API: glGetString(GL_SHADING_LANGUAGE_VERSION)

Public class function GetExtensions: RawByteString; inline; static;

Get a space-separated list of supported extensions to GL.

Some applications want to make use of features that are not part of the standard GL. These features may be implemented as extensions to the standard GL. This method returns a space-separated list of supported GL extensions. (Extension names never contain a space character.)

OpenGL API: glGetString(GL_EXTENSIONS)

Generated by PasDocEx, based on PasDoc 0.14.0.