OpenGL and GLU Overview Quiz

OpenGL is a software library that provides commands for interacting with graphics hardware, allowing developers to create interactive 3D graphics applications.

OpenGL is designed to be independent of the specific hardware it's used on. It can work on various platforms with different graphics capabilities.

OpenGL doesn't handle windowing tasks or user input; it focuses solely on graphics rendering. You need separate tools for handling those aspects.

These functions define the basic building blocks of 3D shapes in OpenGL, such as points, lines, polygons, and more.

These functions control how primitives look, such as their color, type of line (solid, dashed), light effects, and textures.

These functions determine the properties of the virtual camera used to view the 3D scene, such as its position, orientation, and perspective.

The process of converting 3D models into 2D images that can be displayed on a screen.

OpenGL uses a method called rasterization to create images. However, other rendering techniques exist, such as ray tracing.

A stage in the rendering pipeline that converts geometric primitives (e.g., points, lines, triangles) into a collection of fragments, which are essentially small pieces of information about each pixel that will be drawn.

A user-written program in GLSL (OpenGL Shading Language) that determines the final color of each fragment (potential pixel) on the screen. It runs independently for each fragment.

A set of tests that can be applied to fragments (potential pixels) based on user settings. These tests include things like checking if a fragment belongs to a specific pixel, or if it passes the depth or stencil test.

The smallest visible element on your computer display. It's a unit of color on the screen.

A chunk of memory used by the graphics hardware to store pixels for the image displayed on your screen.

A cross-platform, hardware accelerated API (Application Programming Interface) used to create 3D (and 2D) graphics. It acts as a bridge between your code and the graphics hardware.

The primary set of commands in OpenGL, responsible for defining and drawing geometric shapes like points, lines, and polygons.

A geometric primitive in OpenGL representing a closed shape with three vertices.

The glutInitWindowSize function is used to set the initial size of the display window in terms of pixels.

Sets the display mode of the OpenGL window, determining its characteristics like the color buffer type and depth buffer.

Creates the display window using the current settings defined in the previous steps, giving it a title.

A programming concept where code execution is triggered in response to specific events happening within the program, such as user input.

A function that is automatically executed when a specific event occurs, allowing the programmer to define actions for different events.

The most crucial event in OpenGL rendering, responsible for redrawing the display window content whenever necessary.

The glutDisplayFunc assigns the defined myDisplay function to be executed when the display event occurs.

Starts the event loop, where OpenGL continuously listens for and handles events, leading to the execution of corresponding callback functions.

A library built on top of OpenGL, providing utilities like camera setup and projection, along with tools to create models such as quadric surfaces and polygons.

Commands within GLU always start with 'glu', such as 'gluLookAt' or 'gluPerspective'.

A library designed to interact with the operating system, providing functionality for window creation, handling user inputs (keyboard and mouse), and creating simple 3D models.

OpenGL is designed to work on different operating systems, but it's not inherently window-system dependent.

OpenGL needs GLUT to interact with the operating system. GLUT provides functionality for creating windows, responding to user inputs, and building basic 3D objects.

The core library behind OpenGL. It's responsible for graphics rendering and is hardware-independent, but its implementation varies across operating systems.

OpenGL and GLUT can be used in C++ to build 3D applications. Dev-C++ has OpenGL built-in and GLUT can be added; Microsoft Visual C++ has OpenGL, but GLUT is available as a separate download.

A library that provides extra functions for creating user interfaces in OpenGL applications, often used with GLU and GLUT.

A three-dimensional coordinate system where each point is represented by an x, y, and z value. It is used to define the position of objects in 3D space.

The ability to move freely in three dimensions. It corresponds to the movement along the x, y, and z axes of a 3D coordinate system.

A specific arrangement that determines the direction you are looking at a 3D object. It is defined by a point in space and an angle of rotation around that point.

The default orientation in 3D graphics. It is specified by looking down the negative z-axis, with the up direction along the positive y-axis.

These are parameters that control the visual appearance of a graphics object.

A system that stores and manages the current settings for how objects should be drawn. It remembers the current state of attributes like color, size, and position.

A color representation that uses three values - Red, Green, and Blue - to define the color.

An extension of RGB that includes an Alpha value, which controls the transparency or opacity of the color.

The amount of memory needed to store a frame buffer depends on the resolution and color depth. For example, a screen resolution of 1024x768 with 8 bits for each red, green, and blue color component requires 1024x768x24 bits, which equals 2.4MB.

A look-up table (LUT) stores a limited number of colors, represented by indices. Each pixel in the frame buffer stores an index, which references a corresponding color in the LUT.

LUTs save storage, but they slow down the rasterization process because an extra look-up operation is needed. They were popular in the past when memory was expensive, but modern systems generally use direct storage due to cheaper memory.

OpenGL defaults to direct storage, meaning each pixel stores its actual color data directly in the frame buffer. However, if desired, the programmer can opt for a color look-up table through certain functions.

The glColor* function is used to change the current color used for drawing. It allows setting the color using RGB or RGBA representations. For instance, glColor3f(1.0,0.0,0.0) sets the drawing color to red.

glClearColor is used to modify the background color of the scene. It always uses RGBA representation, and the alpha value might not always be utilized.

Before beginning OpenGL drawing, a frame buffer needs to be defined. For color drawing, a color frame buffer is specified using the function glutInitDisplayMode(GLUT_SINGLE,GLUT_RGB). To incorporate alpha values, use GLUT_RGBA, and to utilize a color look-up table use GLUT_INDEX.

A point is the simplest shape in OpenGL. The only attributes that can be modified for points are their color and size. The glPointSize function changes the size of points in pixels, with a default size of 1 pixel.