Opengl presentation

Opengl
OpenGL has been around for over 16 years. Its
development is overseen by the Khronos group.

OpenGL has undergone some radical changes in its most
recent release.

OpenGL Architecture

internal state machine
In programmable it is up to the
programmer to not only pass in
the correct information (for
example the color of the vertex)
but also apply this information
to the vertex in the shader.

Fixed-Function vs.
Programmability

Related Libraries

GLUT (OpenGL Utility Toolkit)
SDL

GLUT
OpenGL Utility Toolkit
windowing, menus, or input

SDL

The Simple Direct Media Layer

audio, input, 2D graphics, and many other things

WGL
prevent multiple OpenGL applications from interfering with
each other. This is done through the use of a rendering
context

Only one rendering context per thread.

HGLRC wglCreateContext(HDC hDC);

BOOL wglDeleteContext(HGLRC hRC);

BOOL wglMakeCurrent(HDC hDC, HGLRC hRC);

WGL
HGLRC wglGetCurrentContext();

HDC wglGetCurrentDC();

Pixel Formats
typedef struct tagPIXELFORMATDESCRIPTOR {

WORD nSize;
WORD nVersion;
DWORD dwFlags;
BYTE iPixelType;
BYTE cColorBits;
BYTE cRedBits;
BYTE cRedShift;
BYTE cGreenBits;
BYTE cGreenShift; BYTE cBlueBits;
BYTE cBlueShift;
BYTE cAlphaBits;
BYTE cAlphaShift; BYTE cAccumBits;
BYTE cAccumRedBits; BYTE cAccumGreenBits; BYTE cAccumBlueBits; BYTE
cAccumAlphaBits; BYTE cDepthBits;
BYTE cStencilBits; BYTE cAuxBuffers; BYTE iLayerType;
BYTE bReserved;
DWORD dwLayerMask; DWORD dwVisibleMask; DWORD dwDamageMask;

} PIXELFORMATDESCRIPTOR;

Pixel Formats
nSize

dwFlags

iPixelType
PFD_TYPE_RGBA. RGBA pixels. Each pixel has four
components in this order: red, green, blue, and alpha.
PFD_TYPE_COLORINDEX. Paletted mode. Each pixel uses a
color-index value.

• cColorBits the bits per pixel

Setting the Pixel Format
int ChoosePixelFormat(HDC hdc, CONST
PIXELFORMATDESCRIPTOR *ppfd); (modify pixel
format to match supported and return id for pixel format)

BOOL SetPixelFormat(HDC hdc, int pixelFormat, const
PIXELFORMATDESCRIPTOR *ppfd);

void glGetBooleanv(GLenum pname, GLboolean
*params); void glGetDoublev(GLenum pname, GLdouble
*params); void glGetFloatv(GLenum pname, GLfloat
*params); void glGetIntegerv(GLenum pname, GLint
*params);

Enabling and Disabling States

void glEnable(GLenum cap);

void glDisable(GLenum cap);

GLboolean glIsEnabled(GLenum cap);

Querying String Values
const GLubyte *glGetString(GLenum name);

GL_VENDOR , GL_RENDERER , GL_VERSION ,
GL_EXTENSIONS

Finding Errors
GLenum glGetError();

Colors in OpenGL
void glColor (T components);

void glColorv(T components);

Handling Primitives
Immediate Mode

Vertex Arrays

Immediate Mode
void glBegin(GLenum mode);

glBegin()

glEnd()

GL_INVALID_OPERATION

void glVertex{234}{dfis}();

void glVertex{234}{dfis}v();

Vertex Arrays
void glEnableClientState(GLenum cap);

void glDisableClientState(GLenum cap);

gl*Pointer()

void glVertexPointer(GLint size, GLenum type, GLsizei
stride, const GLvoid *array);
size must be 2, 3, or 4 and
Type can be set to GL_SHORT, GL_INT, GL_FLOAT, or
GL_DOUBLE.
Stride padding in bytes between each vertex

Vertex Arrays
void glColorPointer(GLint size, GLenum type, GLsizei
stride, const GLvoid *array);
void glEdgeFlagPointer(GLsizei stride, const GLboolean
*array);
Array of Boolean

void glNormalPointer(GLenum type, GLsizei stride, const
GLvoid *array); normals always (x,y,z) so no need for the
size.
void glTexCoordPointer(GLint size, GLenum type, GLsizei
stride, const GLvoid *array); size = number of coordinate
per vertex

Rendering Uesing Vertex
Arrays
void glDrawArrays(GLenum mode, GLint first, GLsizei
count);

void glDrawElements(GLenum mode, GLsizei count,
GLenum type, const GLvoid *indices); [count is the
number of indices that you want to render ]

void glDrawRangeElements(GLenum mode, GLuint start,
GLuint end, GLsizei count, GLenum type, const GLvoid *
indices);

Rendering Uesing Vertex
Arrays
void glMultiDrawArrays(GLenum mode, GLint *first,
GLsizei *count, GLsizei primcount)

Vertex Buffer Objects
(VRAM) instead of (RAM)

To use a VBO, you need to perform the following steps:
1. Generate a name for the buffer.
2. Bind (activate) the buffer.
3. Store data in the buffer.
4. Use the buffer to render the data. 5. Destroy the buffer.
5. Destroy the buffer.

Generating a Name
void glGenBuffers(GLsizei n, GLuint *buffers);

void glDeleteBuffers(GLsizei n, const GLuint *buffers);

Binding the Buffer
Binding a buffer makes it current; all buffer-related OpenGL calls
and rendering will operate on the currently bound buffer.

void glBindBuffer(GLenum target, GLuint buffer);

target can be GL_ARRAY_BUFFER,
GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER,
or GL_PIXEL_UNPACK_BUFFER

GL_ARRAY_BUFFER for vertices data and
GL_ELEMENT_ARRAY_BUFFER for indices data.

if buffer is zero, the call will unbind any currently bound buffer.

Filling the Buffer
void glBufferData(GLenum target, GLsizeiptr size, const
GLvoid *data, GLenum usage);
usage is a hint to OpenGL telling it how you intend to use
this buffer. It can be GL_STREAM_DRAW,
GL_STREAM_READ, GL_STREAM_COPY,
GL_STATIC_DRAW, GL_STATIC_READ,
GL_STATIC_COPY, GL_DYNAMIC_DRAW,
GL_DYNAMIC_READ, or GL_DYNAMIC_COPY
Calling glBufferData() on a buffer object that already
contains data will cause the old data to be destroyed and
replaced with the new data

Rendering with Buffers and
Vertex Arrays
When rendering with VBOs you use gl*Pointer() functions
as an offset.

Modifying Point Size
void glPointSize(GLfloat size)

If point anti-aliasing is disabled then the point size is
rounded to the nearest integer never zero.

Opengl presentation

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Opengl presentation (20)

Opengl presentation