OpenGL 4.1快速参考卡片：顶点与多边形处理

需积分: 10 134 浏览量更新于2024-09-17 收藏 635KB PDF 举报

OpenGL 4.1 API Quick Reference Card 是一个详细的指南，专注于OpenGL 4.1版本的核心编程接口。这个文档是针对那些希望快速查阅和理解OpenGL函数特性和用法的专业开发者，特别是对三维图形渲染有深入需求的人。它提供了关键的API函数列表及其用途，有助于程序员在实际项目中高效地查询和调用这些函数。核心部分包括： 1. **Begin and End** (从2.6版本开始)：这两个函数用于包围一组顶点坐标，构建几何对象。`void Begin(enum mode)` 开始一个新的绘制模式，例如线段、三角形等，之后可以设置属性如颜色、纹理等。`void End()` 结束当前的绘制状态，恢复到上一次的Begin状态。 2. **Separate Patches**：用于控制多边形模式，允许定义独立的顶点集合来创建复杂的形状。`void PatchParameteri(pname, int value)` 可以设置patch参数，比如PATCH_VERTICES，用于指定每个patch中的顶点数量。 3. **Polygon Edges**：此功能标记多边形边作为边界或非边界，以便于渲染和光照处理。`void EdgeFlag(boolean flag)` 和 `void EdgeFlagv(const boolean* flag)` 分别设置单个或多个边的边缘标志。 4. **Vertex Specification** (2.7版本)：定义了顶点属性，包括位置（2D、3D或4D）、法线、纹理坐标、通用顶点属性（如颜色、次级颜色和雾坐标）等。`void Vertex{234}{sifd}(Tcoords)` 和 `void Vertex{234}{sifd}v(const Tcoords)` 方法允许设置单个或多个顶点的坐标，而 `void VertexP{234}ui` 和 `void VertexP{234}uiv` 则用于指定不同类型的整数纹理坐标。 5. **TexCoord** 函数：用于设置顶点的纹理坐标，`void TexCoord{1234}{sifd}` 和 `void TexCoord{1234}{sifd}v` 方法分别设置单个或多个纹理坐标值，其中Tcoords类型可能包括INT_2_10_10_10_REV和UNSIGNED_INT_2_10_10_10_REV。这份参考卡片提供了对OpenGL 4.1 API中基础且重要的部分进行快速查询的工具，对于理解顶点处理、多边形操作以及纹理映射等方面的知识至关重要。开发者可以从中找到所需的具体函数签名、参数含义以及用法示例，帮助他们在实际项目中高效地应用OpenGL技术。

OpenGL 4.1 API Quick Reference Card - Page 1

Vertex Specicaon

Begin and End [2.6]

Enclose coordinate sets between Begin/End

pairs to construct geometric objects.

void Begin(enum mode);

void End(void);

mode: see MulDrawElementsBaseVertex

Separate Patches

void PatchParameteri(enum pname, int value);

pname: PATCH_VERTICES

Polygon Edges [2.6.2]

Flag each edge of polygon primives as either

boundary or non-boundary.

void EdgeFlag(boolean ag);

void EdgeFlagv(const boolean *ag);

Vertex Specicaon [2.7]

Verces have 2, 3, or 4 coordinates, and

oponally a current normal, mulple current

texture coordinate sets, mulple current

generic vertex aributes, current color, current

secondary color, and current fog coordinates.

void Vertex{234}{sifd}(T coords);

void Vertex{234}{sifd}v(const T coords);

void VertexP{234}ui(enum type, uint coords);

void VertexP{234}uiv(enum type,

const uint *coords);

type: INT_2_10_10_10_REV,

UNSIGNED_INT_2_10_10_10_REV

void TexCoord{1234}{sifd}(T coords);

void TexCoord{1234}{sifd}v(const T coords);

void TexCoordP{1234}ui(enum type,

uint coords);

void TexCoordP{1234}uiv(enum type,

const uint *coords);

type: see VertexP{234}uiv

void MulTexCoord{1234}{sifd}(

enum texture, T coords);

void MulTexCoord{1234}{sifd}v(

enum texture, const T coords);

texture: TEXTUREi (where i is

[0, MAX_TEXTURE_COORDS - 1])

