# OpenGL (8.) - Slovníček pojmů v OpenGL

Dnes jsem si pro vás přichystal menší slovníček důležitých pojmů, se kterými se můžete setkat při programování v OpenGL. Je sice v only-english verzi, ale Vám jako programátorům by to nemělo zas tak moc vadit. Je potřeba si zvykat :-).

**A**- aliasing
- A rendering technique that assigns to pixels the color of the primitive being rendered, regardless of whether that primitive covers all of the pixel's area or only a portion of the pixel's area. This results in jagged edges, or jaggies
- alpha
- A fourth color component typically used to control color blending. The alpha component is never displayed directly. By convention, OpenGL alpha corresponds to opacity rather than transparency, meaning an alpha value of 1.0 implies complete opacity, and an alpha value of 0.0 implies complete transparency.
- animation
- Generating repeated renderings of a scene, with smoothly changing viewpoint and/or object positions, quickly enough that the illusion of motion is achieved. OpenGL animation almost always is done using double-buffering.
- antialiasing
- A rendering technique that assigns pixel colors based on the fraction of the pixel's area that's covered by the primitive being rendered. Antialiased rendering reduces or eliminates the jaggies that result from aliased rendering.
- application-specific clipping
- Clipping of primitives against planes in eye coordinates. The planes are specified by the application using glClipPlane( ).
**B**- back face
- See face
- bit
- Binary digit. A state variable that has only two possible values: 0 or 1. Binary numbers are constructions of one or more bits.
- bitmap
- A rectangular array of bits. Also, the primitive rendered by the glBitmap( ) command, which uses its bitmap parameter as a mask.
- bitplane
- A rectangular array of bits mapped one-to-one with pixels. The frame buffer is a stack of bitplanes.
- blending
- Reduction of two color components to one component, usually as a linear interpolation between the two components.
- buffer
- A group of bitplanes that store a single component (such as depth or green) or a single index (such as the color index or the stencil index). Sometimes the red, green, blue, and alpha buffers together are referred to as the color buffer, rather than the color buffers.
**C**- client
- The computer from which OpenGL commands are issued. The computer that issues OpenGL commands can be connected through a network to a different computer that executes the commands, or commands can be issued and executed on the same computer. See also server
- client memory
- The main memory (where program variables are stored) of the client computer.
- clip coordinates
- The coordinate system that follows transformation by the projection matrix and that precedes perspective division. View-volume clipping is done in clip coordinates, but application-specific clipping is not.
- clipping
- Elimination of the portion of a geometric primitive that's outside the half-space defined by a clipping plane. Points are simply rejected if outside. The portion of a line or of a polygon that's outside the half-space is eliminated, and additional vertices are generated as necessary to complete the primitive within the clipping half-space. Geometric primitives and the current raster position (when specified) are always clipped against the six half-spaces defined by the left, right, bottom, top, near, and far planes of the view volume. Applications can specify optional application-specific clipping planes to be applied in eye coordinates.
- color index
- A single value that represents a color by name, rather than by value. OpenGL color indexes are treated as continuous values (for example, floating-point numbers) while operations such as interpolation and dithering are performed on them. Color indexes stored in the frame buffer are always integer values, however. Floating-point indexes are converted to integers by rounding to the nearest integer value.
- color-index mode
- An OpenGL context is in color index mode if its color buffers store color indexes, rather than red, green, blue, and alpha color components.
- color map
- A table of index-to-RGB mappings that's accessed by the display hardware. Each color index is read from the color buffer, converted to an RGB triple by lookup in the color map, and sent to the monitor.
- component
- A single, continuous (for example, floating-point) value that represents an intensity or quantity. Usually, a component value of zero represents the minimum value or intensity, and a component value of one represents the maximum value or intensity, though other normalizations are sometimes used. Because component values are interpreted in a normalized range, they are specified independent of actual resolution. For example, the RGB triple (1, 1, 1) is white, regardless of whether the color buffers store 4, 8, or 12 bits each. Out-of-range components are typically clamped to the normalized range, not truncated or otherwise interpreted. For example, the RGB triple (1.4, 1.5, 0.9) is clamped to (1.0, 1.0, 0.9) before it's used to update the color buffer. Red, green, blue, alpha, and depth are always treated as components, never as indexes.
- context
- A complete set of OpenGL state variables. Note that frame buffer contents are not part of the OpenGL state, but that the configuration of the frame buffer is.
- convex
- A polygon is convex if no straight line in the plane of the polygon intersects the polygon more than twice.
- convex hull
- The smallest convex region enclosing a specified group of points. In two dimensions, the convex hull is found conceptually by stretching a rubber band around the points so that all of the points lie within the band.
- coordinate system
- In n-dimensional space, a set of n linearly independent vectors anchored to a point (called the origin). A group of coordinates specifies a point in space (or a vector from the origin) by indicating how far to travel along each vector to reach the point (or tip of the vector).
- culling
- The process of eliminating a front face or back face of a polygon so that it isn't drawn.
- current matrix
- A matrix that transforms coordinates in one coordinate system to coordinates of another system. There are three current matrices in OpenGL: the modelview matrix transforms object coordinates (coordinates specified by the programmer) to eye coordinates; the perspective matrix transforms eye coordinates to clip coordinates; the texture matrix transforms specified or generated texture coordinates as described by the matrix. Each current matrix is the top element on a stack of matrices. Each of the three stacks can be manipulated with OpenGL matrix-manipulation commands.
- current raster position
- A window coordinate position that specifies the placement of an image primitive when it's rasterized. The current raster position, and other current raster parameters, are updated when glRasterpos( ) is called.
**D**- depth
- Generally refers to the z window coordinate.
- depth-cueing
- A rendering technique that assigns color based on distance from the viewpoint.
- display list
- A named list of OpenGL commands. Display lists are always stored on the server, so display lists can be used to reduce the network traffic in client-server environments. The contents of a display list may be preprocessed, and might therefore execute more efficiently than the same set of OpenGL commands executed in immediate mode. Such preprocessing is especially important for computing intensive commands such as glTexImage( ).
- dithering
- A technique for increasing the perceived range of colors in an image at the cost of spatial resolution. Adjacent pixels are assigned differing color values. When viewed from a distance, these colors seem to blend into a single intermediate color. The technique is similar to the half-toning used in black-and-white publications to achieve shades of gray.
- double-buffering
- OpenGL contexts with both front and back color buffers are double-buffered. Smooth animation is accomplished by rendering into only the back buffer (which isn't displayed), then causing the front and back buffers to be swapped.
**E**- element
- A single component or index.
- evaluation
- The OpenGL process of generating object-coordinate vertices and parameters from previously specified Bé zier equations.
- execute
- An OpenGL command is executed when it's called in immediate mode or when the display list that it's a part of is called.
- eye coordinates
- The coordinate system that follows transformation by the modelview matrix and that precedes transformation by the projection matrix. Lighting and application-specific clipping are done in eye coordinates.
**F**- face
- One side of a polygon. Each polygon has two faces: a front face and a back face. Only one face or the other is ever visible in the window. Whether the back or front face is visible is effectively determined after the polygon is projected onto the window. After this projection, if the polygon's edges are directed clockwise, one of the faces is visible; if directed counterclockwise, the other face is visible. Whether clockwise corresponds to front or back (and counterclockwise corresponds to back or front) is determined by the OpenGL programmer.
- flat shading
- Refers to coloring a primitive with a single, constant color across its extent, rather than smoothly interpolating colors across the primitive. See Gouraud shading
- fog
- A rendering technique that can be used to simulate atmospheric effects such as haze, fog, and smog by fading object colors to a background color based on distance from the viewer. Fog also aids in the perception of distance from the viewer, giving a depth cue
- font
- A group of graphical character representations usually used to display strings of text. The characters may be roman letters, mathematical symbols, Asian ideograms, Egyptian hieroglyphs, and so on.
- fragment
- Fragments are generated by the rasterization of primitives. Each fragment corresponds to a single pixel and includes color, depth, and sometimes texture-coordinate values.
- frame buffer
- All the buffers of a given window or context. Sometimes includes all the pixel memory of the graphics hardware accelerator.
- front face
- See face
- frustum
- The view volume warped by perspective division.
**G**- gamma correction
- A function applied to colors stored in the frame buffer to correct for the nonlinear response of the eye (and sometimes of the monitor) to linear changes in color-intensity values.
- geometric model
- The object-coordinate vertices and parameters that describe an object. Note that OpenGL doesn't define a syntax for geometric models, but rather a syntax and semantics for the rendering of geometric models.
- geometric object
- Geometric model.
- geometric primitive
- A point, a line, or a polygon.
- Gouraud shading
- Smooth interpolation of colors across a polygon or line segment. Colors are assigned at vertices and linearly interpolated across the primitive to produce a relatively smooth variation in color. Also called smooth shading.
- group
- Each pixel of an image in client memory is represented by a group of one, two, three, or four elements. Thus, in the context of a client memory image, a group and a pixel are the same thing.
**H**- half-space
- A plane divides space into two half-spaces.
- homogenous coordinates
- A set of n+1 coordinates used to represent points in n-dimensional projective space. Points in projective space can be thought of as points in Euclidean space together with some points at infinity. The coordinates are homogenous because a scaling of each of the coordinates by the same non-zero constant doesn't alter the point to which the coordinates refer. Homogeneous coordinates are useful in the calculations of projective geometry, and thus in computer graphics, where scenes must be projected onto a window.
**I**- image
- A rectangular array of pixels, either in client memory or in the frame buffer.
- image primitive
- A bitmap or an image.
- immediate mode
- Execution of OpenGL commands when they're called, rather than from a display list. No immediate-mode bit exists; the mode in immediate mode refers to usage of OpenGL, rather than to a specific bit of OpenGL state.
- index
- A single value that's interpreted as an absolute value, rather than as a normalized value in a specified range (as is a component). Color indexes are the names of colors, which are dereferenced by the display hardware using the color map. Indexes are typically masked, rather than clamped, when out of range. For example, the index 0xf7 is masked to 0x7 when written to a 4-bit buffer (color or stencil). Color indexes and stencil indexes are always treated as indexes, never as components.
- IRIS GL
- Silicon Graphics' proprietary graphics library, developed from 1982 through 1992. OpenGL was designed with IRIS GL as a starting point.
**J**- jaggies
- Artifacts of aliased rendering. The edges of primitives that are rendered with aliasing are jagged rather than smooth. A near-horizontal aliased line, for example, is rendered as a set of horizontal lines on adjacent pixel rows, rather than as a smooth, continuous line.
**L**- lighting
- The process of computing the color of a vertex based on current lights, material properties, and lighting-model modes.
- line
- A straight region of finite width between two vertices. (Unlike mathematical lines, OpenGL lines have finite width and length.) Each segment of a strip of lines is itself a line.
- luminance
- The perceived brightness of a surface. Often refers to a weighted average of red, green, and blue color values that gives the perceived brightness of the combination.
**M**- matrices
- Plural of matrix.
- matrix
- A two-dimensional array of values. OpenGL matrices are all 4x4, though when they are stored in client memory they're treated as 1x16 single-dimension arrays.
- modelview matrix
- The 4x4 matrix that transforms points, lines, polygons, and raster positions from object coordinates to eye coordinates.
- monitor
- The device that displays the image in the frame buffer.
- motion blurring
- A technique that simulates what you get on a piece of film when you take a picture of a moving object, or when you move the camera when you take a picture of a stationary object. In animations without motion blur, moving objects can appear jerky.
**N**- network
- A connection between two or more computers that allows each to transfer data to and from the others.
- nonconvex
- A polygon is nonconvex if there exists a line in the plane of the polygon that intersects the polygon more than twice.
- normal
- A three-component plane equation that defines the angular orientation, but not position, of a plane or surface.
- normalize
- Divide each of the components of a normal by the square root of the sum of their squares. Then, if the normal is thought of as a vector from the origin to the point (nx˘, ny˘, nx˘), this vector has unit length

nx˘ = nx/factor

ny˘ = ny/factor

nz˘ = nz/factor - normal vector
- Same as normal.
- NURBS
- Non-Uniform Rational B-Spline. A common way to specify parametric curves and surfaces.
**O**- object
- An object-coordinate model that's rendered as a collection of primitives.
- object coordinates
- Coordinate system prior to any OpenGL transformation.
- orthographic
- Nonperspective projection, as in some engineering drawings, with no foreshortening.
**P**- parameter
- A value passed as an argument to an OpenGL command. Sometimes one of the values passed by reference to an OpenGL command.
- perspective division
- The division of x, y, and z by w, carried out in clip coordinates.
- pixel
- Picture element. The bits at location (x, y) of all the bitplanes in the frame buffer constitute the single pixel (x, y ). In an image in client memory, a pixel is one group of elements. In OpenGL window coordinates, each pixel corresponds to a 1.0x1.0 screen area. The coordinates of the lower left corner of the pixel names x, y are (x, y ), and the upper right corner are (x+1, y+1).
- point
- An exact location in space, which is rendered as a finite-diameter dot.
- polygon
- A near-planar surface bounded by edges specified by vertices. Each triangle of a triangle mesh is a polygon, as is each quadrilateral of a quadrilateral mesh. The rectangle specified by glRect*( ) is also a polygon.
- primitive
- A shape (such as a point, line, polygon, bitmap or image) that can be drawn, stored, and manipulated as a discrete entity; elements from which large graphic designs are created.
- projection matrix
- The 4x4 matrix that transforms points, lines, polygons, and raster positions from eye coordinates to clip coordinates.
**Q**- quadrilateral
- A polygon with four edges.
**R**- rasterize
- Convert a projected point, line, or polygon, or the pixels of a bitmap or image, to fragments, each corresponding to a pixel in the frame buffer. Note that all primitives are rasterized, not just points, lines, and polygons.
- rectangle
- A quadrilateral whose alternate edges are parallel to each other in object coordinates. Polygons specified with glRect*( ) are always rectangles; other quadrilaterals might be rectangles.
- rendering
- Conversion of primitives specified in object coordinates to an image in the frame buffer. Rendering is the primary operation of OpenGL.
- RGBA
- Red, Green, Blue, Alpha
- RGBA mode
- An OpenGL context is in RGBA mode if its color buffers store red, green, blue, and alpha color components, rather than color indexes.
**S**- server
- The computer on which OpenGL commands are executed. This might differ from the computer from which commands are issued. See client
- shading
- The process of interpolating color within the interior of a polygon, or between the vertices of a line, during rasterization.
- single-buffering
- OpenGL contexts that don't have back color buffers are single-buffered.
- stipple
- A one- or two-dimensional binary pattern that defeats the generation of fragments where its value is zero. Line stipples are one-dimensional and are applied relative to the start of a line. Polygon stipples are two-dimensional and are applied with a fixed orientation to the window.
**T**- tessellation
- Reduction of a portion of an analytic surface to a mesh of polygons, or of a portion of an analytic curve to a sequence of lines.
- texel
- A texture element. A texel is obtained from texture memory and represents the color of the texture to be applied to a corresponding fragment.
- texture
- A one- or two-dimensional image used to modify the color of fragments produced by rasterization.
- texture mapping
- The process of applying an image (the texture) to a primitive. Texture mapping is often used to add realism to a scene. For example, you could apply a picture of a building facade to a polygon representing a wall.
- texture matrix
- The 4x4 matrix that transforms texture coordinates from the coordinates that they're specified in to the coordinates that are used for interpolation and texture lookup.
- transformation
- A warping of space. In OpenGL, transformations are limited to projective transformations that include anything that can be represented by a 4x4 matrix. Such transformations include rotations, translations, (nonuniform) scalings along the coordinate axes, perspective transformations, and combinations of these.
- triangle
- A polygon with three edges. Triangles are always convex.
**V**- vertex
- A point in three-dimensional space.
- vertices
- Preferred plural of vertex.
- viewpoint
- The origin of either the eye- or the clip-coordinate system, depending on context. (For example, when discussing lighting, the viewpoint is the origin of the eye-coordinate system. When discussing projection, the viewpoint is the origin of the clip-coordinate system.) With a typical projection matrix, the eye-coordinate and clip-coordinate origins are at the same location.
- view volume
- The volume in clip coordinates whose coordinates satisfy the three conditions
**W**- window
- A subregion of the frame buffer, usually rectangular, whose pixels all have the same buffer configuration. An OpenGL context renders to a single window at a time.
- window-aligned
- When referring to line segments or polygon edges, implies that these are parallel to the window boundaries. (In OpenGL, the window is rectangular, with horizontal and vertical edges). When referring to a polygon pattern, implies that the pattern is fixed relative to the window origin.
- window coordinates
- The coordinate system of a window. It's important to distinguish between the names of pixels, which are discrete, and the window-coordinate system, which is continuous. For example, the pixel at the lower-left corner of a window is a pixel (0, 0); the window coordinates of the center of this pixel are (0.5, 0.5, z). Note that window coordinates include a depth, or z, component, and that this component is continuous as well.
- wireframe
- A representation of an object that contains line segments only. Typically, the line segments indicate polygon edges.
**X**- X Window System
- A window system used by many of the machines on which OpenGL is implemented.

Vyšlo 03.01.2002, v blogu: 0 1 2 3 4 5 6 7 8

Děkuji, že jste se rozhodl(a) přečíst tento článek. Budu rád i za komentář. Pokud Vás tento článek zaujal a rádi byste jej doporučili ostatním, podpořte mně prosím tím, že věnujete minutku svého času a uděláte mi reklamu na linkuj.cz, vybrali.sme.sk či jagg.cz. Přeji příjemné čtení

## Poslední články

- 3D Studio MAX (11.) - Tvorba realistické jeskyně
- Zoner Callisto (2.) - Export do PDF
- OpenGL (11.) - Nová detekce kolizí
- OpenGL (10.) - Nová knihovna geometry.pas
- OpenGL (9.) - Generování textur a vylepšení FarClip Distance
- Zoner Callisto (1.) - Export do GIFu
- 3D Studio MAX (9.) - Vytváření odlesků vodní hladiny
**OpenGL (8.) - Slovníček pojmů v OpenGL**- OpenGL (7.) - Detekce kolizí, načtení mapy a textury v jpg souboru
- OpenGL (6.) - Co je to MiniGL
- OpenGL (5.) - Urychlení pomocí glDrawElements
- Delphi (7.) - Syst. repro a autodestrukce souboru
- OpenGL (4.) - FullScreen
- 3D Studio MAX (8.) - Tvorba hořící zápalky
- 'DOOM' 3D Engine techniques

## Diskuse k blogu

Vložil: (26.02.2011 15:08:53)

Přidání příspěvku