Opengl 45 Reference Guide
User Manual:
Open the PDF directly: View PDF 
.
Page Count: 13
| Download | |
| Open PDF In Browser | View PDF |
OpenGL 4.5 API Reference Card
Page 1
OpenGL® is the only cross-platform graphics API that enables
developers of software for PC, workstation, and supercomputing
hardware to create high-performance, visually-compelling graphics
software applications, in markets such as CAD, content creation,
energy, entertainment, game development, manufacturing,
medical, and virtual reality.
Specifications are available at www.opengl.org/registry
Command Execution [2.3]
OpenGL Errors [2.3.1]
enum GetError(void);
Graphics Reset Recovery [2.3.2]
enum GetGraphicsResetStatus(void);
Returns: NO_ERROR, GUILTY_CONTEXT_RESET,
{INNOCENT, UNKNOWN}_CONTEXT_RESET
GetIntegerv(
RESET_NOTIFICATION_STRATEGY);
Returns: NO_RESET_NOTIFICATION,
LOSE_CONTEXT_ON_RESET
Flush and Finish [2.3.3]
void Flush(void);
void Finish(void);
Synchronization
Sync Objects and Fences [4.1]
void DeleteSync(sync sync);
sync FenceSync(enum condition, bitfield flags);
condition: SYNC_GPU_COMMANDS_COMPLETE
flags: must be 0
Buffer Objects [6]
void GenBuffers(sizei n, uint *buffers);
void CreateBuffers(sizei n, uint *buffers);
void DeleteBuffers(sizei n, const uint *buffers);
Create and Bind Buffer Objects [6.1]
void BindBuffer(enum target, uint buffer);
target: [Table 6.1] {ARRAY, UNIFORM}_BUFFER,
{ATOMIC_COUNTER, QUERY}_BUFFER,
COPY_{READ, WRITE}_BUFFER,
{DISPATCH, DRAW}_INDIRECT_BUFFER,
{ELEMENT_ARRAY, TEXTURE}_BUFFER,
PIXEL_[UN]PACK_BUFFER,
SHADER_STORAGE_BUFFER,
TRANSFORM_FEEDBACK_BUFFER
void BindBufferRange(enum target,
uint index, uint buffer, intptr offset,
sizeiptr size);
target: ATOMIC_COUNTER_BUFFER,
{SHADER_STORAGE, UNIFORM}_BUFFER,
TRANSFORM_FEEDBACK_BUFFER
void BindBufferBase(enum target,
uint index, uint buffer);
target: See BindBufferRange
void BindBuffersRange(enum target,
uint first, sizei count, const uint *buffers,
const intptr *offsets, const sizeiptr *size);
target: See BindBufferRange
void BindBuffersBase(enum target,
uint first, sizei count,
const uint *buffers);
target: See BindBufferRange
Create/Modify Buffer Object Data [6.2]
void BufferStorage(enum target,
sizeiptr size, const void *data,
bitfield flags);
target: See BindBuffer
flags: Bitwise OR of MAP_{READ, WRITE}_BIT,
{DYNAMIC, CLIENT}_STORAGE_BIT,
MAP_{COHERENT, PERSISTENT}_BIT
void NamedBufferStorage(uint buffer,
sizeiptr size, const void *data,
bitfield flags);
flags: See BufferStorage
void BufferData(enum target, sizeiptr size,
const void *data, enum usage);
target: See BindBuffer
usage: DYNAMIC_{DRAW, READ, COPY},
{STATIC, STREAM}_{DRAW, READ, COPY}
void NamedBufferData(uint buffer, sizeiptr
size, const void *data, enum usage);
©2014 Khronos Group - Rev. 0814
Floating-Point Numbers [2.3.4]
16-Bit
Unsigned 11-Bit
Unsigned 10-Bit
1-bit sign, 5-bit exponent,
10-bit mantissa
no sign bit, 5-bit exponent,
6-bit mantissa
no sign bit, 5-bit exponent,
5-bit mantissa
Command Letters [Tables 2.1, 2.2]
Where a letter denotes a type in a function
name, T within the prototype is the same type.
b - byte (8 bits)
ub - ubyte (8 bits)
s - short (16 bits)
us - ushort (16 bits)
i - int (32 bits)
ui - uint (32 bits)
i64 - int64 (64 bits)
ui64 - uint64 (64 bits)
f - float (32 bits)
d - double (64 bits)
Waiting for Sync Objects [4.1.1]
enum ClientWaitSync(sync sync,
bitfield flags, uint64 timeout_ns);
flags: SYNC_FLUSH_COMMANDS_BIT, or zero
void WaitSync(sync sync, bitfield flags,
uint64 timeout);
timeout: TIMEOUT_IGNORED
Sync Object Queries [4.1.3]
void GetSynciv(sync sync, enum pname,
sizei bufSize, sizei *length, int *values);
pname: OBJECT_TYPE, SYNC_{STATUS, CONDITION, FLAGS}
boolean IsSync(sync sync);
void BufferSubData(enum target,
intptr offset, sizeiptr size,
const void *data);
target: See BindBuffer
void NamedBufferSubData(uint buffer,
intptr offset, sizeiptr size,
const void *data);
void ClearBufferSubData(enum target,
enum internalFormat, intptr offset,
sizeiptr size, enum format, enum type,
const void *data);
target: See BindBuffer
internalformat: See TexBuffer on pg. 3 of this card
format: RED, GREEN, BLUE, RG, RGB, RGBA, BGR,
BGRA, {RED, GREEN, BLUE, RG, RGB}_INTEGER,
{RGBA, BGR, BGRA} _INTEGER, STENCIL_INDEX,
DEPTH_{COMPONENT, STENCIL}
void ClearNamedBufferSubData(
uint buffer, enum internalFormat,
intptr offset, sizeiptr size, enum format,
enum type, const void *data);
internalformat, format, type: See
ClearBufferSubData
void ClearBufferData(enum target,
enum internalformat, enum format,
enum type, const void *data);
target, internalformat, format: See
ClearBufferSubData
void ClearNamedBufferData(uint buffer,
enum internalformat, enum format,
enum type, const void *data);
internalformat, format, type: See ClearBufferData
Map/Unmap Buffer Data [6.3]
void *MapBufferRange(enum target,
intptr offset, sizeiptr length,
bitfield access);
target: See BindBuffer
access: The Bitwise OR of MAP_X_BIT, where X may
be READ, WRITE, PERSISTENT, COHERENT,
INVALIDATE_{BUFFER, RANGE},
FLUSH_EXPLICIT, UNSYNCHRONIZED
void *MapNamedBufferRange(uint buffer,
intptr offset, sizeiptr length,
bitfield access);
target: See BindBuffer
access: See MapBufferRange
• See FunctionName refers to functions on this reference card.
• [n.n.n] and [Table n.n] refer to sections and tables in the OpenGL 4.5 core specification.
• [n.n.n] refers to sections in the OpenGL Shading Language 4.50 specification.
OpenGL Command Syntax [2.2]
GL commands are formed from a return type, a name, and optionally up to 4 characters
(or character pairs) from the Command Letters table (to the left), as shown by the prototype:
return-type Name{1234}{b s i i64 f d ub us ui ui64}{v} ([args ,] T arg1 , . . . , T argN [, args]);
The arguments enclosed in brackets ([args ,] and [, args]) may or may not be present.
The argument type T and the number N of arguments may be indicated by the command name
suffixes. N is 1, 2, 3, or 4 if present. If “v” is present, an array of N items is passed by a pointer.
For brevity, the OpenGL documentation and this reference may omit the standard prefixes.
The actual names are of the forms:
glFunctionName(), GL_CONSTANT, GLtype
Asynchronous Queries [4.2, 4.2.1]
void GenQueries(sizei n, uint *ids);
void CreateQueries(enum target, sizei n,
uint *ids);
target: See BeginQuery, plus TIMESTAMP
void DeleteQueries(sizei n, const uint *ids);
void BeginQuery(enum target, uint id);
target: ANY_SAMPLES_PASSED[_CONSERVATIVE],
PRIMITIVES_GENERATED,
SAMPLES_PASSED, TIME_ELAPSED,
TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
void BeginQueryIndexed(enum target,
uint index, uint id);
target: See BeginQuery
void EndQuery(enum target);
void EndQueryIndexed(enum target,
uint index);
boolean IsQuery(uint id);
void GetQueryiv(enum target, enum pname,
int *params);
target: See BeginQuery, plus TIMESTAMP
pname: CURRENT_QUERY, QUERY_COUNTER_BITS
void GetQueryIndexediv(enum target,
uint index, enum pname, int *params);
target: See BeginQuery, plus TIMESTAMP
pname: CURRENT_QUERY, QUERY_COUNTER_BITS
void GetQueryObjectiv(uint id, enum pname,
int *params);
void GetQueryObjectuiv(uint id,
enum pname, uint *params);
void GetQueryObjecti64v(uint id,
enum pname, int64 *params);
void GetQueryObjectui64v(uint id,
enum pname, uint64 *params);
pname: QUERY_TARGET,
QUERY_RESULT[_NO_WAIT, _AVAILABLE]
Timer Queries [4.3]
void QueryCounter(uint id, TIMESTAMP);
void GetIntegerv(TIMESTAMP, int *data);
void GetInteger64v(TIMESTAMP, int64 *data);
void *MapBuffer(enum target, enum access);
void GetBufferParameteri[64]v(
enum target, enum pname, int[64]*data);
Timer queries track the amount of time needed
to fully complete a set of GL commands.
access: See MapBufferRange
void *MapNamedBuffer(uint buffer,
enum access);
access: See MapBufferRange
void FlushMappedBufferRange(intptr offset,
sizeiptr length);
void FlushMappedNamedBufferRange(
uint buffer, intptr offset, sizeiptr length);
boolean UnmapBuffer(enum target);
target: See BindBuffer
boolean UnmapNamedBuffer(uint buffer);
Invalidate Buffer Data [6.5]
void InvalidateBufferSubData(uint buffer,
intptr offset, sizeiptr length);
void InvalidateBufferData(uint buffer);
Buffer Object Queries [6, 6.7]
boolean IsBuffer(uint buffer);
void GetBufferSubData(enum target,
intptr offset, sizeiptr size, void *data);
target: See BindBuffer
void GetNamedBufferSubData(uint buffer,
intptr offset, sizeiptr size, void *data);
Shaders and Programs
Shader Objects [7.1-2]
uint CreateShader(enum type);
type:
{COMPUTE, FRAGMENT}_SHADER,
{GEOMETRY, VERTEX}_SHADER,
TESS_{EVALUATION, CONTROL}_SHADER
void ShaderSource(uint shader, sizei count,
const char * const * string,
const int *length);
target: See BindBuffer
pname: [Table 6.2] BUFFER_SIZE, BUFFER_USAGE,
BUFFER_{ACCESS[_FLAGS]}, BUFFER_MAPPED,
BUFFER_MAP_{OFFSET, LENGTH},
BUFFER_{IMMUTABLE_STORAGE, ACCESS_FLAGS}
void GetNamedBufferParameteri[64]v(
uint buffer, enum pname, int[64]*data);
void GetBufferPointerv(enum target,
enum pname, const void **params);
target: See BindBuffer
pname: BUFFER_MAP_POINTER
void GetNamedBufferPointerv(uint buffer,
enum pname, const void **params);
pname: BUFFER_MAP_POINTER
Copy Between Buffers [6.6]
void CopyBufferSubData(enum readTarget,
enum writeTarget, intptr readOffset,
intptr writeOffset, sizeiptr size);
readTarget and writeTarget: See BindBuffer
void CopyNamedBufferSubData(
uint readBuffer, uint writeBuffer,
intptr readOffset, intptr writeOffset,
sizeiptr size);
void CompileShader(uint shader);
void ReleaseShaderCompiler(void);
void DeleteShader(uint shader);
boolean IsShader(uint shader);
void ShaderBinary(sizei count,
const uint *shaders, enum binaryformat,
const void *binary, sizei length);
(Continued on next page)
www.opengl.org/registry
Page 2
Shaders and Programs (cont.)
Program Objects [7.3]
uint CreateProgram(void);
void AttachShader(uint program, uint shader);
void DetachShader(uint program,
uint shader);
void LinkProgram(uint program);
void UseProgram(uint program);
uint CreateShaderProgramv(enum type,
sizei count, const char * const * strings);
void ProgramParameteri(uint program,
enum pname, int value);
pname: PROGRAM_SEPARABLE,
PROGRAM_BINARY_RETRIEVABLE_HINT
value: TRUE, FALSE
void DeleteProgram(uint program);
boolean IsProgram(uint program);
Program Interfaces [7.3.1]
void GetProgramInterfaceiv(uint program,
enum programInterface, enum pname,
int *params);
OpenGL 4.5 API Reference Card
stages: ALL_SHADER_BITS or the bitwise OR of
TESS_{CONTROL, EVALUATION}_SHADER_BIT,
{VERTEX, GEOMETRY, FRAGMENT}_SHADER_BIT,
COMPUTE_SHADER_BIT
void ActiveShaderProgram(uint pipeline,
uint program);
Program Binaries [7.5]
void GetProgramBinary(uint program,
sizei bufSize, sizei *length,
enum *binaryFormat, void *binary);
void ProgramBinary(uint program,
enum binaryFormat, const void *binary,
sizei length);
Uniform Variables [7.6]
int GetUniformLocation(uint program,
const char *name);
void GetActiveUniformName(uint program,
uint uniformIndex, sizei bufSize,
sizei *length, char *uniformName);
void GetUniformIndices(uint program,
sizei uniformCount,
const char * const *uniformNames,
uint *uniformIndices);
void GetActiveUniform(uint program,
uint index, sizei bufSize, sizei *length,
int *size, enum *type, char *name);
programInterface:
ATOMIC_COUNTER_BUFFER, BUFFER_VARIABLE,
UNIFORM[_BLOCK], PROGRAM_{INPUT, OUTPUT}, *type returns: DOUBLE_{VECn, MATn, MATmxn},
SHADER_STORAGE_BLOCK,
DOUBLE, FLOAT_{VECn, MATn, MATmxn}, FLOAT,
{GEOMETRY, VERTEX}_SUBROUTINE,
INT, INT_VECn, UNSIGNED_INT[_VECn], BOOL,
TESS_{CONTROL, EVALUATION}_SUBROUTINE,
BOOL_VECn, or any value in [Table 7.3]
{FRAGMENT, COMPUTE}_SUBROUTINE,
void GetActiveUniformsiv(uint program,
TESS_CONTROL_SUBROUTINE_UNIFORM,
sizei uniformCount,
TESS_EVALUATION_SUBROUTINE_UNIFORM,
const uint *uniformIndices, enum pname,
{GEOMETRY, VERTEX}_SUBROUTINE_UNIFORM,
int *params);
{FRAGMENT, COMPUTE}_SUBROUTINE_UNIFORM,
TRANSFORM_FEEDBACK_{BUFFER, VARYING}
pname: [Table 7.6]
UNIFORM_{NAME_LENGTH, TYPE, OFFSET},
pname: ACTIVE_RESOURCES, MAX_NAME_LENGTH,
MAX_NUM_ACTIVE_VARIABLES,
UNIFORM_{SIZE, BLOCK_INDEX, UNIFORM},
MAX_NUM_COMPATIBLE_SUBROUTINES
UNIFORM_{ARRAY, MATRIX}_STRIDE,
UNIFORM_IS_ROW_MAJOR,
uint GetProgramResourceIndex(
UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX
uint program, enum programInterface,
const char *name);
void GetProgramResourceName(
uint program, enum programInterface,
uint index, sizei bufSize, sizei *length,
char *name);
void GetProgramResourceiv(uint program,
enum programInterface, uint index,
sizei propCount, const enum *props,
sizei bufSize, sizei *length, int *params);
*props: [See Table 7.2]
int GetProgramResourceLocation(
uint program, enum programInterface,
const char *name);
int GetProgramResourceLocationIndex(
uint program, enum programInterface,
const char *name);
Program Pipeline Objects [7.4]
void GenProgramPipelines(sizei n,
uint *pipelines);
void DeleteProgramPipelines(sizei n,
const uint *pipelines);
boolean IsProgramPipeline(uint pipeline);
void BindProgramPipeline(uint pipeline);
void CreateProgramPipelines(sizei n,
uint *pipelines);
void UseProgramStages(uint pipeline,
bitfield stages, uint program);
Textures and Samplers [8]
UNIFORM_BLOCK_REFERENCED_BY_X_SHADER,
where X may be one of VERTEX, FRAGMENT,
COMPUTE, GEOMETRY, TESS_CONTROL, or
TESS_EVALUATION [Table 7.7]
void GetActiveAtomicCounterBufferiv(
uint program, uint bufferIndex,
enum pname, int *params);
pname: See GetActiveUniformBlockiv, however
replace the prefix UNIFORM_BLOCK_ with
ATOMIC_COUNTER_BUFFER_
Load Uniform Vars. in Default Uniform Block
Texture Objects [8.1]
void DeleteTextures(sizei n,
const uint *textures);
boolean IsTexture(uint texture);
target: TEXTURE_{1D, 2D}[_ARRAY],
TEXTURE_{3D, RECTANGLE, BUFFER},
TEXTURE_CUBE_MAP[_ARRAY],
TEXTURE_2D_MULTISAMPLE[_ARRAY]
void BindTextures(uint first, sizei count,
const uint *textures);
target: See BindTexture
©2014 Khronos Group - Rev. 0814
void UniformBlockBinding(uint program,
uint uniformBlockIndex,
uint uniformBlockBinding);
Shader Buffer Variables [7.8]
void ShaderStorageBlockBinding(
uint program, uint storageBlockIndex,
uint storageBlockBinding);
Subroutine Uniform Variables [7.9]
Parameter shadertype for the functions in this
section may be {COMPUTE, VERTEX}_SHADER,
TESS_{CONTROL, EVALUATION}_SHADER, or
{FRAGMENT, GEOMETRY}_SHADER
pname: [NUM_]COMPATIBLE_SUBROUTINES
void UniformSubroutinesuiv(
enum shadertype, sizei count,
const uint *indices);
Shader Memory Access [7.12.2]
target: See BindTexture
Sampler Objects [8.2]
void SamplerParameter{i f}(uint sampler,
enum pname, T param);
void BindSamplers(uint first, sizei count,
const uint *samplers);
Shader and Program Queries [7.13]
void GetShaderiv(uint shader, enum pname,
int *params);
pname: SHADER_TYPE, INFO_LOG_LENGTH,
{DELETE, COMPILE}_STATUS, COMPUTE_SHADER,
SHADER_SOURCE_LENGTH
void GetProgramiv(uint program,
enum pname, int *params);
pname: ACTIVE_ATOMIC_COUNTER_BUFFERS,
ACTIVE_ATTRIBUTES,
ACTIVE_ATTRIBUTE_MAX_LENGTH,
ACTIVE_UNIFORMS, ACTIVE_UNIFORM_BLOCKS,
ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH,
ACTIVE_UNIFORM_MAX_LENGTH,
ATTACHED_SHADERS, VALIDATE_STATUS,
COMPUTE_WORK_GROUP_SIZE, DELETE_STATUS,
GEOMETRY_{INPUT, OUTPUT}_TYPE,
GEOMETRY_SHADER_INVOCATIONS,
GEOMETRY_VERTICES_OUT, INFO_LOG_LENGTH,
LINK_STATUS, PROGRAM_SEPARABLE,
PROGRAM_BINARY_RETRIEVABLE_HINT,
TESS_CONTROL_OUTPUT_VERTICES,
TESS_GEN_{MODE, SPACING},
TESS_GEN_{VERTEX_ORDER, POINT_MODE},
TRANSFORM_FEEDBACK_BUFFER_MODE,
TRANSFORM_FEEDBACK_VARYINGS,
TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
void GetProgramPipelineiv(uint pipeline,
enum pname, int *params);
pname: ACTIVE_PROGRAM, VALIDATE_STATUS,
{VERTEX, FRAGMENT, GEOMETRY}_SHADER,
TESS_{CONTROL, EVALUATION}_SHADER,
INFO_LOG_LENGTH, COMPUTE_SHADER
void GetAttachedShaders(uint program,
sizei maxCount, sizei *count,
uint *shaders);
void GetShaderInfoLog(uint shader,
sizei bufSize, sizei *length, char *infoLog);
void GetProgramInfoLog(uint program,
sizei bufSize, sizei *length, char *infoLog);
void GetProgramPipelineInfoLog(
uint pipeline, sizei bufSize,
sizei *length, char *infoLog);
void GetShaderSource(uint shader,
sizei bufSize, sizei *length, char *source);
void GetShaderPrecisionFormat(
enum shadertype, enum precisiontype,
int *range, int *precision);
shadertype: {VERTEX, FRAGMENT}_SHADER
precisiontype: {LOW, MEDIUM, HIGH}_{FLOAT, INT}
pname: ACTIVE_SUBROUTINES,
ACTIVE_SUBROUTINE_X where X may be
UNIFORMS, MAX_LENGTH, UNIFORM_LOCATIONS,
UNIFORM_MAX_LENGTH
Sampler Queries [8.3]
void GetSamplerParameter{i f}v(
pname: TEXTURE_X where X may be WRAP_{S, T, R},
uint sampler, enum pname, T *params);
{MIN, MAG}_FILTER, {MIN, MAX}_LOD,
pname: See SamplerParameter{if}
BORDER_COLOR, LOD_BIAS,
void GetSamplerParameterI{i ui}v(
COMPARE_{MODE, FUNC} [Table 23.18]
void SamplerParameter{i f}v(uint sampler,
enum pname, const T *param);
pname: See SamplerParameter{if}
void GenSamplers(sizei count, uint *samplers); void SamplerParameterI{i ui}v(uint sampler,
enum pname, const T *params);
void CreateSamplers(sizei n, uint *samplers);
pname: See SamplerParameter{if}
void BindSampler(uint unit, uint sampler);
barriers: ALL_BARRIER_BITS or the OR of
X_BARRIER_BIT where X may be:
ATOMIC_COUNTER, FRAMEBUFFER,
SHADER_IMAGE_ACCESS, SHADER_STORAGE,
TEXTURE_FETCH, UNIFORM
void GetUniform{f d i ui}v(uint program,
int location, T *params);
See diagram on page 6 for more information.
void GetnUniform{f d i ui}v(uint program,
int location, sizei bufSize, T *params);
void MemoryBarrier(bitfield barriers);
barriers: ALL_BARRIER_BITS or the OR of
void GetUniformSubroutineuiv(
X_BARRIER_BIT where X may be: QUERY_BUFFER,
enum shadertype, int location,
VERTEX_ATTRIB_ARRAY, ELEMENT_ARRAY,
uint *params);
UNIFORM, TEXTURE_FETCH, BUFFER_UPDATE,
void GetProgramStageiv(uint program,
SHADER_IMAGE_ACCESS, COMMAND,
enum shadertype, enum pname,
PIXEL_BUFFER, TEXTURE_UPDATE, FRAMEBUFFER,
int *values);
TRANSFORM_FEEDBACK, ATOMIC_COUNTER,
void Uniform{1234}{i f d ui}(int location,
T value);
void Uniform{1234}{i f d ui}v(int location,
SHADER_STORAGE, CLIENT_MAPPED_BUFFER,
sizei count, const T *value);
void MemoryBarrierByRegion(bitfield
void UniformMatrix{234}{f d}v(
barriers);
int location, sizei count, boolean transpose,
const float *value);
void BindTextureUnit(uint unit, uint texture);
void CreateTextures(enum target, sizei n,
uint *textures);
void GenTextures(sizei n, uint *textures);
void BindTexture(enum target, uint texture);
Uniform Buffer Object Bindings
int GetSubroutineUniformLocation(
uint program, enum shadertype,
const char *name);
uint GetSubroutineIndex(uint program,
enum shadertype, const char *name);
uint GetUniformBlockIndex(uint program,
const char *uniformBlockName);
void GetActiveSubroutineName(
uint program, enum shadertype,
void GetActiveUniformBlockName(
uint index, sizei bufsize, sizei *length,
uint program, uint uniformBlockIndex,
char *name);
sizei bufSize, sizei length,
char *uniformBlockName);
void GetActiveSubroutineUniformName(
uint program, enum shadertype,
void GetActiveUniformBlockiv(
uint index, sizei bufsize, sizei *length,
uint program, uint uniformBlockIndex,
char *name);
enum pname, int *params);
void GetActiveSubroutineUniformiv(
pname: UNIFORM_BLOCK_{BINDING, DATA_SIZE},
uint program, enum shadertype,
UNIFORM_BLOCK_NAME_LENGTH,
uint index, enum pname, int *values);
UNIFORM_BLOCK_ACTIVE_UNIFORMS[_INDICES],
void ActiveTexture(enum texture);
texture: TEXTUREi (where i is
[0, max(MAX_TEXTURE_COORDS,
MAX_COMBINED_TEXTURE_IMAGE_UNITS)-1])
void
UniformMatrix{2x3,3x2,2x4,4x2,3x4, 4x3}
{fd}v( int location, sizei count,
boolean transpose, const float *value);
void ProgramUniform{1234}{i f d}(
uint program, int location, T value);
void ProgramUniform{1234}{i f d}v(
uint program, int location, sizei count,
const T *value);
void ProgramUniform{1234}uiv(
uint program, int location, sizei count,
const T *value);
void ProgramUniform{1234}ui(
uint program, int location, T value);
void ProgramUniformMatrix{234}{f d}v(
uint program, int location, sizei count,
boolean transpose, const T *value);
void ProgramUniformMatrixf{2x3,3x2,2x4,
4x2, 3x4, 4x3}{f d}v(
uint program, int location, sizei count,
boolean transpose, const T *value);
void DeleteSamplers(sizei count,
const uint *samplers);
boolean IsSampler(uint sampler);
uint sampler, enum pname, T *params);
pname: See SamplerParameter{if}
Pixel Storage Modes [8.4.1]
void PixelStore{i f}(enum pname, T param);
pname: [Tables 8.1, 18.1] [UN]PACK_X where X may
be SWAP_BYTES, LSB_FIRST, ROW_LENGTH,
SKIP_{IMAGES, PIXELS, ROWS}, ALIGNMENT,
IMAGE_HEIGHT, COMPRESSED_BLOCK_WIDTH,
COMPRESSED_BLOCK_{HEIGHT, DEPTH, SIZE}
(Continued on next page)
www.opengl.org/registry
OpenGL 4.5 API Reference Card
Page 3
Textures and Samplers (cont.)
void TextureSubImage1D(uint texture, int level, Buffer Textures [8.9]
int xoffset, sizei width, enum format,
void TexBufferRange(enum target,
enum type, const void *pixels);
enum internalFormat, uint buffer,
format,
type:
See
TexImage3D
void TexImage3D(enum target, int level,
intptr offset, sizeiptr size);
int internalformat, sizei width, sizei height, void CopyTextureSubImage3D(uint texture,
void
TextureBufferRange(uint texture,
sizei depth, int border, enum format,
int level, int xoffset, int yoffset, int zoffset,
enum internalFormat, uint buffer,
enum type, const void *data);
int x, int y, sizei width, sizei height);
intptr offset, sizeiptr size);
target: [PROXY_]TEXTURE_CUBE_MAP_ARRAY,
internalformat: See TexBuffer
[PROXY_]TEXTURE_2D_ARRAY, [PROXY_]TEXTURE_3D void CopyTextureSubImage2D(uint texture,
int
level,
int
xoffset,
int
yoffset,
int
x,
void TexBuffer(enum target,
internalformat: STENCIL_INDEX, RED,
int y, sizei width, sizei height);
DEPTH_{COMPONENT, STENCIL}, RG, RGB, RGBA,
enum internalformat, uint buffer);
COMPRESSED_{RED, RG, RGB, RGBA, SRGB,
target: TEXTURE_BUFFER
void CopyTextureSubImage1D(uint texture,
SRGB_ALPHA), a sized internal format from
internalformat: [Table 8.16] R8, R8{I, UI}, R16,
int level, int xoffset, int x, int y, sizei width);
Texture Image Spec. [8.5]
[Tables 8.12 - 8.13], or a COMPRESSED_ format
from [Table 8.14]
format: DEPTH_{COMPONENT, STENCIL}, RED,
GREEN, BLUE, RG, RGB, RGBA, BGR, BGRA,
{BGRA, RED, GREEN, BLUE}_INTEGER,
{RG, RGB, RGBA, BGR}_INTEGER,
STENCIL_INDEX, [Table 8.3]
type: [UNSIGNED_]{BYTE, SHORT, INT},
[HALF_]FLOAT, or a value from [Table 8.2]
void TexImage2D(enum target, int level,
int internalformat, sizei width,
sizei height, int border, enum format,
enum type, const void *data);
target: [PROXY_]TEXTURE_{2D, RECTANGLE},
[PROXY_]TEXTURE_{1D_ARRAY, CUBE_MAP},
TEXTURE_CUBE_MAP_POSITIVE_{X, Y, Z},
TEXTURE_CUBE_MAP_NEGATIVE_{X, Y, Z}
internalformat, format, type: See TexImage3D
Compressed Texture Images [8.7]
void CompressedTexImage3D(enum target,
int level, enum internalformat, sizei width,
sizei height, sizei depth, int border,
sizei imageSize, const void *data);
target: See TexImage3D
internalformat: A COMPRESSED_
format from [Table 8.14]
Alternate Texture Image Spec. [8.6]
void CopyTexImage2D(enum target,
int level, enum internalformat, int x,
int y, sizei width, sizei height, int border);
target: TEXTURE_{2D, RECTANGLE, 1D_ARRAY},
TEXTURE_CUBE_MAP_{POSITIVE, NEGATIVE}_{X, Y, Z}
internalformat: See TexImage3D
void CopyTexImage1D(enum target,
int level, enum internalformat, int x,
int y, sizei width, int border);
target: TEXTURE_1D
internalformat: See TexImage3D
void TexSubImage3D(enum target, int level,
int xoffset, int yoffset, int zoffset,
sizei width, sizei height, sizei depth,
enum format, enum type,
const void *data);
target: TEXTURE_3D, TEXTURE_2D_ARRAY,
TEXTURE_CUBE_MAP_ARRAY
format, type: See TexImage3D
void TexSubImage2D(enum target,
int level, int xoffset, int yoffset, sizei width,
sizei height, enum format, enum type,
const void *data);
target: See CopyTexImage2D
format, type: See TexImage3D
void TexSubImage1D(enum target, int level,
int xoffset, sizei width, enum format,
enum type, const void *data);
target, format, type: See CopyTexImage1D
void CopyTexSubImage3D(enum target,
int level, int xoffset, int yoffset, int zoffset,
int x, int y, sizei width, sizei height);
target: See TexSubImage3D
void CopyTexSubImage2D(enum target,
int level, int xoffset, int yoffset, int x,
int y, sizei width, sizei height);
target: See TexImage2D
void CopyTexSubImage1D(enum target,
int level, int xoffset, int x, int y, sizei width);
void CompressedTexImage1D(enum target,
int level, enum internalformat,
sizei width, int border, sizei imageSize,
const void *data);
void TexParameterI{i ui}v(enum target,
enum pname, const T *params);
target: See TexImage2D
internalformat: May be one of the COMPRESSED_
formats from [Table 8.14]
internalformat: See TexImage1D, omitting
compressed rectangular texture formats
void CompressedTexSubImage3D(
enum target, int level, int xoffset,
int yoffset, int zoffset, sizei width,
sizei height, sizei depth, enum format,
sizei imageSize, const void *data);
target: See TexSubImage3D
format: See internalformat for
CompressedTexImage3D
void CompressedTexSubImage2D(
enum target, int level, int xoffset,
int yoffset, sizei width, sizei height,
enum format, sizei imageSize,
cont void *data);
target: See TexSubImage2D
format: See internalformat for
CompressedTexImage2D
void CompressedTexSubImage1D(
enum target, int level, int xoffset,
sizei width, enum format, sizei imageSize,
const void *data);
target: See TexSubImage1D
format: See internalformat for
CompressedTexImage1D
void CompressedTextureSubImage3D(
uint texture, int level, int xoffset,
int yoffset, int zoffset, sizei width,
sizei height, sizei depth, enum format,
sizei imageSize, const void *data);
format: See internalformat for
CompressedTexImage3D
void CompressedTextureSubImage2D(
uint texture, int level, int xoffset,
int yoffset, sizei width, sizei height,
enum format, sizei imageSize,
cont void *data);
format: See internalformat for
CompressedTexImage2D
void CompressedTextureSubImage1D(
uint texture, int level, int xoffset,
sizei width, enum format, sizei imageSize,
const void *data);
format: See internalformat for
CompressedTexImage1D
internalformat: RED, RG, RGB, RGBA, RGBA{32, 32UI},
DEPTH_COMPONENT[16, 24, 32, 32F],
DEPTH{24, 32F}_STENCIL8, STENCIL_INDEX{1, 4, 8, 16}
void TextureSubImage2D(uint texture, int level,
int xoffset, int yoffset, sizei width,
void TexImage2DMultisample(enum target,
sizei height, enum format, enum type,
sizei samples, int internalformat, sizei width,
const void *pixels);
sizei height, boolean fixedsamplelocations);
format, type: See TexImage3D
©2014 Khronos Group - Rev. 0814
internalformat: See TexBuffer
Texture Parameters [8.10]
void TexParameter{i f}(enum target,
enum pname, T param);
target: See TexSubImage1D
Multisample Textures [8.8]
void TextureSubImage3D(uint texture, int level, void TexImage3DMultisample(enum target,
sizei samples, int internalformat,
int xoffset, int yoffset, int zoffset,
sizei width, sizei height, sizei depth,
sizei width, sizei height, sizei depth,
boolean
fixedsamplelocations);
enum format, enum type,
target: [PROXY_]TEXTURE_2D_MULTISAMPLE_ARRAY
const void *pixels);
format, type: See TexImage3D
void TextureBuffer(uint texture,
enum internalformat, uint buffer);
void CompressedTexImage2D(enum target,
int level, enum internalformat,
sizei width, sizei height, int border,
sizei imageSize, const void *data);
void TexImage1D(enum target, int level,
int internalformat, sizei width, int border,
enum format, enum type, const void *data); target: TEXTURE_1D, PROXY_TEXTURE_1D
target: TEXTURE_1D, PROXY_TEXTURE_1D
type, internalformat, format: See TexImage3D
R16{F, I, UI}, R32{F, I, UI}, RG8, RG8{I, UI}, RG16,
RG16{F, I, UI}, RG32{F, I, UI}, RGB32F, RGB32{I, UI},
RGBA8, RGBA8{I, UI}, RGBA16, RGBA16{F, I, UI},
RGBA32{F, I, UI}
target: [PROXY_]TEXTURE_2D_MULTISAMPLE
internalformat: See TexImage3DMultisample
target: See BindTexture
void TexParameter{i f}v(enum target,
enum pname, const T *params);
target: See BindTexture
target: See BindTexture
pname: DEPTH_STENCIL_TEXTURE_MODE or
TEXTURE_X where X may be one of
WRAP_{S, T, R}, BORDER_COLOR,
{MIN, MAG}_FILTER, LOD_BIAS,{MIN, MAX}_LOD,
{BASE, MAX}_LEVEL, SWIZZLE_{R, G, B, A, RGBA},
COMPARE_{MODE, FUNC} [Table 8.17]
void GetTextureLevelParameter{i f}v(
uint texture, int level, enum pname,
T *params);
pname: See GetTexLevelParameter{i f}v
void GetTexImage(enum target, int level,
enum format, enum type, void *pixels);
target: TEXTURE_{1, 2}D[_ARRAY],
TEXTURE_{3D, RECTANGLE, CUBE_MAP_ARRAY},
TEXTURE_CUBE_MAP_NEGATIVE_{X, Y, Z},
TEXTURE_CUBE_MAP_POSITIVE_{X, Y, Z}
format: See TexImage3D
type: [UNSIGNED_]BYTE, SHORT, INT,
[HALF_]FLOAT, or a value from [Table 8.2]
void GetTextureImage(uint texture, int level,
enum format, enum type, sizei bufSize,
void *pixels);
level: LOD level
format, type: See GetTexImage
void GetnTexImage(enum tex, int level,
enum format, enum type, sizei bufSize,
void *pixels);
tex: TEXTURE_{1D, 2D, 3D}[_ARRAY], TEXTURE_3D,
TEXTURE_{CUBE_MAP_ARRAY, RECTANGLE},
TEXTURE_CUBE_MAP_POSITIVE_{X, Y, Z},
TEXTURE_CUBE_MAP_NEGATIVE_{X, Y, Z}
level, format, type: See GetTextureImage
void GetTextureSubImage(uint texture,
int level, int xoffset, int yoffset, int zoffset,
sizei width, sizei height, sizei depth,
enum format, enum type, sizei bufSize,
void *pixels);
level, format, type: See GetTextureImage
void GetCompressedTexImage(enum target,
int level, void *pixels);
target: See GetTextureImage
void TextureParameter{i f}(uint texture,
enum pname, T param);
void
GetCompressedTextureImage(uint texture,
int level, sizei bufSize, void *pixels);
void TextureParameter{i f}v(uint texture,
enum pname, const T *params);
void GetnCompressedTexImage(enum target,
int level, sizei bufsize, void *pixels);
pname: See BindTexture
pname: See BindTexture
void TextureParameterI{i ui}v(uint texture,
enum pname, const T *params);
pname: TEXTURE_3D, TEXTURE_{1D, 2D}[_ARRAY],
TEXTURE_CUBE_MAP[_ARRAY],
TEXTURE_RECTANGLE,
TEXTURE_2D_MULTISAMPLE[_ARRAY]
Texture Queries [8.11]
void GetTexParameter{if}v(enum target,
enum pname, T * params);
target: See BindTexture
pname: See GetTexParameterI{i ui}v
void GetTexParameterI{i ui}v(enum target,
enum pname, T * params);
target: See BindTexture
pname: IMAGE_FORMAT_COMPATIBILITY_TYPE,
TEXTURE_IMMUTABLE_{FORMAT, LEVELS},
TEXTURE_VIEW_MIN_{LEVEL, LAYER},
TEXTURE_VIEW_NUM_{LEVELS, LAYERS},
DEPTH_STENCIL_TEXTURE_MODE, or TEXTURE_X
where X may be one of WRAP_{S, T, R},
BORDER_COLOR, TARGET, {MIN, MAG}_FILTER,
LOD_BIAS,{MIN, MAX}_LOD, {BASE, MAX}_LEVEL,
SWIZZLE_{R, G, B, A, RGBA},
COMPARE_{MODE, FUNC} [Table 8.17]
void GetTextureParameter{if}v(uint texture,
enum pname, T *data);
pname: See GetTexParameterI{i ui}v
void GetTextureParameterI{i ui}v(uint texture,
enum pname, T *data);
pname: See GetTexParameterI{i ui}v
void GetTexLevelParameter{i f}v(enum target,
int level, enum pname, T *params);
target: [PROXY_]TEXTURE_{1D, 2D, 3D},
TEXTURE_BUFFER, PROXY_TEXTURE_CUBE_MAP,
[PROXY_]TEXTURE_{1D, 2D,CUBE_MAP}_ARRAY,
[PROXY_]TEXTURE_RECTANGLE,
TEXTURE_CUBE_MAP_NEGATIVE_{X, Y, Z},
TEXTURE_CUBE_MAP_POSITIVE_{X, Y, Z},
[PROXY_]TEXTURE_2D_MULTISAMPLE[_ARRAY]
pname: TEXTURE _*, where * may be WIDTH,
HEIGHT, DEPTH, FIXED_SAMPLE_LOCATIONS,
INTERNAL_FORMAT, SHARED_SIZE, COMPRESSED,
COMPRESSED_IMAGE_SIZE, SAMPLES,
BUFFER_{OFFSET, SIZE}, or X_{SIZE, TYPE}
where X can be RED, GREEN, BLUE, ALPHA, DEPTH
level: See GetTextureImage
target: See GetCompressedTexImage
level: LOD level
void GetCompressedTextureSubImage(
uint texture, int level, int xoffset, int yoffset,
int zoffset, sizei width, sizei height,
sizei depth, sizei bufSize, void *pixels);
level: LOD level
Cube Map Texture Select [8.13.1]
Enable/Disable/IsEnabled(
TEXTURE_CUBE_MAP_SEAMLESS);
Manual Mipmap Generation [8.14.4]
void GenerateMipmap(enum target);
target: TEXTURE_{1D, 2D, 3D},
TEXTURE_{1D, 2D}_ARRAY,
TEXTURE_CUBE_MAP[_ARRAY]
void GenerateTextureMipmap(uint texture);
Texture Views [8.18]
void TextureView(uint texture, enum target,
uint origtexture, enum internalformat,
uint minlevel, uint numlevels, uint minlayer,
uint numlayers);
target: TEXTURE_{1D, 2D,CUBE_MAP}[_ARRAY],
TEXTURE_3D, TEXTURE_RECTANGLE,
TEXTURE_2D_MULTISAMPLE[_ARRAY]
internalformat:
R8, R8{UI, I}, R8_SNORM, R11F_G11F_B10F,
R16{F, UI, I}, R16[_SNORM],
R32{F, UI, I}, SRGB8[UI, I],
RG8{F, UI, I}, RG8[_SNORM],
RG16{F, UI, I}, RG16[_SNORM], RG32{F, UI, I},
RGB8[_SNORM], RGB9_E5, RGB10_A2[UI],
RGBA8{UI, I}, RGBA8[_SNORM],
RGB16{F, UI, I}, RGB16[_SNORM], RGB32{F, UI, I},
RGBA16{F, UI, I}, RGBA16[_SNORM],
RGBA32{F, UI, I}, SRGB8_ALPHA8;
COMPRESSED_X where X may be
[SIGNED]_RED_RGTC1, [SIGNED]_RG_RGTC2,
{RGBA, SRGB_ALPHA}_BPTC_UNORM,
RGB_BPTC_[UN]SIGNED_FLOAT
Immutable-Format Tex. Images [8.19]
void TexStorage1D(enum target, sizei levels,
enum internalformat, sizei width);
target: TEXTURE_1D
internalformat: any of the sized internal color, depth,
and stencil formats in [Tables 8.18-20]
(Continued on next page)
www.opengl.org/registry
Page 4
Textures and Samplers (cont.)
void TexStorage2D(enum target, sizei levels,
enum internalformat, sizei width,
sizei height);
OpenGL 4.5 API Reference Card
void TextureStorage3D(uint texture,
sizei levels, enum internalformat,
sizei width, sizei height, sizei depth);
internalformat: See TexStorage1D
void TextureStorage3DMultisample(
uint texture, sizei samples,
enum internalformat, sizei width,
sizei height, sizei depth,
boolean fixedsamplelocations);
void ClearTexImage(uint texture,
int level, enum format, enum type,
const void *data);
format, type: See TexImage3D, pg 2 this card
void TexStorage2DMultisample(
enum target, sizei samples,
Invalidate Texture Image Data [8.20]
enum internalformat, sizei width,
texture,
sizei height, boolean fixedsamplelocations); voidintInvalidateTexSubImage(uint
level, int xoffset, int yoffset, int zoffset,
void TexStorage3D(enum target, sizei levels,
target: TEXTURE_2D_MULTISAMPLE
sizei
width,
sizei
height,
sizei
depth);
enum internalformat, sizei width,
sizei height, sizei depth);
void TexStorage3DMultisample(
void InvalidateTexImage(uint texture, int level);
enum target, sizei samples,
target: TEXTURE_3D,
enum internalformat, sizei width,
TEXTURE_{CUBE_MAP, 2D}[_ARRAY]
Clear Texture Image Data [8.21]
sizei height, sizei depth,
internalformat: See TexStorage1D
void ClearTexSubImage(uint texture,
boolean fixedsamplelocations);
int level, int xoffset, int yoffset, int zoffset,
void TextureStorage1D(uint texture, sizei levels, target: TEXTURE_2D_MULTISAMPLE_ARRAY
enum internalformat, sizei width);
sizei width, sizei height, sizei depth,
void
TextureStorage2DMultisample(
enum format, enum type, const void *data);
internalformat: See TexStorage1D
uint texture, sizei samples,
format, type: See TexImage3D, pg 2 this card
void TextureStorage2D(uint texture,
enum internalformat, sizei width,
sizei levels, enum internalformat,
sizei height, boolean fixedsamplelocations);
sizei width, sizei height);
Texture Image Loads/Stores [8.26]
void BindImageTexture(uint index,
uint texture, int level, boolean layered,
int layer, enum access, enum format);
Framebuffer Objects
void NamedFramebufferTexture(
uint framebuffer, enum attachment,
uint texture, int level);
target: TEXTURE_{RECTANGLE, CUBE_MAP},
TEXTURE_{1D_ARRAY, 2D}
internalformat: See TexStorage1D
access: READ_ONLY, WRITE_ONLY, READ_WRITE
format: RGBA{32,16}F, RG{32,16}F, R11F_G11F_B10F,
R{32,16}F, RGBA{32,16,8}UI, RGB10_A2UI,
RG{32,16,8}UI, R{32,16,8}UI, RGBA{32,16,8}I,
RG{32,16,8}I, R{32,16,8}I, RGBA{16,8}, RGB10_A2,
RG{16,8}, R{16,8}, RGBA{16,8}_SNORM,
RG{16,8}_SNORM, R{16,8}_SNORM [Table 8.26]
void BindImageTextures(uint first,
sizei count, const uint *textures);
internalformat: See TexStorage1D
Binding and Managing [9.2]
void BindFramebuffer(enum target,
uint framebuffer);
target: [DRAW_, READ_]FRAMEBUFFER
void CreateFramebuffers(sizei n,
uint *framebuffers);
void GenFramebuffers(sizei n,
uint *framebuffers);
void DeleteFramebuffers(sizei n,
const uint *framebuffers);
boolean IsFramebuffer(uint framebuffer);
Framebuffer Object Parameters [9.2.1]
void FramebufferParameteri(
enum target, enum pname, int param);
attachment: DEPTH, FRONT_{LEFT, RIGHT}, STENCIL, void NamedRenderbufferStorage(
BACK_{LEFT, RIGHT}, COLOR_ATTACHMENTi,
uint renderbuffer, enum internalformat,
{DEPTH, STENCIL, DEPTH_STENCIL}_ATTACHMENT
sizei width, sizei height);
pname: FRAMEBUFFER_ATTACHMENT_ X where X
internalformat: See TexImage3DMultisample
may be OBJECT_{TYPE, NAME}, COMPONENT_TYPE,
{RED, GREEN, BLUE, ALPHA, DEPTH, STENCIL}_SIZE, Renderbuffer Object Queries [9.2.6]
COLOR_ENCODING, TEXTURE_{LAYER, LEVEL},
void GetRenderbufferParameteriv(
LAYERED, TEXTURE_CUBE_MAP_FACE
enum target, enum pname, int *params);
textarget: TEXTURE_1D
target, attachment: See FramebufferRenderbuffer
target: RENDERBUFFER
pname: [Table 23.27]
void FramebufferTexture2D(enum target,
RENDERBUFFER_X where X may be WIDTH,
enum attachment, enum textarget,
HEIGHT, INTERNAL_FORMAT, SAMPLES,
uint texture, int level);
{RED, GREEN, BLUE, ALPHA, DEPTH, STENCIL}_SIZE textarget: TEXTURE_CUBE_MAP_POSITIVE_{X, Y, Z},
attachment, pname: See GetFramebufferParameteriv
TEXTURE_CUBE_MAP_NEGATIVE_{X, Y, Z},
void GetNamedRenderbufferParameteriv(
Renderbuffer Objects [9.2.4]
TEXTURE_{2D, RECTANGLE, 2D_MULTISAMPLE}
uint renderbuffer, enum pname,
(unspecified if texture is 0)
void BindRenderbuffer(enum target,
int
*params);
uint renderbuffer);
target, attachment: See FramebufferRenderbuffer
pname:
See
GetRenderbufferParameteriv
target: RENDERBUFFER
void FramebufferTexture3D(enum target,
void GetNamedFramebufferAttachmentParameteriv(uint framebuffer,
enum attachment, enum pname,
int *params);
void {Create, Gen}Renderbuffers(sizei n,
uint *renderbuffers);
void DeleteRenderbuffers(sizei n,
const uint *renderbuffers);
void NamedFramebufferParameteri(
boolean IsRenderbuffer(uint renderbuffer);
uint framebuffer, enum pname, int param);
void RenderbufferStorageMultisample(
pname: See FramebufferParameteri
enum target, sizei samples,
Framebuffer Object Queries [9.2.3]
enum internalformat, sizei width,
sizei height);
void GetFramebufferParameteriv(
enum target, enum pname, int *params);
target: RENDERBUFFER
target: [DRAW_, READ_]FRAMEBUFFER
pname: FRAMEBUFFER_DEFAULT_X where X may
be WIDTH, HEIGHT, FIXED_SAMPLE_LOCATIONS,
SAMPLES, LAYERS
target: See FramebufferParameteri
pname: See FramebufferParameteri plus
DOUBLEBUFFER, SAMPLES, SAMPLE_BUFFERS,
IMPLEMENTATION_COLOR_READ_FORMAT,
IMPLEMENTATION_COLOR_READ_TYPE, STEREO
void GetNamedFramebufferParameteriv(
uint framebuffer, enum pname, int
*params);
internalformat: See TexImage3DMultisample
void
NamedRenderbufferStorageMultisample(
uint renderbuffer, sizei samples,
enum internalformat, sizei width,
sizei height);
internalformat: See TexImage3DMultisample
void RenderbufferStorage(enum target,
enum internalformat, sizei width,
void GetFramebufferAttachmentParameteriv(
sizei height);
enum target, enum attachment,
target: RENDERBUFFER
enum pname, int *params);
pname: See GetFramebufferParameteri
target: [DRAW_, READ_]FRAMEBUFFER
Vertices
Separate Patches [10.1.15]
void PatchParameteri(enum pname, int value);
pname: PATCH_VERTICES
Current Vertex Attribute Values [10.2]
Use the commands VertexAttrib*for attributes
of type float, VertexAttribI* for int or uint, or
VertexAttribL* for double.
Vertex Arrays
Vertex Array Objects [10.3.1]
All states related to definition of data used by
vertex processor is in a vertex array object.
internalformat: See TexImage3DMultisample
void VertexAttrib{1234}{s f d}(uint index,
T values);
void VertexAttrib{123}{s f d}v(uint index,
const T *values);
void VertexAttrib4{b s i f d ub us ui}v(
uint index, const T *values);
void VertexAttrib4Nub(uint index, ubyte x,
ubyte y, ubyte z, ubyte w);
void VertexAttrib4N{b s i ub us ui}v(
uint index, const T *values);
Attaching Renderbuffer Images [9.2.7]
void FramebufferRenderbuffer(
enum target, enum attachment,
enum renderbuffertarget,
uint renderbuffer);
void VertexAttribFormat(uint attribindex,
int size, enum type, boolean normalized,
unit relativeoffset);
type: [UNSIGNED_]BYTE, [UNSIGNED_]SHORT,
[UNSIGNED_]INT, [HALF_]FLOAT, DOUBLE, FIXED,
[UNSIGNED_]INT_2_10_10_10_REV,
UNSIGNED_INT_10F_11F_11F_REV
enum attachment, enum textarget,
uint texture, int level, int layer);
textarget: TEXTURE_3D (unspecified if texture is 0)
target, attachment: See FramebufferRenderbuffer
void FramebufferTextureLayer(enum target,
target: [DRAW_, READ_]FRAMEBUFFER
enum attachment, uint texture,
attachment: [Table 9.1]
int level, int layer);
{DEPTH, STENCIL, DEPTH_STENCIL}_ATTACHMENT,
target, attachment: See FramebufferRenderbuffer
COLOR_ATTACHMENTi where i is
[0, MAX_COLOR_ATTACHMENTS - 1]
void NamedFramebufferTextureLayer(
renderbuffertarget: RENDERBUFFER if renderbuffer is
uint framebuffer, enum attachment,
non-zero, else undefined
uint texture, int level, int layer);
attachment: See FramebufferRenderbuffer
void NamedFramebufferRenderbuffer(
uint framebuffer, enum attachment,
enum renderbuffertarget,
uint renderbuffer);
attachment, renderbuffertarget: See
FramebufferRenderbuffer
Attaching Texture Images [9.2.8]
void FramebufferTexture(enum target,
enum attachment, uint texture, int level);
target: [DRAW_, READ_]FRAMEBUFFER
attachment: See FramebufferRenderbuffer
void VertexAttribI{1234}{i ui}(uint index,
T values);
void VertexAttribI{1234}{i ui}v(uint index,
const T *values);
void VertexAttribI4{b s ub us}v(uint index,
const T *values);
void VertexAttribL{1234}d(uint index,
const T values);
void VertexAttribL{1234}dv(uint index,
const T *values);
Generic Vertex Attribute Arrays [10.3.2] void VertexArrayAttribFormat(uint vaobj,
void GenVertexArrays(sizei n, uint *arrays);
void DeleteVertexArrays(sizei n,
const uint *arrays);
void VertexAttribIFormat(uint attribindex,
void BindVertexArray(uint array);
int size, enum type, unit relativeoffset);
void CreateVertexArrays(sizei n, uint *arrays); type: [UNSIGNED_]BYTE, [UNSIGNED_]SHORT,
[UNSIGNED_]INT
boolean IsVertexArray(uint array);
void VertexAttribLFormat(uint attribindex,
void VertexArrayElementBuffer(uint vaobj,
int size, enum type, unit relativeoffset);
uint buffer);
type: DOUBLE
©2014 Khronos Group - Rev. 0814
attachment: See FramebufferRenderbuffer
void FramebufferTexture1D(enum target,
enum attachment, enum textarget,
uint texture, int level);
uint attribindex, int size, enum type,
boolean normalized, uint relativeoffset);
type: See VertexAttribFormat
void VertexArrayAttribIFormat(uint vaobj,
uint attribindex, int size, enum type,
uint relativeoffset);
type: See VertexAttribIFormat
void VertexArrayAttribLFormat(uint vaobj,
uint attribindex, int size, enum type,
uint relativeoffset);
type: See VertexAttribLFormat
void BindVertexBuffer(uint bindingindex,
uint buffer, intptr offset, sizei stride);
Feedback Loops [9.3.1]
void TextureBarrier(void);
Framebuffer Completeness [9.4.2]
enum CheckFramebufferStatus(enum target);
target: [DRAW_, READ_]FRAMEBUFFER
returns: FRAMEBUFFER_COMPLETE or a constant
indicating the violating value
enum CheckNamedFramebufferStatus(
uint framebuffer, enum target);
target: See CheckFramebufferStatus
void VertexAttribP{1234}ui(uint index,
enum type, boolean normalized, uint value);
void VertexAttribP{1234}uiv(uint index,
enum type, boolean normalized,
const uint *value);
type: [UNSIGNED_]INT_2_10_10_10_REV, or
UNSIGNED_INT_10F_11F_11F_REV (except for
VertexAttribP4uiv)
void VertexArrayVertexBuffer(uint vaobj,
uint bindingindex, uint buffer, intptr offset,
sizei stride);
void BindVertexBuffers(uint first,
sizei count, const uint *buffers,
const intptr *offsets, const sizei *strides);
void VertexArrayVertexBuffers(uint vaobj,
uint first, sizei count, const uint *buffers,
const intptr *offsets, const sizei *strides);
void VertexAttribBinding(uint attribindex,
uint bindingindex);
(Continued on next page)
www.opengl.org/registry
OpenGL 4.5 API Reference Card
Vertex Arrays (cont.)
void VertexArrayAttribBinding(uint vaobj,
uint attribindex, uint bindingindex);
void VertexAttribPointer(uint index, int size,
enum type, boolean normalized,
sizei stride, const void *pointer);
type: See VertexAttribFormat
void VertexAttribIPointer(uint index,
int size, enum type, sizei stride,
const void *pointer);
Page 5
Drawing Commands [10.4]
For all the functions in this section:
mode: POINTS, PATCHES,
LINE_STRIP, LINE_LOOP,
TRIANGLE_STRIP, TRIANGLE_FAN,
LINES, LINES_ADJACENCY,
TRIANGLES, TRIANGLES_ADJACENCY,
LINE_STRIP_ADJACENCY,
TRIANGLE_STRIP_ADJACENCY
type: UNSIGNED_{BYTE, SHORT, INT}
void DrawArrays(enum mode, int first,
sizei count);
void DrawArraysInstancedBaseInstance(
enum mode, int first, sizei count,
void VertexAttribLPointer(uint index, int size,
sizei instancecount, uint baseinstance);
enum type, sizei stride, const void*pointer);
void DrawArraysInstanced(enum mode,
type: DOUBLE
int first, sizei count, sizei instancecount);
void EnableVertexAttribArray(uint index);
void
DrawArraysIndirect(enum mode,
void EnableVertexArrayAttrib(uint vaobj,
const void *indirect);
uint index);
void MultiDrawArrays(enum mode,
void DisableVertexAttribArray(uint index);
const int *first, const sizei *count,
void DisableVertexArrayAttrib(uint vaobj,
sizei drawcount);
uint index);
void MultiDrawArraysIndirect(enum mode,
const void *indirect, sizei drawcount,
Vertex Attribute Divisors [10.3.4]
sizei stride);
void VertexBindingDivisor(uint bindingindex,
uint divisor);
void DrawElements(enum mode, sizei count,
void VertexArrayBindingDivisor(uint vaobj,
enum type, const void *indices);
uint bindingindex, uint divisor);
void DrawElementsInstancedBaseInstance(
void VertexAttribDivisor(uint index,
enum mode, sizei count, enum type,
uint divisor);
const void *indices, sizei instancecount,
uint baseinstance);
Primitive Restart [10.3.6]
void DrawElementsInstanced(enum mode,
Enable/Disable/IsEnabled(target);
sizei count, enum type, const void *indices,
target: PRIMITIVE_RESTART[_FIXED_INDEX]
sizei instancecount);
void PrimitiveRestartIndex(uint index);
Vertex Attributes [11.1.1]
void BindAttribLocation(uint program,
uint index, const char *name);
void GetActiveAttrib(uint program,
uint index, sizei bufSize, sizei *length,
int *size, enum *type, char *name);
Vertex Post-Processing [13]
Transform Feedback [13.2]
void GenTransformFeedbacks(sizei n,
uint *ids);
void DeleteTransformFeedbacks(sizei n,
const uint *ids);
boolean IsTransformFeedback(uint id);
void BindTransformFeedback(
enum target, uint id);
target: TRANSFORM_FEEDBACK
void CreateTransformFeedbacks(
sizei n, uint *ids);
void BeginTransformFeedback(
enum primitiveMode);
primitiveMode: TRIANGLES, LINES, POINTS
Rasterization [13.4, 14]
Enable/Disable/IsEnabled(target);
target: RASTERIZER_DISCARD
Multisampling [14.3.1]
Use to antialias points, and lines.
Enable/Disable/IsEnabled(target);
target: MULTISAMPLE, SAMPLE_SHADING
void GetMultisamplefv(enum pname,
uint index, float *val);
pname: SAMPLE_POSITION
void MinSampleShading(float value);
Points [14.4]
void PointSize(float size);
void PointParameter{i f}(enum pname,
T param);
pname, param: See PointParameter{if}v
©2014 Khronos Group - Rev. 0814
Vertex Array Queries [10.5]
void DrawRangeElements(enum mode,
uint start, uint end, sizei count,
enum type, const void *indices);
void GetVertexArrayIndexdiv(uint vaobj,
uint index, enum pname, int *param);
void DrawElementsBaseVertex(enum mode,
sizei count, enum type, const void *indices,
int basevertex);
void GetTransformFeedbackVarying(
uint program, uint index, sizei bufSize,
sizei *length, sizei *size, enum *type,
char *name);
Transform Feedback Variables [11.1.2]
void TransformFeedbackVaryings(
uint program, sizei count,
const char * const *varyings,
enum bufferMode);
*type returns NONE, FLOAT , FLOAT_VECn,
DOUBLE , DOUBLE_VECn, INT, UNSIGNED_INT,
INT_VECn, UNSIGNED_INT_VECn,
MATnxm, FLOAT_MATnxm, DOUBLE_MATnxm,
FLOAT_MATn, DOUBLE_MATn
bufferMode:
INTERLEAVED_ATTRIBS, SEPARATE_ATTRIBS
void EndTransformFeedback(void);
void PauseTransformFeedback(void);
void ResumeTransformFeedback(void);
void TransformFeedbackBufferRange(
uint xfb, uint index, uint buffer, intptr offset,
sizeiptr size);
void TransformFeedbackBufferBase(
uint xfb, uint index, uint buffer);
void DrawTransformFeedbackStream(
enum mode, uint id, uint stream);
void
DrawTransformFeedbackStreamInstanced(
enum mode, uint id, uint stream,
sizei instancecount);
Transform Feedback Drawing [13.2.3]
Primitive Clipping [13.5]
mode: See Drawing Commands [10.4] above
void DrawTransformFeedbackInstanced(
enum mode, uint id, sizei instancecount);
void PointParameter{i f}v(enum pname,
const T *params);
pname: POINT_FADE_THRESHOLD_SIZE,
POINT_SPRITE_COORD_ORIGIN
params: The fade threshold if pname is
POINT_FADE_THRESHOLD_SIZE;
{LOWER, UPPER}_LEFT if pname is
POINT_SPRITE_COORD_ORIGIN
Enable/Disable/IsEnabled(target);
target: PROGRAM_POINT_SIZE
Line Segments [14.5]
Enable/Disable/IsEnabled(target);
target: LINE_SMOOTH
void LineWidth(float width);
Polygons [14.6, 14.6.1]
Enable/Disable/IsEnabled(target);
target: POLYGON_SMOOTH, CULL_FACE
pname: ELEMENT_ARRAY_BUFFER_BINDING
pname: VERTEX_ATTRIB_RELATIVE_OFFSET or
VERTEX_ATTRIB_ARRAY_X where X is one of
ENABLED, SIZE, STRIDE, TYPE, NORMALIZED,
INTEGER, LONG, DIVISOR
void EndConditionalRender(void);
int GetAttribLocation(uint program,
const char *name);
void DrawTransformFeedback(
enum mode, uint id);
void GetVertexArrayiv(uint vaobj,
enum pname, int *param);
void GetVertexArrayIndexd64iv(uint vaobj,
void DrawRangeElementsBaseVertex(
uint index, enum pname, int64 *param);
enum mode, uint start, uint end,
sizei count, enum type, const void *indices, pname: VERTEX_BINDING_OFFSET
int basevertex);
void GetVertexAttrib{d f i}v(uint index,
enum pname, T *params);
void DrawElementsInstancedBaseVertex(
pname: See GetVertexArrayIndexediv plus
enum mode, sizei count, enum type,
VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
const void *indices, sizei instancecount,
VERTEX_ATTRIB_BINDING,
int basevertex);
CURRENT_VERTEX_ATTRIB
void DrawElementsInstancedBasevoid GetVertexAttribI{i ui}v(uint index,
VertexBaseInstance(enum mode,
enum pname, T *params);
sizei count, enum type,
pname: See GetVertexAttrib{d f i}v
const void *indices, sizei instancecount,
int basevertex, uint baseinstance);
void GetVertexAttribLdv(uint index,
enum pname, double *params);
void DrawElementsIndirect(enum mode,
pname: See GetVertexAttrib{d f i}v
enum type, const void *indirect);
void GetVertexAttribPointerv(uint index,
void MultiDrawElementsIndirect(
enum pname, const void **pointer);
enum mode, enum type,
pname: VERTEX_ATTRIB_ARRAY_POINTER
const void *indirect, sizei drawcount,
sizei stride);
Conditional Rendering [10.9]
void MultiDrawElementsBaseVertex(
void BeginConditionalRender(uint id,
enum mode, const sizei *count,
enum mode);
enum type, const void *const *indices,
mode: QUERY _[NO_]WAIT[_INVERTED],
sizei drawcount, const int *basevertex);
QUERY_BY_REGION_[NO_]WAIT[_INVERTED]
type: See VertexAttribIFormat
index: [0, MAX_VERTEX_ATTRIBS - 1]
Vertex shaders operate on array of
4-component items numbered from slot 0 to
MAX_VERTEX_ATTRIBS - 1.
void MultiDrawElements(enum mode,
const sizei *count, enum type,
const void * const *indices,
sizei drawcount);
Flatshading [13.4]
void ProvokingVertex(enum provokeMode);
provokeMode: {FIRST, LAST}_VERTEX_CONVENTION
Enable/Disable/IsEnabled(target);
target: DEPTH_CLAMP, CLIP_DISTANCEi where
i = [0..MAX_CLIP_DISTANCES - 1]
void ClipControl(enum origin, enum depth);
origin: LOWER_LEFT or UPPER_LEFT
depth: NEGATIVE_ONE_TO_ONE or ZERO_TO_ONE
void FrontFace(enum dir);
dir: CCW, CW
void CullFace(enum mode);
mode: FRONT, BACK, FRONT_AND_BACK
Polygon Rast. & Depth Offset [14.6.4-5]
void PolygonMode(enum face, enum mode);
face: FRONT_AND_BACK
mode: POINT, LINE, FILL
void PolygonOffset(float factor, float units);
Enable/Disable/IsEnabled(target);
target: POLYGON_OFFSET_{POINT, LINE, FILL}
Shader Execution [11.1.3]
void ValidateProgram(uint program);
void ValidateProgramPipeline(uint pipeline);
Tessellation Prim. Generation [11.2.2]
void PatchParameterfv(enum pname,
const float *values);
pname: PATCH_DEFAULT_INNER_LEVEL,
PATCH_DEFAULT_OUTER_LEVEL
Controlling Viewport [13.6.1]
void DepthRangeArrayv(uint first,
sizei count, const double *v);
void DepthRangeIndexed(uint index,
double n, double f);
void DepthRange(double n, double f);
void DepthRangef(float n, float f);
void ViewportArrayv(uint first, sizei count,
const float *v);
void ViewportIndexedf(uint index, float x,
float y, float w, float h);
void ViewportIndexedfv(uint index,
const float *v);
void Viewport(int x, int y, sizei w, sizei h);
Fragment Shaders [15.2]
void BindFragDataLocationIndexed(
uint program, uint colorNumber,
uint index, const char *name);
void BindFragDataLocation(uint program,
uint colorNumber, const char *name);
int GetFragDataLocation(uint program,
const char *name);
int GetFragDataIndex(uint program,
const char *name);
Compute Shaders [19]
void DispatchCompute(uint num_groups_x,
uint num_groups_y, uint num_groups_z);
void DispatchComputeIndirect(
intptr indirect);
www.opengl.org/registry
Page 6
Per-Fragment Operations
Scissor Test [17.3.2]
Enable/Disable/IsEnabled(SCISSOR_TEST);
Enablei/Disablei/IsEnabledi(SCISSOR_TEST,
uint index);
void ScissorArrayv(uint first, sizei count,
const int *v);
void ScissorIndexed(uint index, int left,
int bottom, sizei width, sizei height);
void ScissorIndexedv(uint index, int *v);
void Scissor(int left, int bottom, sizei width,
sizei height);
Multisample Fragment Ops. [17.3.3]
Enable/Disable/IsEnabled(target);
target: SAMPLE_ALPHA_TO_{COVERAGE, ONE},
SAMPLE_COVERAGE, SAMPLE_MASK
void SampleCoverage(float value,
boolean invert);
void SampleMaski(uint maskNumber,
bitfield mask);
Stencil Test [17.3.5]
Enable/Disable/IsEnabled(STENCIL_TEST);
Whole Framebuffer
OpenGL 4.5 API Reference Card
void StencilFunc(enum func, int ref,
uint mask);
func: NEVER, ALWAYS, LESS, GREATER, EQUAL,
LEQUAL, GEQUAL, NOTEQUAL
void StencilFuncSeparate(enum face,
enum func, int ref, uint mask);
func: See StencilFunc
void StencilOp(enum sfail, enum dpfail,
enum dppass);
void StencilOpSeparate(enum face,
enum sfail, enum dpfail, enum dppass);
face: FRONT, BACK, FRONT_AND_BACK
sfail, dpfail, dppass: KEEP, ZERO, REPLACE, INCR,
DECR, INVERT, INCR_WRAP, DECR_WRAP
Depth Buffer Test [17.3.6]
Enable/Disable/IsEnabled(DEPTH_TEST);
void DepthFunc(enum func);
func: See StencilFunc
Occlusion Queries [17.3.7]
BeginQuery(enum target, uint id);
EndQuery(enum target);
target: SAMPLES_PASSED, ANY_SAMPLES_PASSED,
ANY_SAMPLES_PASSED_CONSERVATIVE
Fine Control of Buffer Updates [17.4.2]
void ColorMask(boolean r, boolean g,
Selecting Buffers for Writing [17.4.1]
boolean b, boolean a);
void DrawBuffer(enum buf);
void ColorMaski(uint buf, boolean r,
buf: [Tables 17.4-5] NONE,
boolean g, boolean b, boolean a);
{FRONT, BACK}_{LEFT, RIGHT}, FRONT, BACK, LEFT,
RIGHT, FRONT_AND_BACK,
void DepthMask(boolean mask);
COLOR_ATTACHMENTi (i = [0,
void StencilMask(uint mask);
MAX_COLOR_ATTACHMENTS - 1 ])
void StencilMaskSeparate(enum face,
void NamedFramebufferDrawBuffer(
uint mask);
uint framebuffer, enum buf);
buf: See DrawBuffer
void DrawBuffers(sizei n, const enum *bufs);
face: FRONT, BACK, FRONT_AND_BACK
Clearing the Buffers [17.4.3]
*bufs: [Tables 17.5-6] {FRONT, BACK}_{LEFT, RIGHT}, void Clear(bitfield buf);
buf: 0 or the OR of
NONE, COLOR_ATTACHMENTi (i = [0,
{COLOR, DEPTH, STENCIL}_BUFFER_BIT
MAX_COLOR_ATTACHMENTS - 1 ])
void NamedFramebufferDrawBuffers(
uint framebuffer, sizei n,
const enum *bufs);
*bufs: See DrawBuffers
Reading and Copying Pixels
Reading Pixels [18.2]
void ReadBuffer(enum src);
src: NONE, {FRONT, BACK}_{LEFT, RIGHT},
FRONT, BACK, LEFT, RIGHT,
FRONT_AND_BACK, COLOR_ATTACHMENTi
(i = [0, MAX_COLOR_ATTACHMENTS - 1 ])
void NamedFramebufferReadBuffer(
uint framebuffer, enum src);
src: See ReadBuffer
void ReadPixels(int x, int y, sizei width,
sizei height, enum format, enum type,
void *data);
format: STENCIL_INDEX, RED, GREEN, BLUE,
RG, RGB, RGBA, BGR, DEPTH_{COMPONENT,
STENCIL}, {RED, GREEN, BLUE, RG, RGB}_
INTEGER, {RGBA, BGR, BGRA}_INTEGER,
BGRA [Table 8.3]
type: [HALF_]FLOAT, [UNSIGNED_]BYTE,
[UNSIGNED_]SHORT, [UNSIGNED_]INT,
FLOAT_32_UNSIGNED_INT_24_8_REV,
UNSIGNED_{BYTE, SHORT, INT}_*
values in [Table 8.2]
void ReadnPixels(int x, int y, sizei width,
sizei height, enum format, enum type,
sizei bufSize, void *data);
format, type: See ReadPixels
Final Conversion [18.2.8]
void ClampColor(enum target, enum clamp);
target: CLAMP_READ_COLOR
clamp: TRUE, FALSE, FIXED_ONLY
Copying Pixels [18.3]
void BlitFramebuffer(int srcX0, int srcY0,
int srcX1, int srcY1, int dstX0, int dstY0,
int dstX1, int dstY1, bitfield mask,
enum filter);
©2014 Khronos Group - Rev. 0814
void BlendFunci(uint buf, enum src, enum dst);
Blending [17.3.8]
src, dst: See BlendFuncSeparate
Enable/Disable/IsEnabled(BLEND);
void BlendFuncSeparatei(uint buf,
Enablei/Disablei/IsEnabledi(BLEND,
enum srcRGB, enum dstRGB,
uint index);
enum srcAlpha, enum dstAlpha);
void BlendEquation(enum mode);
dstRGB, dstAlpha, srcRGB, srcAlpha:
See BlendFuncSeparate
void BlendEquationSeparate(enum modeRGB,
enum modeAlpha);
void BlendColor(float red, float green, float blue,
modeRGB, modeAlpha: MIN, MAX ,
float alpha);
FUNC_{ADD, SUBTRACT, REVERSE_SUBTRACT}
void BlendEquationi(uint buf, enum mode);
void BlendEquationSeparatei(uint buf,
enum modeRGB, enum modeAlpha);
modeRGB, modeAlpha:
See BlendEquationSeparate
void BlendFunc(enum src, enum dst);
src, dst: See BlendFuncSeparate
void BlendFuncSeparate(enum srcRGB,
enum dstRGB, enum srcAlpha,
enum dstAlpha);
srcRGB, dstRGB, srcAlpha, dstAlpha:
ZERO, ONE, SRC_ALPHA_SATURATE,
{SRC, SRC1, DST, CONSTANT}_{COLOR, ALPHA},
ONE_MINUS_{SRC, SRC1}_{COLOR, ALPHA},
ONE_MINUS_{DST, CONSTANT}_{COLOR, ALPHA}
void ClearBuffer{i f ui}v(enum buffer,
int drawbuffer, const T *value);
buffer: COLOR, DEPTH, STENCIL
void ClearNamedFramebuffer{i f ui}v(
uint framebuffer, enum buffer,
int drawbuffer, const T *value);
buffer: See ClearBuffer{i f ui}v
void ClearBufferfi(enum buffer,
int drawbuffer, float depth, int stencil);
buffer: DEPTH_STENCIL
void ClearNamedFramebufferfi(
uint framebuffer, enum buffer,
int drawbuffer, float depth, int stencil);
buffer: See ClearBufferi
Invalidating Framebuffers [17.4.4]
void ClearColor(float r, float g, float b, float a); void InvalidateSubFramebuffer(
enum target, sizei numAttachments,
void ClearDepth(double d);
const enum *attachments, int x, int y,
void ClearDepthf(float d);
sizei width, sizei height);
void ClearStencil(int s);
target: [DRAW_ , READ_]FRAMEBUFFER
Debug Output [20]
severity: DEBUG_SEVERITY_{HIGH, MEDIUM},
DEBUG_SEVERITY_{LOW, NOTIFICATION}
Enable/Disable/IsEnabled(DEBUG_OUTPUT);
Controlling Debug Messages [20.4]
Debug Message Callback [20.2]
void DebugMessageControl(enum source,
void DebugMessageCallback(
enum type, enum severity, sizei count,
DEBUGPROC callback,
const uint *ids, boolean enabled);
const void *userParam);
callback: has the following prototype:
void callback(enum source, enum type,
uint id, enum severity, sizei length,
const char *message,
const void*userParam);
source: DEBUG_SOURCE_X where X may be API,
SHADER_COMPILER, WINDOW_SYSTEM,
THIRD_PARTY, APPLICATION, OTHER
type: DEBUG_TYPE_X where X may be ERROR,
MARKER, OTHER, DEPRECATED_BEHAVIOR,
UNDEFINED_BEHAVIOR, PERFORMANCE,
PORTABILITY, {PUSH, POP}_GROUP
mask: Bitwise 0 of the bitwise OR of
{COLOR, DEPTH, STENCIL}_BUFFER_BIT
filter: LINEAR, NEAREST
void BlitNamedFramebuffer(
uint readFramebuffer,
uint drawFramebuffer, int srcX0,
int srcY0, int srcX1, int srcY1, int dstX0,
int dstY0, int dstX1, int dstY1,
bitfield mask, enum filter);
mask, filter: See BlitFramebuffer
void CopyImageSubData(uint srcName,
enum srcTarget, int srcLevel, int srcX,
int srcY, int srcZ, uint dstName,
enum dstTarget, int dstLevel, int dstX,
int dstY, int dstZ, sizei srcWidth,
sizei srcHeight, sizei srcDepth);
srcTarget, dstTarget: See target for BindTexture in
section [8.1] on this card, plus
GL_RENDERTARGET
source, type, severity: See DebuckMessageCallback
(above), plus DONT_CARE
Externally Generated Messages [20.5]
void DebugMessageInsert(enum source,
enum type, uint id, enum severity,
int length, const char *buf);
source: DEBUG_SOURCE_{APPLICATION, THIRD_PARTY}
type, severity: See DebugMessageCallback
Debug Groups [20.6]
void PushDebugGroup(enum source,
uint id, sizei length, const char *message);
source: See DebugMessageInsert
void PopDebugGroup(void);
Dithering [17.3.10]
Enable/Disable/IsEnabled(DITHER);
Logical Operation [17.3.11]
Enable/Disable/IsEnabled(COLOR_LOGIC_OP);
void LogicOp(enum op);
op: CLEAR, AND, AND_REVERSE, COPY, AND_INVERTED,
NOOP, XOR, OR, NOR, EQUIV, INVERT, OR_REVERSE,
COPY_INVERTED, OR_INVERTED, NAND, SET
Hints [21.5]
void Hint(enum target, enum hint);
target: FRAGMENT_SHADER_DERIVATIVE_HINT,
TEXTURE_COMPRESSION_HINT,
{LINE, POLYGON}_SMOOTH_HINT
hint: FASTEST, NICEST, DONT_CARE
attachments: COLOR_ATTACHMENTi, DEPTH, COLOR,
{DEPTH, STENCIL, DEPTH_STENCIL}_ATTACHMENT,
{FRONT, BACK}_{LEFT, RIGHT}, STENCIL
void InvalidateNamedFramebufferSubData(
uint framebuffer, sizei numAttachments,
const enum *attachments, int x, int y,
sizei width, sizei height);
attachments: See InvalidateSubFramebuffer
void InvalidateFramebuffer(
enumtarget, sizei numAttachments,
const enum *attachments);
target, *attachments: See InvalidateSubFramebuffer
void InvalidateNamedFramebufferData(
uint framebuffer, sizei numAttachments,
const enum *attachments);
*attachments: See InvalidateSubFramebuffer
Debug Labels [20.7]
void ObjectLabel(enum identifier, uint name,
sizei length, const char *label);
identifier: BUFFER, FRAMEBUFFER, RENDERBUFFER,
PROGRAM_PIPELINE, PROGRAM,
QUERY, SAMPLER, SHADER, TEXTURE,
TRANSFORM_FEEDBACK, VERTEX_ARRAY
void ObjectPtrLabel(void* ptr, sizei length,
const char *label);
Synchronous Debug Output [20.8]
Enable/Disable/IsEnabled(
DEBUG_OUTPUT_SYNCHRONOUS);
Debug Output Queries [20.9]
uint GetDebugMessageLog(uint count,
sizei bufSize, enum *sources, enum *types,
uint *ids, enum *severities, sizei *lengths,
char *messageLog);
void GetObjectLabel(enum identifier,
uint name, sizei bufSize, sizei *length,
char *label);
void GetObjectPtrLabel(void* ptr, sizei bufSize,
sizei *length, char *label);
State and State Requests
void GetIntegeri_v(enum target, uint index,
int *data);
void GetFloati_v(enum target, uint index,
float *data);
Simple Queries [22.1]
void GetBooleanv(enum pname, boolean *data); void GetInteger64i_v(enum target, uint index,
int64 *data);
void GetIntegerv(enum pname, int *data);
boolean IsEnabled(enum cap);
void GetInteger64v(enum pname, int64 *data);
boolean IsEnabledi(enum target, uint index);
void GetFloatv(enum pname, float *data);
String Queries [22.2]
void GetDoublev(enum pname, double *data); void GetPointerv(enum pname, void **params);
void GetDoublei_v(enum target, uint index,
ubyte *GetString(enum name);
double *data);
name: RENDERER, VENDOR, VERSION,
SHADING_LANGUAGE_VERSION
void GetBooleani_v(enum target, uint index,
boolean *data);
(Continued on next page)
A complete list of symbolic constants for states is
shown in the tables in [23].
www.opengl.org/registry
OpenGL 4.5 API Reference Card
Page 7
States (cont.)
pname:
CLEAR_{BUFFER, TEXTURE},
COLOR_ENCODING,
COLOR_{COMPONENTS, RENDERABLE},
name: EXTENSIONS, SHADING_LANGUAGE_VERSION
COMPUTE_TEXTURE,
index:
DEPTH_{COMPONENTS, RENDERABLE},
[0, NUM_EXTENSIONS - 1] (if name is EXTENSIONS);
FILTER, FRAMEBUFFER_BLEND,
[0, NUM_SHADING_LANGUAGE_VERSIONS-1]
FRAMEBUFFER_RENDERABLE[_LAYERED],
(if name is SHADING_LANGUAGE_VERSION)
{FRAGMENT, GEOMETRY}_TEXTURE,
Internal Format Queries [22.3]
GET_TEXTURE_IMAGE_FORMAT,
GET_TEXTURE_IMAGE_TYPE,
void GetInternalformativ(enum target,
IMAGE_COMPATIBILITY_CLASS,
enum internalformat, enum pname,
IMAGE_PIXEL_{FORMAT, TYPE},
sizei bufSize, int *params);
IMAGE_FORMAT_COMPATIBILITY_TYPE,
target, pname, internalformat:
IMAGE_TEXEL_SIZE,
See GetInternalformati64v
INTERNALFORMAT_{PREFERRED, SUPPORTED},
void GetInternalformati64v(enum target,
INTERNALFORMAT_{RED, GREEN, BLUE}_SIZE,
enum internalformat, enum pname,
INTERNALFORMAT_{DEPTH, STENCIL}_SIZE,
sizei bufSize, int64 *params);
INTERNALFORMAT_{ALPHA, SHARED}_SIZE,
target: [Table 22.2]
INTERNALFORMAT_{RED, GREEN}_TYPE,
TEXTURE_{1D, 2D, 3D, CUBE_MAP}[_ARRAY],
INTERNALFORMAT_{BLUE, ALPHA}_TYPE,
TEXTURE_2D_MULTISAMPLE[_ARRAY],
INTERNALFORMAT_{DEPTH, STENCIL}_TYPE,
TEXTURE_{BUFFER, RECTANGLE}, RENDERBUFFER
[MANUAL_GENERATE_]MIPMAP,
internalformat: any value
ubyte *GetStringi(enum name, uint index);
MAX_COMBINED_DIMENSIONS,
MAX_{WIDTH, HEIGHT, DEPTH, LAYERS},
NUM_SAMPLE_COUNTS,
READ_PIXELS[_FORMAT, _TYPE],
SAMPLES, SHADER_IMAGE_ATOMIC,
SHADER_IMAGE_{LOAD, STORE},
SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST,
SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE,
SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST,
SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE,
SRGB_{READ, WRITE},
STENCIL_{COMPONENTS, RENDERABLE},
TESS_{CONTROL, EVALUATION}_TEXTURE,
TEXTURE_COMPRESSED[_BLOCK_SIZE],
TEXTURE_COMPRESSED_BLOCK_{HEIGHT, WIDTH}
TEXTURE_GATHER[_SHADOW],
TEXTURE_IMAGE_FORMAT,
TEXTURE_IMAGE_TYPE,
TEXTURE_{SHADOW, VIEW},
VERTEX_TEXTURE,
VIEW_COMPATIBILITY_CLASS
TransformFeedback Queries [22.4]
void GetTransformFeedbackiv(uint xfb,
enum pname, int *param);
pname: TRANSFORM_FEEDBACK_{PAUSED, ACTIVE}
void GetTransformFeedbacki_v(uint xfb,
enum pname, uint index, int *param);
pname: TRANSFORM_FEEDBACK_BUFFER_BINDING
void GetTransformFeedbacki64_v(uint xfb,
enum pname, uint index, int64 *param);
pname: TRANSFORM_FEEDBACK_BUFFER_START,
TRANSFORM_FEEDBACK_BUFFER_SIZE
OpenGL Compute Programming Model and Compute Memory Hierarchy
gl_NumWorkGroups = (4,2,0)
Use the barrier function to synchronize invocations in a work group:
void barrier();
Use the memoryBarrier* or groupMemoryBarrier functions to order
reads/writes accessible to other invocations:
void memoryBarrier();
void memoryBarrierAtomicCounter();
void memoryBarrierBuffer();
void memoryBarrierImage();
// Only for compute shaders
void memoryBarrierShared();
void groupMemoryBarrier();
// Only for compute shaders
gl_WorkGroupSize = (4,2,0)
gl_WorkGroupID = (2,0,0)
gl_LocalInvocationID = (1,0,0)
gl_GlobalInvocationID = (9,3,0)
Use the compute shader built-in variables to specifiy work groups and invocations:
in vec3 gl_NumWorkGroups;
// Number of workgroups dispatched
const vec3 gl_WorkGroupSize;
// Size of each work group for current shader
// Index of current work group being executed
in vec3 gl_WorkGroupID;
in vec3 gl_LocalInvocationID; // index of current invocation in a work group
in vec3 gl_GlobalInvocationID; // Unique ID across all work groups and threads. (gl_GlobalInvocationID = gl_WorkGroupID * gl_WorkGroupSize + gl_LocalInvocationID)
OpenGL Texture Views and Texture Object State
T
Texture state set with TextureView()
enum internalformat // base internal format
enum target
// texture target
Sampler Parameters (mutable)
TEXTURE_BORDER_COLOR
TEXTURE_COMPARE_{FUNC,MODE}
TEXTURE_LOD_BIAS
TEXTURE_{MAX,MIN}_LOD
TEXTURE_{MAG,MIN}_FILTER
TEXTURE_WRAP_{S,T,R}
©2014 Khronos Group - Rev. 0814
uint minlevel
uint numlevels
// first level of mipmap
// number of mipmap levels
Texture Parameters (immutable)
TEXTURE_WIDTH
TEXTURE_DEPTH
TEXTURE_COMPRESSED
TEXTURE_IMMUTABLE_FORMAT
Texture Parameters (mutable)
TEXTURE_SWIZZLE_{R,G,B,A}
TEXTURE_BASE_LEVEL
TEXTURE_HEIGHT
TEXTURE_FIXED_SAMPLE_LOCATIONS
TEXTURE_COMPRESSED_IMAGE_SIZE
TEXTURE_SAMPLES
TEXTURE_MAX_LEVEL
DEPTH_STENCIL_TEXTURE_MODE
uint minlayer
uint numlayers
// first layer of array texture
// number of layers in array
Texture View Parameters (immutable)
TEXTURE_INTERNAL_FORMAT
TEXTURE_SHARED_SIZE
TEXTURE_VIEW_{MIN,NUM}_LEVEL
TEXTURE_VIEW_{MIN,NUM}_LAYER
TEXTURE_IMMUTABLE_LEVELS
IMAGE_FORMAT_COMPATIBILITY_TYPE
TEXTURE_{RED,GREEN,BLUE,ALPHA,DEPTH}_TYPE
TEXTURE_{RED,GREEN,BLUE,ALPHA,DEPTH,STENCIL}_SIZE
www.opengl.org/registry
Page 8
OpenGL 4.5 API Reference Card
OpenGL Pipeline
A typical program that uses OpenGL
begins with calls to open a window into
the framebuffer into which the program
will draw. Calls are made to allocate a GL
context which is then associated with the
window, then OpenGL commands can be
issued.
The heavy black arrows in this illustration
show the OpenGL pipeline and indicate
data flow.
Blue blocks indicate various buffers
that feed or get fed by the OpenGL
pipeline.
Green blocks indicate fixed function
stages.
Yellow blocks indicate programmable
stages.
T
Texture binding
B Buffer binding
Vertex & Tessellation Details
Each vertex is processed either by a vertex shader
or fixed-function vertex processing (compatibility
only) to generate a transformed vertex, then
assembled into primitives. Tessellation (if enabled)
operates on patch primitives, consisting of a fixedsize collection of vertices, each with per-vertex
attributes and associated per-patch attributes.
Tessellation control shaders (if enabled) transform
an input patch and compute per-vertex and perpatch attributes for a new output patch.
A fixed-function primitive generator
subdivides the patch according to
tessellation levels computed in the
tessellation control shaders or specified
as fixed values in the API (TCS disabled).
The tessellation evaluation shader
computes the position and attributes of
each vertex produced by the tessellator.
Orange blocks indicate features of the Core
specification.
Purple blocks indicate features of the
Compatibility specification.
Green blocks indicate features new or
significantly changed with OpenGL 4.x.
Geometry & Follow-on Details
Geometry shaders (if enabled) consume
individual primitives built in previous primitive
assembly stages. For each input primitive,
the geometry shader can output zero or more
vertices, with each vertex directed at a specific
vertex stream. The vertices emitted to each
stream are assembled into primitives according
to the geometry shader’s output primitive type.
Transform feedback (if active) writes selected
vertex attributes of the primitives of all vertex
streams into buffer objects attached to one or
more binding points.
Primitives on vertex stream zero are then
processed by fixed-function stages, where they
are clipped and prepared for rasterization.
Orange blocks indicate features of the Core
specification.
Purple blocks indicate features of the
Compatibility specification.
Green blocks indicate features new or
significantly changed with OpenGL 4.x.
©2014 Khronos Group - Rev. 0814
www.opengl.org/registry
OpenGL Shading Language 4.50 Reference Card
The OpenGL® Shading Language is used to create
shaders for each of the programmable processors
contained in the OpenGL processing pipeline. The
OpenGL Shading Language is actually several closely
related languages. Currently, these processors are the
vertex, tessellation control, tessellation evaluation,
geometry, fragment, and compute shaders.
[n.n.n] and [Table n.n] refer to sections and tables in
the OpenGL Shading Language 4.50 specification at
www.opengl.org/registry
Operators and Expressions [5.1]
The following operators are numbered in order
of precedence. Relational and equality operators
evaluate to Boolean. Also See lessThan(), equal().
1.
()
2.
[]
()
.
++ --
parenthetical grouping
array subscript
function call, constructor, structure
field, selector, swizzle
postfix increment and decrement
Types [4.1]
double
vec2, vec3, vec4
dvec2, dvec3, dvec4
bvec2, bvec3, bvec4
ivec2, ivec3, ivec4
uvec2, uvec3, uvec4
mat2, mat3, mat4
mat2x2, mat2x3,
mat2x4
mat3x2, mat3x3,
mat3x4
mat4x2, mat4x3,
mat4x4
dmat2, dmat3,
dmat4
dmat2x2, dmat2x3,
dmat2x4
dmat3x2, dmat3x3,
dmat3x4
dmat4x2, dmat4x3,
dmat4x4
no function return value
Boolean
signed/unsigned integers
single-precision floating-point
scalar
double-precision floating scalar
floating point vector
double precision floating-point
vectors
Boolean vectors
signed and unsigned integer
vectors
2x2, 3x3, 4x4 float matrix
2-column float matrix of
2, 3, or 4 rows
3-column float matrix of
2, 3, or 4 rows
4-column float matrix of
2, 3, or 4 rows
2x2, 3x3, 4x4 double-precision
float matrix
2-col. double-precision float
matrix of 2, 3, 4 rows
3-col. double-precision float
matrix of 2, 3, 4 rows
4-column double-precision float
matrix of 2, 3, 4 rows
Qualifiers
Storage Qualifiers [4.3]
Declarations may have one storage qualifier.
(default) local read/write memory,
none
or input parameter
const
read-only variable
in
linkage into shader from previous stage
out
linkage out of a shader to next stage
uniform
buffer
shared
4.
5.
6.
7.
8.
9.
10.
Preprocessor [3.3]
Preprocessor Operators
#version 450
#version 450 profile
#extension
extension_name :
behavior
#extension all : behavior
Preprocessor Directives
#
#if
#define
#ifdef
Predefined Macros
Required when using version 4.50.
profile is core, compatibility, or es (for
ES versions 1.00, 3.00, or 3.10).
• behavior: require, enable, warn,
disable
• extension_name: extension
supported by compiler, or “all”
#elif
#ifndef
11.
12.
13.
14.
15.
prefix increment and decrement
unary
*/%
multiplicative
+additive
<< >>
bit-wise shift
< > <= >= relational
== !=
equality
&
bit-wise and
^
bit-wise exclusive or
linkage between a shader, OpenGL,
and the application
accessible by shaders and OpenGL API
compute shader only, shared among work
items in a local work group
Auxiliary Storage Qualifiers
Use to qualify some input and output variables:
centroid
centroid-based interpolation
sampler
per-sample interpolation
patch
per-tessellation-patch attributes
Interface Blocks [4.3.9]
in, out, uniform, and buffer variable
declarations can be grouped. For example:
uniform Transform {
// allowed restatement qualifier:
mat4 ModelViewMatrix;
uniform mat3 NormalMatrix;
};
©2014 Khronos Group - Rev. 0814
sampler{1D,2D,3D}
image{1D,2D,3D}
samplerCube
imageCube
sampler2DRect
image2DRect
sampler{1D,2D}Array
image{1D,2D}Array
samplerBuffer
imageBuffer
sampler2DMS
image2DMS
sampler2DMSArray
image2DMSArray
samplerCubeArray
imageCubeArray
sampler1DShadow
sampler2DShadow
sampler2DRectShadow
sampler1DArrayShadow
sampler2DArrayShadow
samplerCubeShadow
#else
#line
|
&&
^^
||
?:
= += -=
*= /=
16.
%= <<= >>=
&= ^= |=
17.
,
++ -+-~!
Floating-Point Opaque Types
Transparent Types
void
bool
int, uint
float
3.
Page 9
__VERSION__
Decimal integer constants. __FILE__ says
which source string is being processed.
Decimal integer, e.g.: 450
GL_core_profile
Defined as 1
GL_es_profile
1 if the ES profile is supported
Defined as 1 if the implementation
supports the compatibility profile.
__LINE__
GL_compatibility_profile
#endif
#pragma
#error
#undef
bit-wise inclusive or
logical and
logical exclusive or
logical inclusive or
selects an entire operand
assignment
arithmetic assignments
sequence
Signed Integer Opaque Types (cont’d)
1D, 2D, or 3D texture
iimage2DRect
isampler[1,2]DArray
iimage[1,2]DArray
isamplerBuffer
iimageBuffer
isampler2DMS
iimage2DMS
isampler2DMSArray
iimage2DMSArray
isamplerCubeArray
iimageCubeArray
__FILE__
#extension
#version
Vector & Scalar Components [5.5]
In addition to array numeric subscript syntax,
names of vector and scalar components are
denoted by a single letter. Components can be
swizzled and replicated. Scalars have only an x, r,
or s component.
{x, y, z, w} Points or normals
{r, g, b, a}
Colors
{s, t, p, q}
Texture coordinates
Unsigned Integer Opaque Types (cont’d)
int. 2D rectangular image
uimage2DMSArray uint 2D multi-sample array image
integer 1D, 2D array texture
usamplerCubeArray uint cube map array texture
cube mapped texture
integer 1D, 2D array image
uimageCubeArray uint cube map array image
integer buffer texture
rectangular texture
Implicit Conversions
integer buffer image
int
-> uint
uvec2 -> dvec2
1D or 2D array texture
int. 2D multi-sample texture
int, uint
-> float
uvec3 -> dvec3
int. 2D multi-sample image
int, uint, float -> double
uvec4 -> dvec4
buffer texture
ivec2
-> uvec2
vec2
-> dvec2
int. 2D multi-sample array tex.
ivec3
-> uvec3
vec3
-> dvec3
int. 2D multi-sample array image ivec4
2D multi-sample texture
-> uvec4
vec4
-> dvec4
ivec2
-> vec2
mat2
-> dmat2
int. cube map array texture
ivec3
-> vec3
mat3
-> dmat3
2D multi-sample array
int. cube map array image
ivec4
-> vec4
mat4
-> dmat4
texture
uvec2
-> vec2
mat2x3 -> dmat2x3
cube map array texture Unsigned Integer Opaque Types
uvec3
-> vec3
mat2x4 -> dmat2x4
atomic_uint
uint atomic counter
uvec4
-> vec4
mat3x2 -> dmat3x2
1D or 2D depth texture
ivec2
-> dvec2
mat3x4 -> dmat3x4
usampler[1,2,3]D
uint 1D, 2D, or 3D texture
with comparison
ivec3
-> dvec3
mat4x2 -> dmat4x2
uint 1D, 2D, or 3D image
rectangular tex. / compare uimage[1,2,3]D
ivec4
-> dvec4
mat4x3 -> dmat4x4
usamplerCube
uint cube mapped texture
1D or 2D array depth
texture with comparison
uimageCube
uint cube mapped image
Aggregation
of
Basic
Types
cube map depth texture usampler2DRect
uint rectangular texture
Arrays
float[3] foo; float foo[3]; int a [3][2];
with comparison
uimage2DRect
uint rectangular image
// Structures, blocks, and structure members
samplerCubeArrayShadow cube map array depth
// can be arrays. Arrays of arrays supported.
usampler[1,2]DArray 1D or 2D array texture
texture with comparison
Structures struct type-name {
uimage[1,2]DArray 1D or 2D array image
members
Signed Integer Opaque Types
usamplerBuffer
uint buffer texture
} struct-name[];
isampler[1,2,3]D
integer 1D, 2D, or 3D texture
uimageBuffer
uint buffer image
// optional variable declaration
iimage[1,2,3]D
integer 1D, 2D, or 3D image
usampler2DMS
uint 2D multi-sample texture
Blocks
in/out/uniform block-name {
isamplerCube
integer cube mapped texture
// interface matching by block name
uimage2DMS
uint 2D multi-sample image
iimageCube
integer cube mapped image
optionally-qualified members
usampler2DMSArray uint 2D multi-sample array tex.
} instance-name[];
isampler2DRect
int. 2D rectangular texture
Continue
// optional instance name, optionally an array
Continue
Layout Qualifiers [4.4]
The following table summarizes the use of layout qualifiers applied to non-opaque types and the kinds of declarations they may be applied to.
Op = Opaque types only, FC = gl_FragCoord only, FD = gl_FragDepth only.
Indiv.
Block
Layout Qualifier Qualif.
Only Var. Block Mem.
shared, packed, std{140, 430} X
X
{row, column}_major X
X
X
binding =
Op
X
offset =
X
align =
X
X
location =
X
location =
component =
X
X
index =
X
triangles, quads, isolines
equal_spacing,
fractional_even_spacing,
fractional_odd_spacing
cw, ccw
point_mode
points
[ points ], lines, triangles,
{triangles, lines}_adjacency
invocations =
X
X
X
Allowed Interfaces
uniform/buffer
uniform/buffer and
subroutine variables
all in/out, except for
compute
fragment out and
subroutine functions
X
X
X
X
X
tessellation evaluation
in
geometry in/out
X
geometry in
X
geometry in
Indiv.
Block
Layout Qualifier Qualif.
Only Var. Block Mem. Allowed Interfaces
origin_upper_left
FC
pixel_center_integer
fragment in
early_fragment_tests X
local_size_{x, y, z} = X
compute in
xfb_{buffer, stride} = X
X
X
X vertex, tessellation, and
geometry out
xfb_offset =
X
X
X
vertices = X
tessellation control out
[ points ], line_strip,
X
triangle_strip
geometry out
max_vertices = X
stream = X
X
X
X
depth_{any, greater,
FD
fragment out
less, unchanged}
Opaque Uniform Layout Qualifiers [4.4.6]
Used to bind opaque uniform variables to specific buffers or units.
binding = integer-constant-expression
Atomic Counter Layout Qualifiers
binding = integer-constant-expression
offset = integer-constant-expression
(Continued on next page)
www.opengl.org/registry
Page 10
OpenGL Shading Language 4.50 Reference Card
Qualifiers (continued)
Format Layout Qualifiers
One qualifier may be used with variables
declared as “image” to specify the image format.
binding = integer-constant-expression,
rgba{32,16}f, rg{32,16}f, r{32,16}f,
rgba{16,8}, r11f_g11f_b10f, rgb10_a2{ui},
rg{16,8}, r{16,8}, rgba{32,16,8}i, rg{32,16,8}
i, r{32,16,8}i, rgba{32,16,8}ui, rg{32,16,8}ui,
r{32,16,8}ui, rgba{16,8}_snorm,
rg{16,8}_snorm, r{16,8}_snorm
Interpolation Qualifiers [4.5]
Qualify outputs from vertex shader and inputs
to fragment shader.
smooth
perspective correct interpolation
flat
no interpolation
noperspective linear interpolation
Parameter Qualifiers [4.6]
Input values copied in at function call time,
output values copied out at function return.
none
in
(default) same as in
for function parameters passed into
function
for function parameters that cannot be
written to
for function parameters passed back out of
function, but not initialized when passed in
for function parameters passed both into
and out of a function
const
out
inout
Precision Qualifiers [4.7]
Qualify individual variables:
{highp, mediump, lowp} variable-declaration;
Establish a default precision qualifier:
precision {highp, mediump, lowp} {int, float};
Built-In Variables [7]
Invariant Qualifiers Examples [4.8]
These are for vertex, tessellation, geometry,
and fragment languages.
#pragma STDGL
force all output variables
invariant(all)
to be invariant
invariant gl_Position;
qualify a previously
declared variable
invariant centroid out
vec3 Color;
qualify as part of a
variable declaration
Precise Qualifier [4.9]
Ensures that operations are executed in stated
order with operator consistency. For example,
a fused multiply-add cannot be used in the
following; it requires two identical multiplies,
followed by an add.
precise out vec4 Position = a * b + c * d;
Memory Qualifiers [4.10]
Variables qualified as “image” can have one or
more memory qualifiers.
coherent reads and writes are coherent with
other shader invocations
volatile
underlying values may be changed by
other sources
restrict
won’t be accessed by other code
readonly read only
writeonly write only
Order of Qualification [4.11]
When multiple qualifiers are present in a
declaration they may appear in any order, but
must all appear before the type.
The layout qualifier is the only qualifier that can
appear more than once. Further, a declaration
can have at most one storage qualifier, at most
one auxiliary storage qualifier, and at most one
interpolation qualifier.
Multiple memory qualifiers can be used. Any
rule violation will cause a compile-time error.
Geometry Language
Tessellation Control Language
Outputs
Inputs
in gl_PerVertex {
vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
float gl_CullDistance[];
} gl_in[gl_MaxPatchVertices];
in int gl_PatchVerticesIn;
in int gl_PrimitiveID;
in int gl_InvocationID;
out gl_PerVertex {
vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
float gl_CullDistance[];
} gl_out[];
Inputs
in int gl_PrimitiveIDIn;
in int gl_InvocationID;
Outputs
out gl_PerVertex {
vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
float gl_CullDistance[];
};
out int gl_PrimitiveID;
out int gl_Layer;
out int gl_ViewportIndex;
Fragment Language
in
in
in
in
in
in
in
in
in
in
in
in
out float gl_FragDepth;
out int gl_SampleMask[];
patch out float gl_TessLevelOuter[4];
patch out float gl_TessLevelInner[2];
Tessellation Evaluation Language
Outputs
};
in int gl_PatchVerticesIn;
in int gl_PrimitiveID;
in vec3 gl_TessCoord;
patch in float gl_TessLevelOuter[4];
patch in float gl_TessLevelInner[2];
out gl_PerVertex {
vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
float gl_CullDistance[];
©2014 Khronos Group - Rev. 0814
vec4
bool
float
float
vec2
int
int
vec2
int
int
int
bool
gl_FragCoord;
gl_FrontFacing;
gl_ClipDistance[];
gl_CullDistance[];
gl_PointCoord;
gl_PrimitiveID;
gl_SampleID;
gl_SamplePosition;
gl_SampleMaskIn[];
gl_Layer;
gl_ViewportIndex;
gl_HelperInvocation;
Compute Language
More information in diagram on page 6.
Work group dimensions
in uvec3 gl_NumWorkGroups;
const uvec3 gl_WorkGroupSize;
in uvec3 gl_LocalGroupSize;
Inputs
Inputs
in gl_PerVertex {
vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
float gl_CullDistance[];
} gl_in[gl_MaxPatchVertices];
out gl_PerVertex {
vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
float gl_CullDistance[];
};
Inputs
gl_VertexID;
gl_InstanceID;
in gl_PerVertex {
vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
float gl_CullDistance[];
} gl_in[];
Outputs
Inputs
in int
in int
Outputs
Vertex Language
Work group and invocation IDs
in uvec3 gl_WorkGroupID;
in uvec3 gl_LocalInvocationID;
Derived variables
in uvec3 gl_GlobalInvocationID;
in uint gl_LocalInvocationIndex;
Operations and Constructors
Vector & Matrix [5.4.2]
.length() for matrices returns number of columns
.length() for vectors returns number of components
mat2(vec2, vec2);
// 1 col./arg.
mat2x3(vec2, float, vec2, float); // col. 2
dmat2(dvec2, dvec2);
// 1 col./arg.
// 1 col./arg.
dmat3(dvec3, dvec3, dvec3);
Structure Example [5.4.3]
.length() for structures returns number of members
struct light {members; };
light lightVar = light(3.0, vec3(1.0, 2.0, 3.0));
Matrix Examples [5.6]
Examples of access components of a matrix with
array subscripting syntax:
mat4 m;
m[1] = vec4(2.0);
m[0][0] = 1.0;
m[2][3] = 2.0;
// m is a matrix
// sets 2nd col. to all 2.0
// sets upper left element to 1.0
// sets 4th element of 3rd col. to 2.0
Statements and Structure
Subroutines [6.1.2]
Subroutine type variables are assigned to functions
through the UniformSubroutinesuiv command in the
OpenGL API.
Declare types with the subroutine keyword:
Examples of operations on matrices and vectors:
m = f * m;
v = f * v;
v = v * v;
m = m +/- m;
m = m * m;
f = dot(v, v);
v = cross(v, v);
Array Example [5.4.4]
const float c[3];
c.length()
// will return the integer 3
Structure & Array Operations [5.7]
Select structure fields or length() method of an
array using the period (.) operator. Other operators:
.
field or method selector
== != equality
=
assignment
[]
indexing (arrays only)
Array elements are accessed using the array
subscript operator ( [ ] ), e.g.:
diffuseColor += lightIntensity[3]*NdotL;
Declare subroutine type variables with a specific
subroutine type in a subroutine uniform variable
declaration:
subroutine uniform subroutineTypeName
subroutineVarName;
Iteration and Jumps [6.3-4]
subroutine returnType subroutineTypeName(type0
arg0,
type1 arg1, ..., typen argn);
Function
Iteration
Associate functions with subroutine types of
matching declarations by defining the functions
with the subroutine keyword and a list of
subroutine types the function matches:
Selection
subroutine(subroutineTypeName0, ...,
subroutineTypeNameN)
returnType functionName(type0 arg0,
type1 arg1, ..., typen argn){ ... }
// function body
Built-In Constants [7.3]
The following are provided to all shaders. The
actual values are implementation-dependent, but
must be at least the value shown.
const ivec3 gl_MaxComputeWorkGroupCount =
{65535, 65535, 65535} ;
const ivec3 gl_MaxComputeWorkGroupSize[] =
{1024, 1024, 64};
const int gl_MaxComputeUniformComponents = 1024;
const int gl_MaxComputeTextureImageUnits = 16;
const int gl_MaxComputeImageUniforms = 8;
const int gl_MaxComputeAtomicCounters = 8;
const int gl_MaxComputeAtomicCounterBuffers = 1;
const int gl_MaxVertexAttribs = 16;
const int gl_MaxVertexUniformComponents = 1024;
const int gl_MaxVaryingComponents= 60;
const int gl_MaxVertexOutputComponents = 64;
const int gl_MaxGeometryInputComponents = 64;
const int gl_MaxGeometryOutputComponents = 128;
const int gl_MaxFragmentInputComponents = 128;
const int gl_MaxVertexTextureImageUnits = 16;
const int gl_MaxCombinedTextureImageUnits = 80;
const int gl_MaxTextureImageUnits = 16;
const int gl_MaxImageUnits = 8;
gl_MaxCombinedImageUnitsAndFragmentOutputs = 8;
const int gl_MaxImageSamples = 0;
const int gl_MaxVertexImageUniforms= 0;
const int gl_MaxTessControlImageUniforms = 0;
const int gl_MaxTessEvaluationImageUniforms = 0;
const int gl_MaxGeometryImageUniforms = 0;
const int gl_MaxFragmentImageUniforms = 8;
const int gl_MaxCombinedImageUniforms = 8;
const int gl_MaxFragmentUniformComponents = 1024;
const int gl_MaxDrawBuffers = 8;
const int gl_MaxClipDistances = 8;
const int gl_MaxGeometryTextureImageUnits = 16;
const int gl_MaxGeometryOutputVertices = 256;
const int gl_MaxGeometryTotalOutputComponents = 1024;
const int gl_MaxGeometryUniformComponents = 1024;
const int gl_MaxGeometryVaryingComponents = 64;
const int gl_MaxTessControlInputComponents = 128;
// scalar * matrix component-wise
// scalar * vector component-wise
// vector * vector component-wise
// matrix +/- matrix comp.-wise
// linear algebraic multiply
// vector dot product
// vector cross product
Entry
Jump
Exit
call by value-return
for (;;) { break, continue }
while ( ) { break, continue }
do { break, continue } while ( );
if ( ) { }
if ( ) { } else { }
switch ( ) { case integer: … break; …
default: … }
void main()
break, continue, return
(There is no ‘goto’)
return in main()
discard // Fragment shader only
const int gl_MaxTessControlOutputComponents = 128;
const int gl_MaxTessControlTextureImageUnits = 16;
const int gl_MaxTessControlUniformComponents = 1024;
const int gl_MaxTessControlTotalOutputComponents = 4096;
const int gl_MaxTessEvaluationInputComponents = 128;
const int gl_MaxTessEvaluationOutputComponents = 128;
const int gl_MaxTessEvaluationTextureImageUnits = 16;
const int gl_MaxTessEvaluationUniformComponents = 1024;
const int gl_MaxTessPatchComponents = 120;
const int gl_MaxPatchVertices = 32;
const int gl_MaxTessGenLevel = 64;
const int gl_MaxViewports = 16;
const int gl_MaxVertexUniformVectors = 256;
const int gl_MaxFragmentUniformVectors = 256;
const int gl_MaxVaryingVectors = 15;
const int gl_MaxVertexAtomicCounters = 0;
const int gl_MaxTessControlAtomicCounters = 0;
const int gl_MaxTessEvaluationAtomicCounters = 0;
const int gl_MaxGeometryAtomicCounters = 0;
const int gl_MaxFragmentAtomicCounters = 8;
const int gl_MaxCombinedAtomicCounters = 8;
const int gl_MaxAtomicCounterBindings = 1;
const int gl_MaxVertexAtomicCounterBuffers = 0;
const int gl_MaxTessControlAtomicCounterBuffers = 0;
const int gl_MaxTessEvaluationAtomicCounterBuffers = 0;
const int gl_MaxGeometryAtomicCounterBuffers = 0;
const int gl_MaxFragmentAtomicCounterBuffers = 1;
const int gl_MaxCombinedAtomicCounterBuffers = 1;
const int gl_MaxAtomicCounterBufferSize = 32;
const int gl_MinProgramTexelOffset = -8;
const int gl_MaxProgramTexelOffset = 7;
const int gl_MaxTransformFeedbackBuffers = 4;
gl_MaxTransformFeedbackInterleavedComponents = 64;
const int gl_MaxCullDistances = 8;
const int gl_MaxCombinedClipAndCullDistances = 8;
const int gl_MaxSamples = 4;
const int gl_MaxVertexImageUniforms = 0;
const int gl_MaxFragmentImageUniforms = 8;
const int gl_MaxComputeImageUniforms = 8;
const int gl_MaxCombinedImageUniforms = 48;
const int gl_MaxCombinedShaderOutputResources = 16;
www.opengl.org/registry
OpenGL Shading Language 4.50 Reference Card
Built-In Functions
Common Functions (cont.)
Angle & Trig. Functions [8.1]
Functions will not result in a divide-by-zero
error. If the divisor of a ratio is 0, then results
will be undefined. Component-wise operation.
Parameters specified as angle are in units of
radians. Tf=float, vecn.
Tf radians(Tf degrees)
degrees to radians
Tf degrees(Tf radians)
radians to degrees
Tf sin(Tf angle)
sine
Tf cos(Tf angle)
cosine
Tf tan(Tf angle)
tangent
Tf asin(Tf x)
arc sine
Tf acos(Tf x)
arc cosine
Tf atan(Tf y, Tf x)
Tf atan(Tf y_over_x)
arc tangent
Tf sinh(Tf x)
hyperbolic sine
Tf cosh(Tf x)
hyperbolic cosine
Tf tanh(Tf x)
hyperbolic tangent
Tf asinh(Tf x)
hyperbolic sine
Tf acosh(Tf x)
hyperbolic cosine
Tf atanh(Tf x)
hyperbolic tangent
Tf exp(Tf x)
ex
Tf log(Tf x)
ln
Tf exp2(Tf x)
2x
log2
Tfd sqrt(Tfd x)
square root
Tfd inversesqrt(Tfd x)
inverse square root
Common Functions [8.3]
Component-wise operation. Tf=float, vecn. Tb=bool,
bvecn. Ti=int, ivecn. Tu=uint, uvecn.
Td= double, dvecn. Tfd= Tf, Td. Tiu= Ti, Tu.
Returns -1.0, 0.0, or 1.0:
Tfd sign(Tfd x)
Ti mix(Ti x, Ti y, Ti a)
Tu mix(Tu x, Tu y, Tu a)
Components returned come from x when a components
are true, from y when a components are false:
Tfd mix(Tfd x, Tfd y, Tb a) Tb mix(Tb x, Tb y, Tb a)
Tiu mix(Tiu x, Tiu y, Tb a)
Returns 0.0 if x < edge, else 1.0:
Tfd step(Tfd edge, Tfd x)
Tf step(float edge, Tf x)
Td step(double edge, Td x)
Ti abs(Ti x)
Ti sign(Ti x)
Returns nearest integer <= x:
Tfd floor(Tfd x)
Returns nearest integer with absolute value <= absolute
value of x:
Tfd trunc(Tfd x)
Returns nearest integer, implementation-dependent
rounding mode:
Tfd round(Tfd x)
Returns nearest integer, 0.5 rounds to nearest even integer:
Tfd roundEven(Tfd x)
Type Abbreviations for Built-in Functions:
In vector types, n is 2, 3, or 4.
Tf=float, vecn. Td =double, dvecn. Tfd= float, vecn, double, dvecn. Tb= bool, bvecn.
Tu=uint, uvecn. Ti=int, ivecn. Tiu=int, ivecn, uint, uvecn. Tvec=vecn, uvecn, ivecn.
Within any one function, type sizes and dimensionality must correspond after implicit type
conversions. For example, float round(float) is supported, but float round(vec4) is not.
Geometric Functions [8.5]
These functions operate on vectors as vectors, not
component-wise. Tf=float, vecn. Td =double, dvecn.
Tfd= float, vecn, double, dvecn.
float length(Tf x)
double length(Td x)
length of vector
Integer Functions (cont.)
Multiplies 32-bit integers x and y, producing a 64-bit result:
void umulExtended(Tu x, Tu y, out Tu msb, out Tu lsb)
void imulExtended(Ti x, Ti y, out Ti msb, out Ti lsb)
float distance(Tf p0, Tf p1)
distance between points
double distance(Td p0, Td p1)
Extracts bits [offset, offset + bits - 1] from value, returns
them in the least significant bits of the result:
Tiu bitfieldExtract(Tiu value, int offset, int bits)
float dot(Tf x, Tf y)
double dot(Td x, Td y)
Returns the reversal of the bits of value:
Tiu bitfieldReverse(Tiu value)
dot product
vec3 cross(vec3 x, vec3 y)
cross product
dvec3 cross(dvec3 x, dvec3 y)
Inserts the bits least-significant bits of insert into base:
Tiu bitfieldInsert(Tiu base, Tiu insert, int offset, int bits)
Tfd normalize(Tfd x)
normalize vector to length 1
Tfd faceforward(Tfd N,
Tfd I, Tfd Nref)
returns N if dot(Nref, I) <
0, else -N
Returns the number of bits set to 1:
Ti bitCount(Tiu value)
Tfd reflect(Tfd I, Tfd N)
reflection direction
I - 2 * dot(N,I) * N
Tfd refract(Tfd I, Tfd N,
float eta)
refraction vector
Returns the bit number of the least significant bit:
Ti findLSB(Tiu value)
Returns the bit number of the most significant bit:
Ti findMSB(Tiu value)
Clamps and smoothes:
Tfd smoothstep(Tfd edge0, Tfd edge1, Tfd x)
Tf smoothstep(float edge0, float edge1, Tf x)
Td smoothstep(double edge0, double edge1, Td x)
Matrix Functions [8.6]
Returns true if x is NaN:
Tb isnan(Tfd x)
mat matrixCompMult(mat x, mat y)
component-wise
dmat matrixCompMult(dmat x, dmat y) multiply
Atomic-Counter Functions [8.10]
Returns true if x is positive or negative infinity:
Tb isinf(Tfd x)
matN outerProduct(vecN c, vecN r)
outer product
dmatN outerProduct(dvecN c, dvecN r) (where N != M)
Atomically increments c then returns its prior value:
uint atomicCounterIncrement(atomic_uint c)
matNxM outerProduct(vecM c, vecN r)
outer product
dmatNxM outerProduct(dvecM c, dvecN r)
Atomically decrements c then returns its prior value:
uint atomicCounterDecrement(atomic_uint c)
matN transpose(matN m)
dmatN transpose(dmatN m)
transpose
Atomically returns the counter for c:
uint atomicCounter(atomic_uint c)
matNxM transpose(matMxN m)
dmatNxM transpose(dmatMxN m)
transpose
(where N != M)
Atomic Memory Functions [8.11]
float determinant(matN m)
double determinant(dmatN m)
determinant
Operates on individual integers in buffer-object
or shared-variable storage. OP is Add, Min, Max,
And, Or, Xor, Exchange, or CompSwap.
matN inverse(matN m)
dmatN inverse(dmatN m)
inverse
uint atomicOP(coherent inout uint mem, uint data)
Returns signed int or uint value of the encoding of a float:
Ti floatBitsToInt(Tf value)
Tu floatBitsToUint(Tf value)
Tf log2(Tf x)
Returns absolute value:
Tfd abs(Tfd x)
Tiu max(Tiu x, Tiu y)
Ti max(Ti x, int y)
Tu max(Tu x, uint y)
Returns min(max(x, minVal), maxVal):
Tfd clamp(Tfd x, Tfd minVal, Tfd maxVal)
Tf clamp(Tf x, float minVal, float maxVal)
Td clamp(Td x, double minVal, double maxVal)
Tiu clamp(Tiu x, Tiu minVal, Tiu maxVal)
Ti clamp(Ti x, int minVal, int maxVal)
Tu clamp(Tu x, uint minVal, uint maxVal)
Tfd mix(Tfd x, Tfd y, Tfd a)
Tf mix(Tf x, Tf y, float a)
Td mix(Td x, Td y, double a)
Component-wise operation. Tf=float, vecn.
Td= double, dvecn. Tfd= Tf, Td
xy
Tfd max(Tfd x, Tfd y)
Tf max(Tf x, float y)
Td max(Td x, double y)
Returns linear blend of x and y:
Exponential Functions [8.2]
Tf pow(Tf x, Tf y)
Returns maximum value:
Page 11
Returns float value of a signed int or uint encoding of a float:
Tf intBitsToFloat(Ti value) Tf uintBitsToFloat(Tu value)
Computes and returns a*b + c. Treated as a single operation
when using precise:
Tfd fma(Tfd a, Tfd b, Tfd c)
Splits x into a floating-point significand in the range [0.5, 1.0)
and an integer exponent of 2:
Tfd frexp(Tfd x, out Ti exp)
Builds a floating-point number from x and the corresponding
integral exponent of 2 in exp:
Tfd ldexp(Tfd x, in Ti exp)
Texture Lookup Functions [8.9]
Available to vertex, geometry, and fragment
shaders. See tables on next page.
N and M are 1, 2, 3, 4.
int atomicOP(coherent inout int mem, int data)
Vector Relational Functions [8.7]
Compare x and y component-wise. Sizes of the
input and return vectors for any particular call
must match. Tvec=vecn, uvecn, ivecn.
bvecn lessThan(Tvec x, Tvec y)
<
bvecn lessThanEqual(Tvec x, Tvec y)
<=
These do not operate component-wise.
bvecn greaterThan(Tvec x, Tvec y)
>
Converts each component of v into 8- or 16-bit ints, packs
results into the returned 32-bit unsigned integer:
bvecn greaterThanEqual(Tvec x, Tvec y)
>=
bvecn equal(Tvec x, Tvec y)
bvecn equal(bvecn x, bvecn y)
==
bvecn notEqual(Tvec x, Tvec y)
bvecn notEqual(bvecn x, bvecn y)
!=
Floating-Point Pack/Unpack [8.4]
uint packUnorm2x16(vec2 v)
uint packSnorm2x16(vec2 v)
uint packUnorm4x8(vec4 v)
uint packSnorm4x8(vec4 v)
Returns the value of an atomic counter.
Image Functions [8.12]
In the image functions below, IMAGE_PARAMS
may be one of the following:
gimage1D image, int P
gimage2D image, ivec2 P
gimage3D image, ivec3 P
gimage2DRect image, ivec2 P
gimageCube image, ivec3 P
gimageBuffer image, int P
gimage1DArray image, ivec2 P
gimage2DArray image, ivec3 P
gimageCubeArray image, ivec3 P
gimage2DMS image, ivec2 P, int sample
gimage2DMSArray image, ivec3 P, int sample
bool any(bvecn x)
true if any component of x is true
Returns x - floor(x):
Tfd fract(Tfd x)
Unpacks 32-bit p into two 16-bit uints, four 8-bit uints, or
signed ints. Then converts each component to a normalized
float to generate a 2- or 4-component vector:
vec2 unpackUnorm2x16(uint p)
vec2 unpackSnorm2x16(uint p)
vec4 unpackUnorm4x8(uint p)
vec4 unpackSnorm4x8(uint p)
bool all(bvecn x)
true if all comps. of x are true
Returns modulus:
Tfd mod(Tfd x, Tfd y)
Tf mod(Tf x, float y)
bvecn not(bvecn x)
logical complement of x
Packs components of v into a 64-bit value and returns a
double-precision value:
double packDouble2x32(uvec2 v)
Integer Functions [8.8]
Returns the number of samples of the image or images
bound to image:
int imageSamples(gimage2DMS image)
int imageSamples(gimage2DMSArray image)
Adds 32-bit uint x and y, returning the sum modulo 232:
Tu uaddCarry(Tu x, Tu y, out Tu carry)
Loads texel at the coordinate P from the image unit image:
gvec4 imageLoad(readonly IMAGE_PARAMS)
Subtracts y from x, returning the difference if non-negative,
otherwise 232 plus the difference:
Tu usubBorrow(Tu x, Tu y, out Tu borrow)
Stores data into the texel at the coordinate P from
the image specified by image:
void imageStore(writeonly IMAGE_PARAMS, gvec4 data)
Returns nearest integer >= x:
Tfd ceil(Tfd x)
Td mod(Td x, double y)
Returns separate integer and fractional parts:
Tfd modf(Tfd x, out Tfd i)
Returns a 2-component vector representation of v:
uvec2 unpackDouble2x32(double v)
Returns minimum value:
Returns a uint by converting the components of a twocomponent floating-point vector:
uint packHalf2x16(vec2 v)
Tfd min(Tfd x, Tfd y)
Tf min(Tf x, float y)
Td min(Td x, double y)
Tiu min(Tiu x, Tiu y)
Ti min(Ti x, int y)
Tu min(Tu x, uint y)
(Continue )
©2014 Khronos Group - Rev. 0814
Returns a two-component floating-point vector:
vec2 unpackHalf2x16(uint v)
Component-wise operation. Tu=uint, uvecn.
Ti=int, ivecn. Tiu=int, ivecn, uint, uvecn.
(Continue )
Returns the dimensions of the images or images:
int imageSize(gimage{1D,Buffer} image)
ivec2 imageSize(gimage{2D,Cube,Rect,1DArray,
2DMS} image)
ivec3 imageSize(gimage{Cube,2D,2DMS}Array image)
vec3 imageSize(gimage3D image)
(Continued on next page)
www.opengl.org/registry
Page 12
OpenGL Shading Language 4.50 Reference Card
Built-In Functions (cont.)
Image Functions (cont.)
Adds the value of data to the contents of the selected texel:
uint imageAtomicAdd(coherent IMAGE_PARAMS, uint data)
int imageAtomicAdd(coherent IMAGE_PARAMS, int data)
Takes the minimum of the value of data and the contents
of the selected texel:
uint imageAtomicMin(coherent IMAGE_PARAMS, uint data)
int imageAtomicMin(coherent IMAGE_PARAMS, int data)
Takes the maximum of the value data and the contents
of the selected texel:
uint imageAtomicMax(coherent IMAGE_PARAMS, uint data)
int imageAtomicMax(coherent IMAGE_PARAMS, int data)
Performs a bit-wise AND of the value of data and the
contents of the selected texel:
uint imageAtomicAnd(coherent IMAGE_PARAMS, uint data)
int imageAtomicAnd(coherent IMAGE_PARAMS, int data)
Image Functions (cont.)
Interpolation fragment-processing functions
Geometry Shader Functions (cont’d)
Copies the value of data:
uint imageAtomicExchange(coherent IMAGE_PARAMS,
uint data)
int imageAtomicExchange(coherent IMAGE_PARAMS,
int data)
int imageAtomicExchange(coherent IMAGE_PARAMS,
float data)
Compares the value of compare and contents of selected
texel. If equal, the new value is given by data; otherwise,
it is taken from the original value loaded from texel:
uint imageAtomicCompSwap(coherent IMAGE_PARAMS,
uint compare, uint data)
int imageAtomicCompSwap(coherent IMAGE_PARAMS,
int compare, int data)
Return value of interpolant sampled inside pixel and the
primitive:
Tf interpolateAtCentroid(Tf interpolant)
Emits values of output variables to the current output
primitive:
void EmitVertex()
Fragment Processing Functions [8.13]
Available only in fragment shaders.
Tf=float, vecn.
Derivative fragment-processing functions
Tf dFdx(Tf p)
derivative in x and y, either
fine or coarse derivatives
Tf dFdy(Tf p)
Tf dFdxFine(Tf p)
fine derivative in x and y per
pixel-row/column derivative
Tf dFdyFine(Tf p)
Tf dFdxCoarse(Tf p) coarse derivative in x and y per
Performs a bit-wise exclusive OR of the value of data and Tf dFdyCoarse(Tf p) 2x2-pixel derivative
the contents of the selected texel:
Tf fwidth(Tf p)
uint imageAtomicXor(coherent IMAGE_PARAMS, uint data) Tf fwidthFine(Tf p) sum of absolute values of x and y
derivatives
Tf fwidthCoarse(Tf p)
int imageAtomicXor(coherent IMAGE_PARAMS, int data)
Performs a bit-wise OR of the value of data and the
contents of the selected texel:
uint imageAtomicOr(coherent IMAGE_PARAMS, uint data)
int imageAtomicOr(coherent IMAGE_PARAMS, int data)
Return value of interpolant at location of sample # sample:
Tf interpolateAtSample(Tf interpolant, int sample)
Return value of interpolant sampled at fixed offset offset
from pixel center:
Tf interpolateAtOffset(Tf interpolant, vec2 offset)
Returns noise value. Available to fragment, geometry,
and vertex shaders. n is 2, 3, or 4:
vecn noisen(Tf x)
Texture Functions [8.9]
The P argument needs to have enough
components to specify each dimension, array
layer, or comparison for the selected sampler.
The dPdx and dPdy arguments need enough
components to specify the derivative for each
dimension of the sampler.
Texture Query Functions [8.9.1]
textureSize functions return dimensions of lod
(if present) for the texture bound to sampler.
Components in return value are filled in with the
Texture lookup with projection.
width, height, depth of the texture. For array
forms, the last component of the return value is gvec4 textureProj(gsampler{1D,2D[Rect],3D} sampler,
the number of layers in the texture array.
vec{2,3,4} P [, float bias])
float textureProj(sampler{1D,2D[Rect]}Shadow sampler,
{int,ivec2,ivec3} textureSize(
vec4 P [, float bias])
gsampler{1D[Array],2D[Rect,Array],Cube} sampler[,
int lod])
{int,ivec2,ivec3} textureSize(
Texture lookup as in texture but with explicit LOD.
gsampler{Buffer,2DMS[Array]}sampler)
gvec4 textureLod(
{int,ivec2,ivec3} textureSize(
gsampler{1D[Array],2D[Array],3D,Cube[Array]} sampler,
sampler{1D, 2D, 2DRect,Cube[Array]}Shadow sampler[,
{float,vec2,vec3} P, float lod)
int lod])
float
textureLod(sampler{1D[Array],2D}Shadow sampler,
ivec3 textureSize(samplerCubeArray sampler, int lod)
vec3 P, float lod)
textureQueryLod functions return the mipmap
Offset added before texture lookup.
array(s) that would be accessed in the x
component of the return value. Returns the
gvec4 textureOffset(
computed level of detail relative to the base level
gsampler{1D[Array],2D[Array,Rect],3D} sampler,
in the y component of the return value.
{float,vec2,vec3} P, {int,ivec2,ivec3} offset [, float bias])
float
textureOffset(
vec2 textureQueryLod(
sampler{1D[Array],2D[Rect,Array]}Shadow sampler,
gsampler{1D[Array],2D[Array],3D,Cube[Array]} sampler,
{vec3, vec4} P, {int,ivec2} offset [, float bias])
{float,vec2,vec3} P)
vec2 textureQueryLod(
sampler{1D[Array],2D[Array],Cube[Array]}Shadow sampler, Use integer texture coordinate P to lookup a single
{float,vec2,vec3} P)
texel from sampler.
Order reads and writes accessible to other invocations:
Completes current output primitive stream stream and
starts a new one:
void EndStreamPrimitive(int stream)
void groupMemoryBarrier()
void
void
void
void
memoryBarrierAtomicCounter()
memoryBarrierShared()
memoryBarrierBuffer()
memoryBarrierImage()
(Continue )
float textureProjOffset(
sampler{1D,2D[Rect]}Shadow sampler, vec4 P,
{int,ivec2} offset [, float bias])
Offset texture lookup with explicit LOD.
gvec4 textureLodOffset(
gsampler{1D[Array],2D[Array],3D} sampler,
{float,vec2,vec3} P, float lod, {int,ivec2,ivec3} offset)
float textureLodOffset(
sampler{1D[Array],2D}Shadow sampler, vec3 P, float lod,
{int,ivec2} offset)
Projective texture lookup with explicit LOD.
gvec4 textureProjLod(gsampler{1D,2D,3D} sampler,
vec{2,3,4} P, float lod)
float textureProjLod(sampler{1D,2D}Shadow sampler,
vec4 P, float lod)
Offset projective texture lookup with explicit LOD.
gvec4 textureProjLodOffset(gsampler{1D,2D,3D} sampler,
vec{2,3,4} P, float lod, {int, ivec2, ivec3} offset)
float textureProjLodOffset(sampler{1D,2D}Shadow sampler,
vec4 P, float lod, {int, ivec2} offset)
Texture lookup both projectively as in
textureProj, and with explicit gradient as in
textureGrad.
gvec4 textureProjGrad(gsampler{1D,2D[Rect],3D} sampler,
{vec2,vec3,vec4} P, {float,vec2,vec3} dPdx,
{float,vec2,vec3} dPdy)
float textureProjGrad(sampler{1D,2D[Rect]}Shadow sampler,
vec4 P, {float,vec2} dPdx, {float,vec2} dPdy)
Texture lookup projectively and with explicit gradient
as in textureProjGrad, as well as with offset as in
textureOffset.
gvec4 textureProjGradOffset(
gsampler{1D,2D[Rect],3D} sampler, vec{2,3,4} P,
{float,vec2,vec3} dPdx, {float,vec2,vec3} dPdy,
{int,ivec2,ivec3} offset)
float textureProjGradOffset(
sampler{1D,2D[Rect]Shadow} sampler, vec4 P,
{float,vec2} dPdx, {float,vec2} dPdy, {ivec2,int,vec2} offset)
Texture Gather Instructions [8.9.3]
These functions take components of a floating-point
vector operand as a texture coordinate, determine
a set of four texels to sample from the base level of
detail of the specified texture image, and return one
component from each texel in a four-component
result vector.
gvec4 textureGather(
gsampler{2D[Array,Rect],Cube[Array]} sampler,
{vec2,vec3,vec4} P [, int comp])
vec4 textureGather(
sampler{2D[Array,Rect],Cube[Array]}Shadow sampler,
{vec2,vec3,vec4} P, float refZ)
Texture lookup as in texture but with explicit gradients.
Texture gather as in textureGather by offset as
gvec4 textureGrad(
described in textureOffset except minimum and
gsampler{1D[Array],2D[Rect,Array],3D,Cube[Array]} sampler, maximum offset values are given by
{float, vec2, vec3,vec4} P, {float, vec2, vec3} dPdx,
{MIN, MAX}_PROGRAM_TEXTURE_GATHER_OFFSET.
{float, vec2, vec3} dPdy)
gvec4 textureGatherOffset(gsampler2D[Array,Rect] sampler,
float textureGrad(
{vec2,vec3} P, ivec2 offset [, int comp])
sampler{1D[Array],2D[Rect,Array], Cube}Shadow sampler,
vec4 textureGatherOffset(
{vec3,vec4} P, {float,vec2} dPdx, {float,vec2, vec3} dPdy)
sampler2D[Array,Rect]Shadow sampler,
{vec2,vec3} P, float refZ, ivec2 offset)
Texture lookup with both explicit gradient and offset.
textureQueryLevels functions return the number gvec4 texelFetch(
gsampler{1D[Array],2D[Array,Rect],3D} sampler,
of mipmap levels accessible in the texture
{int,ivec2,ivec3} P[, {int,ivec2} lod])
associated with sampler.
gvec4 texelFetch(gsampler{Buffer, 2DMS[Array]} sampler,
int textureQueryLevels(
{int,ivec2,ivec3} P[, int sample])
gsampler{1D[Array],2D[Array],3D,Cube[Array]} sampler)
gvec4 textureGradOffset(
int textureQueryLevels(
gsampler{1D[Array],2D[Rect,Array],3D} sampler,
sampler{1D[Array],2D[Array],Cube[Array]}Shadow sampler) Fetch single texel with offset added before texture lookup.
{float,vec2,vec3} P, {float,vec2,vec3} dPdx,
{float,vec2,vec3} dPdy, {int,ivec2,ivec3} offset)
gvec4 texelFetchOffset(
textureSamples returns the number of samples
gsampler{1D[Array],2D[Array],3D} sampler,
float textureGradOffset(
of the texture.
{int,ivec2,ivec3} P, int lod, {int,ivec2,ivec3} offset)
sampler{1D[Array],2D[Rect,Array]}Shadow sampler,
gvec4 texelFetchOffset(
int textureSamples(gsampler2DMS sampler)
{vec3,vec4} P, {float,vec2} dPdx, {float,vec2}dPdy,
gsampler2DRect sampler, ivec2 P, ivec2 offset)
{int,ivec2} offset)
int textureSamples(gsampler2DMSArray sampler)
©2014 Khronos Group - Rev. 0814
void memoryBarrier()
Emits values of output variables to current output
primitive stream stream:
void EmitStreamVertex(int stream)
Projective texture lookup with offset added before
Use texture coordinate P to do a lookup in the texture texture lookup.
bound to sampler. For shadow forms, compare is
gvec4 textureProjOffset(gsampler{1D,2D[Rect],3D} sampler,
used as Dref and the array layer comes from P.w.
vec{2,3,4} P, {int,ivec2,ivec3} offset [, float bias])
For non-shadow forms, the array layer comes from
the last component of P.
float texture(
sampler{1D[Array],2D[Array,Rect],Cube}Shadow sampler,
{vec3,vec4} P [, float bias])
float texture(gsamplerCubeArrayShadow sampler, vec4 P,
float compare)
Controls ordering of memory transactions issued by a
single shader invocation:
Controls ordering of memory transactions as viewed by
other invocations in a compute work group:
Only available in geometry shaders.
Texel Lookup Functions [8.9.2]
gvec4 texture(
gsampler{1D[Array],2D[Array,Rect],3D,Cube[Array]} sampler,
{float,vec2,vec3,vec4} P [, float bias])
void barrier()
Geometry Shader Functions [8.15]
(Continue )
Available to vertex, geometry, and fragment
shaders. gvec4=vec4, ivec4, uvec4.
gsampler* =sampler*, isampler*, usampler*.
Other Shader Functions [8.16-17]
See diagram on page 11 for more information.
Synchronizes across shader invocations:
Noise Functions [8.14]
float noise1(Tf x)
Completes output primitive and starts a new one:
void EndPrimitive()
Texture gather as in textureGatherOffset except offsets
determines location of the four texels to sample.
gvec4 textureGatherOffsets(gsampler2D[Array,Rect] sampler,
{vec2,vec3} P, ivec2 offsets[4] [, int comp])
vec4 textureGatherOffsets(
sampler2D[Array,Rect]Shadow sampler,
{vec2,vec3} P, float refZ, ivec2 offsets[4])
www.opengl.org/registry
Page 13
OpenGL 4.5 API Reference Card
OpenGL API and OpenGL Shading Language Reference Card Index
The following index shows each item included on this card along with the page on which it is described. The color of the row in the table below is the color of the pane to which you should refer.
A
ActiveShaderProgram
ActiveTexture
Angle Functions
Asynchronous Queries
Atomic Functions
AttachShader
2
2
11
1
11
2
B
BeginConditionalRender
BeginQuery[Indexed]
BeginTransformFeedback
BindAttribLocation
BindBuffer*
BindBuffer[s]{Base, Range}
BindFragDataLocation[Indexed]
BindFramebuffer
BindImageTexture[s]
BindProgramPipeline
BindRenderbuffer
Bind{Sampler, Texture}[s]
BindTexture[s]
BindTextureUnit
BindTransformFeedback
BindVertexArray
BindVertexBuffer[s]
BlendColor
BlendEquation[Separate]*
BlendFunc[Separate]*
Blit[Named]Framebuffer
Buffer[Sub]Data
BufferStorage
BufferTextures
C
CreateTransformFeedbacks
CreateVertexArrays
CullFace
5
4
5
D
DebugMessage*
DeleteBuffers
DeleteFramebuffers
DeleteProgram[Pipelines]
DeleteQueries
DeleteRenderbuffers
DeleteSamplers
DeleteShader
DeleteSync
DeleteTextures
DeleteTransformFeedbacks
DeleteVertexArrays
DepthFunc
DepthMask
DepthRange*
Derivative Functions
DetachShader
DisableVertexArrayAttrib
DisableVertexAttribArray
DispatchCompute*
Dithering
DrawArrays*
DrawBuffer[s]
Draw[Range]Elements*
DrawTransformFeedback*
5
1
5
5
1
1
5
4
4
2
4
2
2
2
5
4
4
6
6
6
6
1
1 E
3 EnableVertexArrayAttrib
EnableVertexAttribArray
EndConditionalRender
6 EndQuery[Indexed]
4 EndQuery
6 EndTransformFeedback
6 Errors
1 Exponential Functions
Callback
Check[Named]FramebufferStatus
ClampColor
Clear
Clear[Named]Buffer[Sub]Data
ClearBuffer*
6
F
ClearColor
6
Feedback Loops
ClearDepth*
6
FenceSync
ClearStencil
6
Finish
ClearTex[Sub]Image
4
Flatshading
ClientWaitSync
1
Floating-Point Pack/Unpack Func.
Clip Control
5
Flush
ColorMask*
6
FlushMapped*
Command Letters
1
Fragment Language Variables
Common Functions
11
Fragment Processing Functions
CompileShader
1
Fragment Shaders
CompressedTex[Sub]Image*
3
Framebuffer Objects
CompressedTextureSubImage*
3
FramebufferParameteri
Compute Language Variables
10
FramebufferRenderbuffer
Compute Programming Diagram
7
FramebufferTexture*
Compute Shaders
5
FrontFace
Constants
10
Conversions
6 G
Copy[Named]BufferSubData
1
GenBuffers
CopyImageSubData
6
Generate[Texture]Mipmap
CopyTex[Sub]Image*
3 GenFramebuffers
CopyTextureSubImage*
3 GenProgramPipelines
CreateBuffers
1 GenQueries
CreateFrameBuffers
4 GenRenderbuffers
CreateProgram[Pipelines]
2 GenSamplers
CreateQueries*
1 GenTextures
CreateRenderBuffers
4 GenTransformFeedbacks
CreateSamplers*
2 GenVertexArrays
CreateShader
1 Geometric Functions
CreateShaderProgramv
2 Geometry & Follow-on Diagram
Createtextures*
2 Geometry Shader Functions
6
1
4
2
1
4
2
1
1
2
5
4
6
6
5
12
2
5
5
5
6
5
6
5
5
5
5
5
1
6
5
1
11
4
1
1
5
11
1
1
10
12
5
4
4
4
4
5
1
3
4
2
1
4
2
2
4
4
11
8
12
GetActiveAtomicCounterBuffer*
GetActiveAttrib
GetActiveSubroutine*
GetActiveUniform*
GetAttachedShaders
GetAttribLocation
GetBoolean*
GetBufferParameter*
GetBuffer{Pointerv, SubData}
Get[n]CompressedTexImage
GetCompressedTexSubImage
GetCompressedTextureImage
GetDebugMessageLog
GetDouble*
GetError
GetFloat*
GetFragData*
GetFramebuffer*
GetGraphicsResetStatus
GetInteger*
GetInteger64*
GetInternalformat*
GetMultisamplefv
GetNamedBuffer[Indexed]
GetNamedFramebuffer
GetNamedRenderbuffer
GetObject[Ptr]Label
GetPointerv
GetProgram*
GetQuery*
GetRenderbufferParameteriv
GetSamplerParameter*
GetShader*
GetString*
GetSubroutine*
GetSynciv
Get[n]TexImage
GetTex[Level]Parameter*
GetTexture*
GetTransformFeedback
GetTransformFeedbackVarying
Get[n]Uniform
GetUniform*
GetVertex{Array, Attrib}*
GL Command Syntax
2
5
2
2
2
5
6
1
1
3
3
3
6
6
1
6
5
4
1
7
7
7
5
1
4
4
6
6-7
2
1
4
2
2
6
2
1
3
3
3
7
5
2
2
5
1
H
Hint
6
I
Image Functions
Integer Functions
Interpolation Functions
Interpolation Qualifiers
InvalidateBuffer*
Invalidate[Sub]Framebuffer
InvalidateNamedFramebuffer
InvalidateTex[Sub]Image
Invariant Qualifiers
IsBuffer
IsFramebuffer
IsProgram[Pipeline]
IsQuery
IsRenderbuffer
IsSampler
IsShader
IsSync
IsTexture
IsTransformFeedback
IsVertexArray
Iteration and Jumps
11
11
12
10
1
6
6
4
10
1
4
5
1
4
2
1
1
2
5
4
10
L
Layout Qualifiers
LineWidth
LinkProgram
LogicOp
9
5
2
6
M
Macros
Map[Named]Buffer*
Matrix Operations
Matrix Functions
MemoryBarrier
MemoryBarrier
Memory Qualifiers
MinSampleShading
MultiDraw{Arrays, Elements}*
Multisample Fragment Ops
Multisample Textures
Multisampling
9
1
10
11
2
12
10
5
5
6
3
5
N
NamedBuffer
NamedFramebufferDraw
NamedFramebuffer
NamedFramebufferReadBuffer
NamedRenderbufferStorage
Noise Functions
1
6
4
6
4
12
O
Object[Ptr]Label
Occlusion Queries
Operators
5
6
9
P
Pack/Unpack Functions
Parameter Qualifiers
PatchParameter
PauseTransformFeedback
Per-Fragment Operations
Pipeline Diagram
PixelStore{if}
PointParameter*
PointSize
Polygon{Mode, Offset}
{Pop, Push}DebugGroup
Precise & Precision Qualifiers
Preprocessor
Primitive Clipping
PrimitiveRestartIndex
ProgramBinary
Program Objects
ProgramParameteri
ProgramUniform[Matrix]*
ProvokingVertex
11
10
5
5
6
8
2
5
5
5
6
10
9
5
5
2
2
2
2
5
Q
Qualifiers
QueryCounter
9
1
R
Rasterization
ReadBuffer
Read[n]Pixels
ReleaseShaderCompiler
Renderbuffer Object Queries
RenderbufferStorage*
ResumeTransformFeedback
5
6
6
1
4
4
5
S
SampleCoverage
SampleMaski
5
5
SamplerParameter*
Sampler Queries
Scissor*
Shaders and Programs
Shader Functions
Shader[Binary, Source]
ShadersStorageBlockBinding
Shading Language
State and State Requests
StencilFunc[Separate]
StencilMask[Separate]
StencilOp[Separate]
Storage Qualifiers
Structures
Subroutine Uniform Variables
Subroutines
Synchronization
2
2
6
1-2
12
1
2
9-12
6-7
6
6
6
9
10
2
10
1
T
Tessellation Diagram
Tessellation Variables
TexBuffer*
Texel Lookup Functions
TexImage*[Multisample]
TexParameter*
TexStorage*
TexStorage*[Multisample]
TexSubImage*
TextureBarrier
TextureBuffer[Range]
Texture Functions
Texture Queries
TextureStorage*[Multisample]
TextureSubImage
TextureView
Texture View/State Diagram
Timer Queries
Transform Feedback
TransformFeedbackVaryings
Types
7
10
3
12
3
3
3
4
3
4
3
12
3
4
3
3
7
1
5
5
9
U
Uniform Qualifiers
Uniform Variables
Uniform*
UniformBlockBinding
Uniform[Matrix]*
UniformSubroutinesuiv
Unmap[Named]Buffer
UseProgram[Stages]
9-10
2
2
2
2
2
1
2
V
ValidateProgram[Pipeline]
Vector & Matrix
Vector Relational Functions
Vertex & Tessellation Diagram
Vertex Arrays
VertexAttrib*
Vertex[Array]Attrib*
VertexArrayBindingDivisor
VertexArray*Buffer
VertexAttrib*Format
VertexAttrib*Pointer
VertexAttrib[Binding, Divisor]
VertexBindingDivisor
Vertex Language Variables
Viewport*
5
10
11
8
4-5
4
4
5
4
4
5
4-5
4
10
5
W
WaitSync
1
OpenGL is a registered trademark of Silicon Graphics International, used under license by Khronos Group.
The Khronos Group is an industry consortium creating open standards for the authoring and acceleration
of parallel computing, graphics and dynamic media on a wide variety of platforms and devices.
See www.khronos.org to learn more about the Khronos Group.
See www.opengl.org to learn more about OpenGL.
©2014 Khronos Group - Rev. 0814
Reference card production by Miller & Mattson www.millermattson.com
www.opengl.org/registry
Source Exif Data:
File Type : PDF File Type Extension : pdf MIME Type : application/pdf PDF Version : 1.5 Linearized : Yes Create Date : 2014:08:08 08:28:01-07:00 Creator : Adobe InDesign CS6 (Windows) Modify Date : 2014:08:08 08:31:57-07:00 XMP Toolkit : Adobe XMP Core 5.2-c001 63.139439, 2010/09/27-13:37:26 Metadata Date : 2014:08:08 08:31:57-07:00 Creator Tool : Adobe InDesign CS6 (Windows) Instance ID : uuid:41b8fea1-549b-47a1-a9bc-a946ef57c9d1 Original Document ID : xmp.did:3195D91657CDDD11841EF19E5A285EBE Document ID : xmp.id:04E38895101FE411812BAF839D00D13F Rendition Class : proof:pdf Derived From Instance ID : xmp.iid:AD3B06E90F1FE411ADA38A64AD4B63E7 Derived From Document ID : xmp.did:4FACDCC7881EE411ADA38A64AD4B63E7 Derived From Original Document ID: xmp.did:3195D91657CDDD11841EF19E5A285EBE Derived From Rendition Class : default History Action : converted History Parameters : from application/x-indesign to application/pdf History Software Agent : Adobe InDesign CS6 (Windows) History Changed : / History When : 2014:08:08 08:28:01-07:00 Format : application/pdf Producer : Adobe PDF Library 10.0.1 Trapped : False Page Layout : OneColumn Page Count : 13EXIF Metadata provided by EXIF.tools