void MulTexCoordP{1234}ui(enum texture,

enum type, uint coords);

void MulTexCoordP{1234}uiv(

enum texture, enum type, const uint *coords);

void Normal3{bsifd}(const T coords);

void Normal3{bsifd}v(T coords);

void NormalP3ui(enum type, uint normal);

void NormalP3uiv(enum type, uint *normal);

void FogCoord{fd}(T coord);

void FogCoord{fd}v(const T coord);

void Color{34}{bsifd ubusui}(T components);

void Color{34}{bsifd ubusui}v(

const T components);

void ColorP{34}ui(enum type, uint coords);

void ColorP{34}uiv(enum type,

const uint *coords);

void SecondaryColor3{bsifd ubusui}(

T components);

void SecondaryColor3{bsifd ubusui}v(

const T components);

void SecondaryColorP3ui(enum type,

uint coords);

void SecondaryColorP3uiv(enum type,

const uint *coords);

void Index{sifd ub}(T index);

void Index{sifd ub}v(const T index);

The VertexArib* commands specify generic

aributes with components of type oat

(VertexArib*), int or uint (VertexAribI*), or

double (VertexAribL*d*).

void VertexArib{1234}{sfd}(uint index,

T values);

void VertexArib{123}{sfd}v(uint index,

const T values);

void VertexArib4{bsifd ub us ui}v(

uint index, const T values);

void VertexArib4Nub(uint index, T values);

void VertexArib4N{bsi ub us ui}v(

uint index, const T values);

void VertexAribI{1234}{i ui}(uint index,

T values);

void VertexAribI{1234}{i ui}v(uint index,

const T values);

void VertexAribI4{bs ub us}v(uint index,

const T values);

void VertexAribP{1234}ui(

uint index, enum type, boolean normalized,

uint value)

void VertexAribL{1234}d(uint index,

T values);

void VertexAribL{1234}dv(uint index,

T values);

void VertexAribP{1234}uiv(uint index,

enum type, boolean normalized,

const uint *value);

type: see VertexP{234}uiv

OpenGL Operaon

Floang-Point Numbers [2.1.1 - 2.1.2]

16-Bit 1-bit sign, 5-bit exponent,

10-bit manssa

Unsigned 11-Bit no sign bit, 5-bit exponent,

6-bit manssa

Unsigned 10-Bit no sign bit, 5-bit exponent,

5-bit manssa

Command Leers [Table 2.1]

Leers are used in commands to denote types.

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 - oat (32 bits) d - double (64 bits)

OpenGL

is the only cross-plaorm graphics API that enables developers of soware for

PC, workstaon, and supercompung hardware to create high-performance, visually-

compelling graphics soware applicaons, in markets such as CAD, content creaon,

energy, entertainment, game development, manufacturing, medical, and virtual reality.

Specicaons are available at www.opengl.org/registry

• see FunconName refers to funcons on this reference card.

• Content shown in blue is removed from the OpenGL 4.1 core prole and present only in the

OpenGL 4.1 compability prole. Prole selecon is made at context creaon.

• [n.n.n] and [Table n.n] refer to secons and tables in the OpenGL 4.1 core specicaon.

• [n.n.n] and [Table n.n] refer to secons and tables in the OpenGL 4.1 compability prole

specicaon, and are shown only when they dier from the core prole.

• [n.n.n] refers to secons in the OpenGL Shading Language 4.10 specicaon.

OpenGL Command Syntax [2.3]

GL commands are formed from a return type, a name, and oponally up to 4 characters

(or character pairs) from the Command Leers table (above), 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

suxes. N is 1, 2, 3, or 4 if present, or else corresponds to the type leers from the Command

Table (above). If “v” is present, an array of N items are passed by a pointer.

For brevity, the OpenGL documentaon and this reference may omit the standard prexes.

The actual names are of the forms:

glFunconName(), GL_CONSTANT, GLtype

Buer Objects

[2.9]

void GenBuers(sizei n, uint *buers);

void DeleteBuers(sizei n, const uint *buers);

Creang and Binding Buer Objects[2.9.1]

void BindBuer(enum target, uint buer);

target:

PIXEL_{PACK, UNPACK}_BUFFER, UNIFORM_BUFFER

ARRAY_BUFFER, COPY_{READ, WRITE}_BUFFER,

DRAW_INDIRECT_BUFFER, ELEMENT_ARRAY_BUFFER,

TEXTURE_BUFFER, TRANSFORM_FEEDBACK_BUFFER,

void BindBuerRange(enum target, uint index,

uint buer, intptr oset, sizeiptr size);

target: {TRANSFORM_FEEDBACK, UNIFORM}_BUFFER

void BindBuerBase(enum target,

uint index, uint buer);

target: see BindBuerRange

Creang Buer Object Data Stores[2.9.

void BuerData(enum target, sizeiptr size,

const void *data, enum usage);

usage: STREAM_{DRAW, READ, COPY},

{DYNAMIC, STATIC}_{DRAW, READ, COPY}

target: see BindBuer

void BuerSubData(enum target,

intptr oset, sizeiptr size,

const void *data);

target: see BindBuer

Mapping/Unmapping Buer Data[2.9.3]

void *MapBuerRange(enum target,

intptr oset, sizeiptr length, biield access);

access: The logical OR of MAP_{READ, WRITE}_BIT,

MAP_INVALIDATE_{BUFFER, RANGE}_BIT,

MAP_{FLUSH_EXPLICIT, UNSYNCHRONIZED}_BIT,

target: see BindBuer

void *MapBuer(enum target, enum access);

access: READ_ONLY, WRITE_ONLY, READ_WRITE

void FlushMappedBuerRange(

enum target, intptr oset, sizeiptr length);

target: see BindBuer

boolean UnmapBuer(enum target);

target: see BindBuer

Copying Between Buers [2.9.5]

void *CopyBuerSubData(enum readtarget,

enum writetarget, intptr readoset,

intptr writeoset, sizeiptr size);

readtarget and writetarget: see BindBuer

Vertex Array Objects [2.10]

All states related to denion of data used by

vertex processor is in a vertex array object.

void GenVertexArrays(sizei n, uint *arrays);

void DeleteVertexArrays(sizei n,

const uint *arrays);

void BindVertexArray(uint array);

Buer Object Queries [6.1.9] [6.1.15]

boolean IsBuer(uint buer);

void GetBuerParameteriv(enum target,

enum pname, int *data);

target: see BindBuer

pname: BUFFER_SIZE, BUFFER_USAGE,

BUFFER_ACCESS{_FLAGS}, BUFFER_MAPPED,

BUFFER_MAP_{OFFSET, LENGTH}

void GetBuerParameteri64v(enum target,

enum pname, int64 *data);

target: see BindBuer

pname: see GetBuerParameteriv,

void GetBuerSubData(enum target,

intptr oset, sizeiptr size, void *data);

target: see BindBuer

void GetBuerPointerv(enum target,

enum pname, void **params);

target: see BindBuer

pname: BUFFER_MAP_POINTER

Vertex Array Object Queries

[6.1.10] [6.1.16]

boolean IsVertexArray(uint array);

Vertex Arrays [2.8]

void VertexPointer(int size, enum type,

sizei stride, const void *pointer);

type: SHORT, INT, FLOAT, HALF_FLOAT, DOUBLE,

{UNSIGNED_}INT_2_10_10_10_REV

void NormalPointer(enum type, sizei stride,

const void *pointer);

type: see VertexPointer, plus BYTE

void ColorPointer(int size, enum type,

sizei stride, const void *pointer);

type: see VertexPointer, plus BYTE, UINT,

UNSIGNED_{BYTE, SHORT}

void SecondaryColorPointer(int size,

enum type, sizei stride, const void *pointer);

type:

see ColorPointer

void IndexPointer(enum type, sizei stride,

const void *pointer);

type: UNSIGNED_BYTE, SHORT, INT, FLOAT, DOUBLE

void EdgeFlagPointer(sizei stride,

const void *pointer);

void FogCoordPointer(enum type,

sizei stride, const void *pointer);

type: FLOAT, HALF_FLOAT, DOUBLE

void TexCoordPointer(int size, enum type,

sizei stride, const void *pointer);

type: see VertexPointer

void VertexAribPointer(uint index, int size,

enum type, boolean normalized,

sizei stride, const void *pointer);

type: see ColorPointer

, plus FIXED

void VertexAribIPointer(uint index,

int size, enum type, sizei stride,

const void *pointer);

type:

BYTE, SHORT, UNSIGNED_{BYTE, SHORT}, INT, UINT

index: [0, MAX_VERTEX_ATTRIBS - 1]

void VertexAribLPointer(uint index, int size,

enum type, sizei stride, const void *pointer);

type: DOUBLE

index: see VertexAribIPointer

void EnableClientState(enum array);

void DisableClientState(enum array);

array: {VERTEX, NORMAL, COLOR, INDEX}_ARRAY,

{SECONDARY_COLOR, EDGE_FLAG}_ARRAY,

FOG_COORD_ARRAY, TEXTURE_COORD_ARRAY

void EnableVertexAribArray(uint index);

void DisableVertexAribArray(uint index);

index: [0, MAX_VERTEX_ATTRIBS - 1]

void VertexAribDivisor(uint index,

uint divisor);

void ClientAcveTexture(enum texture);

index:

TEXTUREi (where i is [0, MAX_TEXTURE_COORDS - 1])

void ArrayElement(int i);

Enable/Disable(PRIMITIVE_RESTART)

void PrimiveRestartIndex(uint index);

Drawing Commands [2.8.3] [2.8.2]

void DrawArrays(enum mode, int rst,

sizei count);

void DrawArraysInstanced(enum mode,

int rst, sizei count, sizei primcount};

void DrawArraysIndirect(enum mode,

const void *indirect);

void MulDrawArrays(enum mode,

const int *rst, sizei *count,

const sizei primcount);

void DrawElements(enum mode,

sizei count, enum type, const void *indices);

void DrawElementsInstanced(enum mode,

sizei count, enum type, const void *indices,

sizei primcount);

void MulDrawElements(enum mode,

sizei *count, enum type,

const void **indices, sizei primcount);

void DrawRangeElements(enum mode,

uint start, uint end, sizei count,

enum type, const void *indices);

void DrawElementsBaseVertex(enum mode,

sizei count, enum type, const void *indices,

int basevertex);

void DrawRangeElementsBaseVertex(

enum mode, uint start, uint end,

sizei count, enum type, const void *indices,

int basevertex);

void DrawElementsInstancedBaseVertex(

enum mode, sizei count, enum type,

const void *indices, sizei primcount,

int basevertex);

void DrawElementsIndirect(enum

mode,

enum type, const void *indirect);

void MulDrawElementsBaseVertex(

enum mode, sizei *count, enum type,

const void **indices, sizei primcount,

int *basevertex);

mode: POINTS,

LINE_STRIP, LINE_LOOP, LINES,

POLYGON, TRIANGLE_{STRIP, FAN}, TRIANGLES,

QUAD_STRIP, QUADS, LINES_ADJACENCY,

{LINE, TRIANGLE}_STRIP_ADJACENCY,

PATCHES, TRIANGLES_ADJACENCY,

type: UNSIGNED_{BYTE, SHORT, INT}

void InterleavedArrays(enum format,

sizei stride, const void *pointer);

format: V2F, V3F, C4UB_{V2F, V3F}, {C3F, N3F}_V3F,

C4F_N3F_V3F, T2F_{C4UB, C3F, N3F}_V3F,

T2F_V3F, T4F_V4F, T2F_C4F_N3F_{V3F, V4F}

OpenGL Errors

[2.5]

enum GetError(void); Returns the numeric error code.

下载后可阅读完整内容，剩余9页未读，立即下载

外行人

粉丝: 2
资源: 3

OpenGL 4.1快速参考卡片：顶点与多边形处理

OpenGL 3.2 API Quick Reference Card

opengl 4.1 API

opengl-quick-reference-card

如何实现 OpenGL ES API

QT5.12.8自带的OpenGL版本为多少

OpenGL 函数库相关的 API

OpenGL 中三维图形的显示过程

opengl与qt3d与qtquick3D

vmware16显卡性能提高

opengl版本更替历史

最新资源