Graficacion - PowerPoint PPT Presentation

1 / 107
About This Presentation
Title:

Graficacion

Description:

Graficacion Curso de Ingenieria en Computacion Clave 115124 Profesor: Dr. Gueorgi Khatchatourov GENERAL INDEX Tema 1.- Aspectos generales de programaci n de realidad ... – PowerPoint PPT presentation

Number of Views:254
Avg rating:3.0/5.0
Slides: 108
Provided by: GeorgiiKh8
Category:

less

Transcript and Presenter's Notes

Title: Graficacion


1
Graficacion
  • Curso de Ingenieria en Computacion
  • Clave 115124
  • Profesor Dr. Gueorgi Khatchatourov

2
GENERAL INDEX
  • Tema 1.- Aspectos generales de programación de
    realidad virtual en OpenGL
  • Tema 2.- Lógica de transformaciones matriciales
    en OpenGL
  • Tema 3.- Viewing
  • Tema 4.- Transformations
  • Tema 5.- Projection transformations
  • Tema 6.- Viewport
  • Tema 7.- Selection
  • Tema 8.- Bitmaps
  • Tema 9.- Texture Mapping
  • Tema 10.- Blending

3
Tema 1.- Aspectos generales de programación de
realidad virtual en OpenGL
  • 1.1 Hardware structures for pixels on the
    screen
  • 1.2 Aspects of Graphics Programming
  • 1.3 Final part of the rendering process
  • 1.4 Real-time Graphics as events-based
    programming
  • 1.5.1 Call time control uso de
    glutIdleFunc (1)
  • 1.5.2 Call time control uso de
    glutIdleFunc (2)
  • 1.6.1 Other animation control uso de
    glutIdleFunc
  • 1.6.2 Other animation control uso de
    glutIdleFunc program single_double.c (1)
  • 1.6.3 Call time control uso de
    glutIdleFunc program single_double.c
    (2)
  • 1.7 Main loop control
  • 1.8 Main loop control for drawing
  • 1.9 OpenGL Primitives
  • 1.10 OpenGL State Machine (II), (III),
    (IV)
  • 1.11 Adaptation of OpenGL Examples to
    VisualStudio

to return to general index
4
Tema 2.- Lógica de transformaciones matriciales
en OpenGL
  • 2.1 Let us analyze an example
  • 2.2 continue the example
  • 2.3 Geometric Transformations The
    Pipeline
  • 2.4 Relation between the program and
    matrix notation

to return to general index
5
Tema 3.- Viewing
  • 3.1 Viewing transformation (I de II)
  • 3.2 Viewing transformation (II de II)

to return to general index
6
Tema 4.- Transformaciones del modelo
  • 4.1 Transformaciones del modelo I
  • 4.2 Transformaciones básicas I
  • 4.3 Transformaciones básicas II
  • 4.5 Shadow matrix
  • (1),(2),(3),(4),(5),(6),(7),(8),(
    9)
  • 4.6 Shadow matrix (10)Tarea 1
  • 4.7 Shadow matrix (11)Tarea 2
  • 4.8 Reflexiones y transparencias I
  • 4.9 Reflexiones y transparencias II

to return to general index
7
Tema 5.- Projection transformations
  • 5.1, Que significa "transformación de
    proyección"
  • 5. 2,Opciones para transformación de proyección
  • 5.3 Funciones de OpenGl para
  • 5.4 glFrustum()
  • 5. 5 gluPerspective()
  • 5. 6 glOrtho()

to return to general index
8
Tema 6.- Viewport 6.1 Mapping
Drawing Coordinates to Window
Coordinates 6.2 Mapping Drawing
Coordinates to Window
Coordinates (2), (3), (4)
to return to general index
9
Tema 7.- Selection
  • 7.1 Lógica general
  • 7.2 The Name Stack I y II
  • 7.3 hits and selection buffer
  • 7.4 Introducing the Name Stack
  • 7.5 functions to manipulate the Name
    Stack
  • 7.6 ejemplo de manipulación con el
    Name Stack
  • 7.7 Name Stack ejemplo del
    contenido de hit records
  • registrado en el selection
    buffer
  • 7.8. Ilustración a lógica de Selection Bufer

to return to general index
10
Tema 8.- Bitmaps
  • void glBitmap.....................................
    .......................(II),
  • Example 8-1 Drawing a Bitmapped Character
    drawf.c...........................................
    ...........................(III),
  • F as a bitmap and itscorresponding bitmap
    data......................................(IV),
  • Choosing a Color for the Bitmap...................
    ........(V)

to return to general index
11
Tema 9.- Texture Mapping
  • Contenido
  • Organigrama de uso de texturas .
    (I)
  • Steps in Texture Mapping .. (II),
  • Naming a texture object, glGenTexture()...
    (III),
  • Create a texture object and specify a
    texture for it, glBindTexture()..................
    .....................................(IV),
  • Modos de almacenamiento y las operaciones de
    transferencia.. (V),
  • Specificar textura , glTexImage2D(). (V
    I),
  • Substutute a part of texture with a sub
    texture, glTexSubImage2D
    ..(VII)
  • Ejemplo de Aplicación de Texturas .....
    (VIII)

to return to general index
12
Tema 10.- Blending
  • 10.1 Blending II official terminology
  • 10.2. glBlendFunc()
  • 10.1 Tabla de valores de argumentos de
    glBlendFunc()

to return to general index
13
Tema 12.-Light and Color
  • 12.1 glEnable(GL_LIGHTi or
    GL_LIGHTING)
  • 12.2 glEnable(GL_LIGHTING)
  • 12.3
  • 12.4

to return to general index
14
Tema 12.-Light and Color lógica está
subordinada al modelo de Phong
El modelo de Phong (en la fórmula arriba) es una
simulación computacional de leyes naturales de
generación de colores de iluminación en cada
pixel de la imagen. Modelo de iluminación en
OpenGl adapta el modelo de Phong. Y por lo tanto
la lógica de uso de iluminación en OpenGl
? la configuración de parámetros de
modelo de Phong mediante las rutinas de OpenGl
to return to general index
15
Tema 12.-Light and Color sentido de los
párametros del modelo de Phong
En el modelo de Phong (en la fórmula arriba
copiada de Wikipedia) la reflexión de una
superficie se divide en tres sub-componentes
ambiental, difusa, y speculiar (sub-indices
a, d , y s , respectivamente). Para el
cálculo de los componentes de luz difusa, y luz
speculiar, es necesario tomar en cuenta
siguientes vectores L de luz a la superficie,
N normal a la superficie, V de superficie al
mirador, R vector de reflexión del L de la
superficie. Los componentes se calculan por
separado para cada fuente de luz y luego se
suman. Letras k y i en la fórmula
corresponden a vectores que determinen las
propiedades de material de la superficie y de la
luz.
to return to general index
16
Tema 12.-Light and Color fragmento de la
máquina de OpenGl responsible de luz
to return to general index
17
Tema 12.-Light and Color specificación de
glLightModel() de OpenGl glLightModel() de OpenGl
(I)
  • NAME
  • glLightModelf, glLightModeli, glLightModelfv,
    glLightModeliv - set the lighting model
    parameters
  • C SPECIFICATION
  • void glLightModelf( GLenum pname, GLfloat param )
  • void glLightModeli( GLenum pname, GLint param )
  • PARAMETERS
  • pname Specifies a single-valued lighting model
    parameter. GL_LIGHT_MODEL_LOCAL_VIEWER and
    GL_LIGHT_MODEL_TWO_SIDE are accepted.
  • param Specifies the value that param will be set
    to.
  • C SPECIFICATION
  • void glLightModelfv( GLenum pname, const GLfloat
    params )
  • void glLightModeliv( GLenum pname, const GLint
    params )
  • PARAMETERS
  • pname Specifies a lighting model parameter.
    GL_LIGHT_MODEL_AMBIENT, GL_LIGHT_MODEL_LOCAL_VIEWE
    R, and GL_LIGHT_MODEL_TWO_SIDE are accepted.
  • params Specifies a pointer to the value or values
    that params will be set to.
  • DESCRIPTION
  • glLightModel sets the lighting model parameter.
    pname names a parameter and params gives the new
    value. There are three lighting model parameters
  • GL_LIGHT_MODEL_AMBIENT params contains four
    integer or floating-point values that specify the
    ambient RGBA intensity of the entire scene.
    Integer values are mapped linearly such that the
    most positive representable value maps to 1.0,
    and the most negative representable value maps to
    -1.0. Floating-point values are mapped directly.
    Neither integer nor floating-point values are
    clamped. The initial ambient scene intensity is
    (0.2, 0.2, 0.2, 1.0). GL_LIGHT_MODEL_LOCAL_VIEWER
    params is a single integer or floating-point
    value that specifies how specular reflection
    angles are computed. If params is 0 (or 0.0),
    specular reflection angles take the view
    direction to be parallel to and in the direction
    of the -z axis, regardless of the location of the
    vertex in eye coordinates. Otherwise, specular
    reflections are computed from the origin of the
    eye coordinate system. The initial value is 0.
    GL_LIGHT_MODEL_TWO_SIDE params is a single
    integer or floating-point value that specifies
    whether one- or two-sided lighting calculations
    are done for polygons. It has no effect on the
    lighting calculations for points, lines, or
    bitmaps. If params is 0 (or 0.0), one- sided
    lighting is specified, and only the front
    material parameters are used in the lighting
    equation. Otherwise, two-sided lighting is
    specified. In this case, vertices of back-facing
    polygons are lighted using the back material
    parameters, and have their normals reversed
    before the lighting equation is evaluated.
    Vertices of front-facing polygons are always
    lighted using the front material parameters, with
    no change to their normals. The initial value is
    0.

18
Tema 12.-Light and Color specificación de
glLightModel() de OpenGl (II)
  • In RGBA mode, the lighted color of a vertex is
    the sum of the material emission intensity, the
    product of the material ambient reflectance and
    the lighting model full-scene ambient intensity,
    and the contribution of each enabled light
    source. Each light source contributes the sum of
    three terms ambient, diffuse, and specular. The
    ambient light source contribution is the product
    of the material ambient reflectance and the
    light's ambient intensity. The diffuse light
    source contribution is the product of the
    material diffuse reflectance, the light's diffuse
    intensity, and the dot product of the vertex's
    normal with the normalized vector from the vertex
    to the light source. The specular light source
    contribution is the product of the material
    specular reflectance, the light's specular
    intensity, and the dot product of the normalized
    vertex-to- eye and vertex-to-light vectors,
    raised to the power of the shininess of the
    material. All three light source contributions
    are attenuated equally based on the distance from
    the vertex to the light source and on light
    source direction, spread exponent, and spread
    cutoff angle. All dot products are replaced with
    0 if they evaluate to a negative value. The alpha
    component of the resulting lighted color is set
    to the alpha value of the material diffuse
    reflectance.
  • ERRORS
  • GL_INVALID_ENUM is generated if pname is not an
    accepted value.
  • GL_INVALID_OPERATION is generated if glLightModel
    is executed between the execution of glBegin and
    the corresponding execution of glEnd.
  • ASSOCIATED GETS
  • glGet with argument GL_LIGHT_MODEL_AMBIENT
  • glGet with argument GL_LIGHT_MODEL_LOCAL_VIEWER
  • glGet with argument GL_LIGHT_MODEL_TWO_SIDE
  • glIsEnabled with argument GL_LIGHTING
  • SEE ALSO
  • glLight, glMaterial

19
Tema 12.-Light and Color glEnable(GL_LIGHTi
or GL_LIGHTING)
glEnable(GL_LIGHTi) / incluir la luz i en la
ecuaciòn de alumbramiento ver glLightModel y
glLight/ glEnable(GL_LIGHTING) / usar los
parametros vigentes de alumbramiento para càlculo
del color de vertice o indice Si no està
habilitado GL_LIGHTING , entonces, el color o
indice corriente se asocìa con cada vèrtice /
to return to general index
20
Tema 11.- Stencil
to return to general index
21
Tema 1.- Aspectos generales de programación de
realidad virtual en OpenGL
to return to index
22
Aspectos generales Hardware structures for
pixels on the screen
  • Framebuffermemory formed by a set of bitplanes
  • Bitplane a set of bits that has one-to-one
    correspondence to the set of the screen pixels

to return to index
23
Aspectos generales Aspects of Graphics
Programming
  • Rendering model-based image generation
  • Rendering mode
  • Retained mode
  • Immediate mode
  • Model
  • Model primitives
  • Spacing Projection, light, texture, fog
  • Real-time Graphics as events-based programming

to return to index
24
Aspectos generales Final part of the rendering
process
framebuffer
control
Interpretation
glFlush(void) glutSwapBuffers()
Image on the screen
to return to index
25
Aspectos generales Real-time Graphics as
events-based programming
  • Main loop
  • Registering a callback function
  • The user-initiated events for calling back
  • reshaping,
  • keyboard,
  • and changing mouse state

to return to index
26
Aspectos generales Call time control uso de
glutTimerFunc (1)
  • This function, glutTimerFunc, takes the name of a
    function to call and the amount of time to wait
    before calling the function
  • void glutTimerFunc(unsigned int msecs, void
    (func)(int value), int value)
  • This code sets up GLUT to wait msecs
    milliseconds before calling func. Pass a
    user-defined value in the value parameter. The
    function called by the timer has the following
    prototype
  • void TimerFunction(int value)
  • Unlike the Windows timer, this function is
    fired only once. To effect a continuous
    animation, reset the timer again in the timer
    function.

to return to index
27
Aspectos generales Call time control uso de
glutTimerFunc (2)
  • void TimerFunction(int value)
  • ......
  • glutPostRedisplay()
  • glutTimerFunc(33,TimerFunction, 1)
  • void SetupRC(void) // Setup the rendering state
  • // Set clear color to blue
  • glClearColor(0.0f, 0.0f, 1.0f, 1.0f)
  • int _tmain(int argc, _TCHAR argv)
  • glutInit(argc, (char )argv)
  • glutInitDisplayMode(GLUT_DOUBLE GLUT_RGB)
  • glutCreateWindow ((char )argv0)
  • glutDisplayFunc(RenderScene)
  • glutReshapeFunc(ChangeSize)
  • glutTimerFunc(33, TimerFunction, 1)

to return to index
28
Aspectos generales Main loop control
  • I TimerFunction
  • II SetupRC(void)
  • III glutInitDisplayMode(GLUT_DOUBLE
    GLUT_RGB)
  • IV glutCreateWindow ((char )argv0)
  • V RenderScene
  • VI ChangeSize

Configure rendering before starting the main
loop IIIII IV
Main loop
I, V
I, (V), (VI)
I, (V), (VI)
Interaction with Main loop control
I recursive request to be called at each cycle
V single request to be called at the 1st cycle
and then when needed
VI single request to be called when needed
to return to index
29
Aspectos generales Main loop control for drawing
  • void glutDisplayFunc(void (func)(void))
    Specifies the function that's called whenever the
    contents of the window need to be redrawn. The
    contents of the window may need to be redrawn
  • the window is initially opened,
  • the window is popped and window damage is
    exposed,
  • glutPostRedisplay() is explicitly called.

glutPostRedisplay() causes Main Loop control to
call display callback function for re-rendering
after other events have been processed.
void glutReshapeFunc(void (func)(int width, int
height)) Specifies the function that's called
whenever the window is resized or moved. The
argument func is a pointer to a function that
expects two arguments, the new width and height
of the window. Typically, func calls glViewport,
so that the display is clipped to the new size,
and it redefines the projection matrix so that
the aspect ratio of the projected image matches
the viewport, avoiding aspect ratio distortion.
If glutReshapeFunc isn't called or is
deregistered by passing NULL, a default reshape
function is called, which calls glViewport(0, 0,
width, height).
to return to index
30
Aspectos generales Other animation control uso
de glutIdleFunc()
  • glutIdleFunc sets the global idle callback.
  • Usage
  • void glutIdleFunc(void (func)(void))
  • func The new idle callback function.
  • Description
  • glutIdleFunc sets the global idle callback to be
    func so a GLUT program can perform background
    processing tasks or continuous animation when
    window system events are not being received. If
    enabled, the idle callback is continuously called
    when events are not being received. The callback
    routine has no parameters.
  • The current window and current menu will not be
    changed before the idle callback. Programs with
    multiple windows and/or menus should explicitly
    set the current window and/or current menu and
    not rely on its current setting.
  • The amount of computation and rendering done in
    an idle callback should be minimized to avoid
    affecting the programs interactive response. In
    general, not more than a single frame of
    rendering should be done in an idle callback.
  • Passing NULL to glutIdleFunc disables the
    generation of the idle callback.

to return to index
31
Aspectos generales Other animation control uso
de glutIdleFunc() program single_double.c de
Ed.Angel book
  • static GLfloat spin 0.0
  • int singleb, doubleb
  • void displayd(void)
  • glClear (GL_COLOR_BUFFER_BIT)
  • glRectf (-25.0, -25.0, 25.0, 25.0)
  • glutSwapBuffers ()
  • void displays(void)
  • glClear (GL_COLOR_BUFFER_BIT)
  • glRectf (-25.0, -25.0, 25.0, 25.0)
  • glFlush()
  • void spinDisplay (void)
  • spin spin 2.0
  • if (spin gt 360.0)
  • spin spin - 360.0
  • glutSetWindow(singleb)
  • glLoadIdentity()
  • glRotatef (spin, 0.0, 0.0, 1.0)
  • glutPostRedisplay()
  • glutSetWindow(doubleb)
  • glLoadIdentity()
  • glRotatef (spin, 0.0, 0.0, 1.0)
  • glutPostRedisplay()
  • void myinit (void)
  • glClearColor (0.0, 0.0, 0.0, 1.0)
  • glColor3f (1.0, 1.0, 1.0)
  • glShadeModel (GL_FLAT)
  • ? continua en la siguiente lamina

to return to index
32
Aspectos generales Other animation control uso
de glutIdleFunc()
  • ?continuación
  • void mouse(int btn, int state, int x, int y)
  • if(btnGLUT_LEFT_BUTTON stateGLUT_DOWN)
    glutIdleFunc(spinDisplay)
  • if(btnGLUT_MIDDLE_BUTTON stateGLUT_DOWN)
    glutIdleFunc(NULL)
  • void myReshape(int w, int h)
  • glViewport(0, 0, w, h)
  • glMatrixMode(GL_PROJECTION)
  • glLoadIdentity()
  • if (w lt h) glOrtho (-50.0, 50.0,
    -50.0(GLfloat)h/(GLfloat)w,
  • 50.0(GLfloat)h/(GLfloat)w, -1.0, 1.0)
  • else glOrtho (-50.0(GLfloat)w/(GLfloat)h,
  • 50.0(GLfloat)w/(GLfloat)h, -50.0, 50.0,
    -1.0, 1.0)
  • glMatrixMode(GL_MODELVIEW)
  • glLoadIdentity ()
  • / Main Loop Open window with initial window
    size, title bar, RGBA display mode, and handle
    input events. /
  • int main(int argc, char argv)
  • glutInit(argc,argv)
  • glutInitDisplayMode (GLUT_SINGLE GLUT_RGB)
  • singlebglutCreateWindow("single buffered")
  • myinit ()
  • glutDisplayFunc(displays)
  • glutReshapeFunc (myReshape)
  • glutIdleFunc (spinDisplay)
  • glutMouseFunc (mouse)
  • glutInitDisplayMode (GLUT_DOUBLE GLUT_RGB)
  • doublebglutCreateWindow("double buffered")
  • myinit ()
  • glutDisplayFunc(displayd)
  • glutReshapeFunc (myReshape)
  • glutIdleFunc (spinDisplay)
  • glutMouseFunc (mouse)
  • glutMainLoop()

to return to index
33
Aspectos generales OpenGL Primitives
back
The VertexA Position in Space A vertex a
coordinate in 2D or 3D space. The geometric
definition of a vertex is not just a point in
space, but rather the point at which an
intersection of two lines or curves occurs. This
is the essence of primitives. In both 2D and
3D, when you draw an object, you actually compose
it with several smaller shapes called primitives.
A primitive is simply the interpretation of a
set or list of vertices into some shape drawn on
the screen. There are 10 primitives in OpenGL,
from a simple point drawn in space to a closed
polygon of any number of sides. Primitives are
one- or two-dimensional entities or surfaces such
as points, lines, and polygons (a flat,
multisided shape) that are assembled in 3D space
to create 3D objects. For example, a
three-dimensional cube consists of six
two-dimensional squares, each placed on a
separate face. Each corner of the square (or of
any primitive) is represented by a vertex.
to return to index
34
Aspectos generales OpenGL State Machine
back
Drawing 3D graphics is a complicated affair. For
a given piece of geometry, many things can affect
how it is drawn. Is a light shining on it? What
are the properties of the light? What are the
properties of the material? Which, if any,
texture should be applied? The list could go on
and on. We call this collection of variables the
state of the pipeline. A state machine is an
abstract model of a collection of state
variables, all of which can have various values,
be turned on or off, and so on. When a state
value is set, it remains set until some other
function changes it. Many states are simply on
or off. Lighting, for example, is either turned
on or off. Geometry drawn without lighting is
drawn without any lighting calculations being
applied to the colors set for the geometry. Any
geometry drawn after lighting is turned back on
is then drawn with the lighting calculations
applied.
to return to index
35
Aspectos generales OpenGL State Machine (II)
back
To turn these types of state variables on and
off, you use void glEnable(GLenum capability)
You turn the variable back off with the
corresponding function void glDisable(GLenum
capability) For the case of lighting, for
instance, you can turn it on by using the
following glEnable(GL_LIGHTING) And you turn
it back off with this functionglDisable(GL_LIGHT
ING) To test a state variable to see whether
it is enabled, use Glboolean glIsEnabled(GLenum
capability)
to return to index
36
Aspectos generales OpenGL State Machine (III)
back
Not all state variables, however, are simply on
or off. Many of the OpenGL functions set up
values that "stick" until changed. You can query
what these values are at any time. These four
query functions are prototyped thus void
glGetBooleanv(GLenum pname, GLboolean params)
void glGetDoublev(GLenum pname, GLdouble
params) void glGetFloatv(GLenum pname, GLfloat
params) void glGetIntegerv(GLenum pname, GLint
params) Each function returns a single value
or a whole array of values, storing the results
at the address you supply.
to return to index
37
Aspectos generales OpenGL State Machine
(IV)Saving and Restoring States
back
OpenGL also has a convenient mechanism for saving
a whole range of state values and restoring them
later. A single OpenGL state value or a whole
range of related state values can be pushed on
the attribute stack with the following
command void glPushAttrib(GLbitfield mask)
Values are correspondingly retrieved with this
command void glPopAttrib(GLbitfield mask)
The argument to these functions is a bitfield.
This means that you use a bitwise mask, which
allows you to perform a bitwise OR (in C using
the operator) of multiple state values with a
single function call. For example, you could save
the lighting and texturing state with a single
call like this glPushAttrib(GL_TEXTURE_BIT
GL_LIGHTING_BIT)
to return to index
38
Aspectos generales Adaptation of OpenGL Examples
to VisualStudio back
  • What to do
  • Put headers into a proper directory
  • Put libraries into a proper directory
  • Choose "consol application" as configuration for
    VisualStudio project
  • Correct the source code of an example

to return to index
39
Tema 2 Lógica de transformaciones matriciales en
OpenGL back
to return to index
40
Logics of the matrix transformation (I de
IV)Let us analyze an example back
Only the model of an object is transformed below
the view and projection stay out of the scope of
the program void display(void) glClear(GL_COLOR
_BUFFER_BIT) // save current matrix in the
stack and duplicate it at once glPushMatrix()
//multiply current matrix with matrix of rotation
around Z-axis glRotatef(spin, 0.0, 0.0,
1.0) // apply the obtained current matrix to a
fixed white rectangle glColor3f(1.0, 1.0,
1.0) glRectf(-25.0, -25.0, 25.0,
25.0) //restore current matrix
glPopMatrix() //swap framebuffers and display
scene glutSwapBuffers()
to return to index
41
Logics of the matrix transformation (II de IV)
continue the example back
void reshape(int w, int h) //modify
viewport glViewport (0, 0, (GLsizei) w,
(GLsizei) h) //apply subsequent matrix
operation to the projection matrix
stack glMatrixMode(GL_PROJECTION) glLoadIdentity(
) // transform the current matrix by setting
// (explicitly) a volume for orthographic
projection and // (implicitly) the matrix of the
default viewpoint glOrtho(-50.0, 50.0, -50.0,
50.0, -1.0, 1.0) // apply subsequent matrix
operation to the modelview matrix
stack glMatrixMode(GL_MODELVIEW) glLoadIdentity()

to return to index
42
Logics of the matrix transformation (III de IV)
back
Geometric Transformations The Pipeline
Organizing the transformations as pipeline means
that projection and modelview matrices co-exist
in parallel mode. Changing matrixmode from
modelview to projection and vice versa in your
program does not erase actual modelview or
projection matrix. OpenGL multiplies
automatically vectors represented in transformed
eye coordinates by the projection matrix.
to return to index
43
Logics of the matrix transformation (IV de IV)
Relation between the program and matrix notation
back
Consider the following code sequence glMatrixMo
de(GL_MODELVIEW) glLoadIdentity() glMultMatrixf(
N) / apply transformation N / glMultMatrixf(M)
/ apply transformation M / glMultMatrixf(L)
/ apply transformation L / glBegin(GL_POINTS)
glVertex3f(v) / draw transformed vertex v
/ glEnd() The transformed vertex is NMLv
N(M(Lv))
to return to index
44
3.- Viewing
to return to index
back
45
Viewing transformation (I de II)
  • As a part of modelview transformation, the
    viewing transformation is specified with
    gluLookAt().
  • If gluLookAt() was not called, the camera has a
    default position and orientation. By default, the
    camera is situated at the origin, points down the
    negative z-axis, and has an up-vector of (0, 1,
    0).

to return to index
back
46
Viewing transformation (II de II)
  • void gluLookAt(GLdouble eyex, GLdouble eyey,
    GLdouble eyez, GLdouble centerx, GLdouble
    centery, GLdouble centerz, GLdouble upx, GLdouble
    upy, GLdouble upz)
  • Defines a viewing matrix and multiplies it to the
    right of the current matrix. The desired
    viewpoint is specified by eyex, eyey, and eyez.
    The centerx, centery, and centerz arguments
    specify any point along the desired line of
    sight, but typically they're some point in the
    center of the scene being looked at. The upx,
    upy, and upz arguments indicate which direction
    is up (that is, the direction from the bottom to
    the top of the viewing volume).
  • In the default position (see previous slide), the
    camera is at the origin, is looking down the
    negative z-axis, and has the positive y-axis as
    straight up. This is the same as calling
  • gluLookat (0.0, 0.0, 0.0, 0.0, 0.0, -100.0, 0.0,
    1.0, 0.0)

to return to index
back
47
4.-Transformaciones del modelo
back
to return to index
48
Transformaciones del modelo I
  • Las transformaciones del modelo se pueden dividir
    en las básicas y las derivadas
  • Las básicas incluyen
  • Cualquier combinación de la Traslación, la
    rotación y escalamiento, o multiplicación por una
    dada matriz 4x4
  • Las derivadas son aquellas que se usan para
    efectos especiales tales como sombra, espejo,
    selección,

back
to return to index
49
Transformaciones básicas I
  • Translate
  • void glTranslatefd(TYPEx, TYPE y, TYPEz)
  • Multiplies the current matrix by a matrix that
    moves (translates) an object by the given x, y,
    and z values (or moves the local coordinate
    system by the same amounts).
  • Rotate
  • void glRotatefd(TYPE angle, TYPE x, TYPE y,
    TYPE z)
  • Multiplies the current matrix by a matrix that
    rotates an object (or the local coordinate
    system) in a counterclockwise direction about the
    ray from the origin through the point (x, y, z).
    The angle parameter specifies the angle of
    rotation in degrees.
  • Scale
  • void glScalefd(TYPEx, TYPE y, TYPEz)
  • Multiplies the current matrix by a matrix that
    stretches, shrinks, or reflects an object along
    the axes. Each x, y, and z coordinate of every
    point in the object is multiplied by the
    corresponding argument x, y, or z. With the local
    coordinate system approach, the local coordinate
    axes are stretched, shrunk, or reflected by the
    x, y, and z factors, and the associated object is
    transformed with them.

back
to return to index
50
Transformaciones básicas II
  • void glLoadMatrixfd(const TYPE m) Sets the
    sixteen values of the current matrix to those
    specified by m.
  • void glMultMatrixfd(const TYPE m)
    Multiplies the matrix specified by the sixteen
    values pointed to by m by the current matrix and
    stores the result as the current matrix.
  • The argument for both these commands is a vector
    of sixteen values (m1, m2, ... , m16) that
    specifies a matrix M as follows
  • Note All matrix multiplication with OpenGL
    occurs as follows Suppose the current matrix is
    C and the matrix specified with glMultMatrix()
    or any of the transformation commands is M. After
    multiplication, the final matrix is always CM.
  • Tarea leer "Advanced Matrix Manipulation ",
    Chapter 4. Geometric Transformations The
    Pipeline, OpenGL SuperBible

back
to return to index
51
Shadow matrix (1)
  • La matrix de sombra es una especie de la
    transformation "modelview"
  • Dada L como vector de la posición de la
    fuente de luz, un plano, y un punto s en espacio,
    la sombra del punto al plano se representa como
    sr(s-L) donde el parametro r se busca de la
    condicion que sr(s-L) pertenece al plano en
    cuestion.
  • Elijamos la representación del plano mediante
    la cuádruple a, b, c, d, donde na, b, c es
    un vector ortonormal al plano y d es el
    desplazamiento del plano desde el origen del
    sistema de coordenadas a lo largo del eje
    generado por n).
  • Obviamente, el vector (x,y,z) pertenece al
    plano si y solo si se cumple la ecuación
  • axbyczd0.

back
to return to index
52
Shadow matrix (2)
  • La ecuacion anterior implica
  • a(sxr(sx- Lx))b(syr(sy- Ly))c(szr(sz-
    Lz))d0
  • De donde se tiene


  • ()

back
to return to index
53
Shadow matrix (3)
  • En otras palabras, para cada s del espacio se ha
    encontrado el mapeo

  • ()
  • donde r es el valor de () de la diapositiva
    anterior.

back
to return to index
54
Shadow matrix (4)
  • La última parte de la búsqueda de la matriz de
    sombra ("shadow matrix") usa las dependencias
    mencionadas para encontrar los elementos de tal
    matrix Msombra, que el mapeo del () se
    representa como
  • ssombra Msombra s

back
to return to index
55
Shadow matrix (5)
  • Los elementos de la matriz de sombra tienen una
    flexibilidad para la definicion de sus
    coeficientes, basada en la equivalencia

  • Re-escribimos ()

  • ()

back
to return to index
56
Shadow matrix (6)
  • Multiplicamos todos componentes del vector en
    () por
  • (estamos usando la equivalencia antemencionada).
    Se tiene
  • Desarrollando las últimas expresiones, se tiene

back
to return to index
57
Shadow matrix (7)

back
to return to index
58
Shadow matrix (8)
  • Comparándolo con

back
to return to index
59
Shadow matrix (9)
  • Finalmente, se tiene
  • Tarea Comparen cada elemento de la M con los
    elementos correspondientes del siguiente código
    de la "Superbiblia"

back
to return to index
60
Shadow matrix (10)(tarea)
  • void gltMakeShadowMatrix(GLfloat
    vPlaneEquation, GLfloat vLightPos, GLfloat
    destMat)
  • GLfloat dot
  • // Dot product of plane and light position
  • dot vPlaneEquation0vLightPos0
    vPlaneEquation1vLightPos1
  • vPlaneEquation2vLightPos2
    vPlaneEquation3vLightPos3
  • // Now do the projection
  • // First column
  • destMat0 dot - vLightPos0
    vPlaneEquation0
  • destMat4 0.0f - vLightPos0
    vPlaneEquation1
  • destMat8 0.0f - vLightPos0
    vPlaneEquation2
  • destMat12 0.0f - vLightPos0
    vPlaneEquation3
  • // Second column
  • destMat1 0.0f - vLightPos1
    vPlaneEquation0
  • destMat5 dot - vLightPos1
    vPlaneEquation1
  • destMat9 0.0f - vLightPos1
    vPlaneEquation2

back
to return to index
61
Shadow matrix (11). Tarea 2
  • En que orden hay que construir los siguientes
    componentes de la imagen?
  • Piso
  • Objeto
  • Sombra del objeto en el piso

back
to return to index
62
Reflexiones y transparencias I
  • Componentes del modelo son
  • Piso
  • Fuente de luz
  • Objeto
  • Los mecanismos involucrados
  • Ecritura normal al framebuffer (borrando el
    contenido anterior)
  • Escritura mediante blending (mezclando el nuevo
    contenido con lo anterior)
  • Lógica de reflexión
  • Reflejar mundo (luz y objeto) respecto el piso
  • Dibujar el mundo reflejado
  • Habilitar GL_ BLEND
  • Dibujar el piso, mezclándolo (BLENDING) con el
    contenido actual del framebuffer
  • Deshabilitar GL_ BLEND
  • Restaurar el mundo
  • Dibujar el mundo

back
to return to index
63
Reflexiones y transparencias II
  • glPushMatrix()
    // recordar la matriz actual
  • PushLightStack() //
    recordar la posicion de luz actual
  • fLightMirr()
    // invertir posición de la fuente de luz respecto
    el piso
  • glFrontFace(GL_CW) // cambiar
    orientacion de poligonos para invertir los lados
    delanteros y traseros
  • glPushMatrix() //
    recordar la matriz actual
  • / dibujar mundo invertido /
  • glScalef(1.0f, -1.0f, 1.0f)
  • glTranslatef(0.0f, 2.0fyground, 0.0f)
  • Draw_Objects_Color()
  • / restaurar el mundo normal/
  • glPopMatrix() //restaurar
    matriz
  • glFrontFace(GL_CCW) //
    restaurar orientación
  • PopLightStack()
    //restaurar posición de luz
  • // Dibujar el piso transparente sobre el mundo
    reflejado
  • glDisable(GL_LIGHTING)

  • glEnable(GL_BLEND)
  • glBlendFunc(GL_SRC_ALPHA,
    GL_ONE_MINUS_SRC_ALPHA)
  • DrawGround()
  • // desabilitar transparencia

back
to return to index
64
5.- Proj. Transf. I que significa
to return to index
back
65
Projection Transformations II
  • Hay dos opciones
  • Proyección ortográfica
  • Proyeccion de perspectiva
  • Los parámetros para los programas de control de
    la proyeccián se indican en los terminos de la
    cámara.Es decir,
  • la 3a coordenada se dirige hacia la cámara
  • La 2a hacia el vector de la proyeccián del vector
    "up" (como aquél de gluLookAt()) por el plano
    ortogonal al eje de la 3a coordenada
  • La 1a es orientada hacia el vector del producto
    cruz de los vectores pertenecientes a los ejes de
    la 2a y la 3a

back
to return to index
66
Projection Transformations III
  • glMatrixMode(GL_PROJECTION)
  • glLoadIdentity()
  • luego siguen opcionalmente
  • glFrustum() //1a opción de la proyección
    perspectiva
  • gluPerspective() //2a opción de la proyección
    perspectiva
  • glOrtho() // proyección
    ortográfica

back
to return to index
67
6.-Viewport
to return to index
back
68
Viewports Mapping Drawing Coordinates to Window
Coordinates
back
to return to index
69
Viewports Mapping Drawing Coordinates to Window
Coordinates (2)
The Viewport Transformation Together, the
projection transformation and the viewport
transformation determine how a scene gets mapped
onto the computer screen. The projection
transformation specifies the mechanics of how the
mapping should occur, and the viewport indicates
the shape of the available screen area into which
the scene is mapped. Since the viewport specifies
the region the image occupies on the computer
screen, you can think of the viewport
transformation as defining the size and location
of the final processed photograph - for example,
whether the photograph should be enlarged or
shrunk. The arguments to glViewport() describe
the origin of the available screen space within
the window - (0,0) in this example - and the
width and height of the available screen area,
all measured in pixels on the screen. This is why
this command needs to be called within reshape()
- if the window changes size, the viewport needs
to change accordingly. Note that the width and
height are specified using the actual width and
height of the window often, you want to specify
the viewport this way rather than giving an
absolute size.
back
to return to index
70
Viewports Mapping Drawing Coordinates to Window
Coordinates (3)
void glViewport(GLint x, GLint y, GLsizei width,
GLsizei height) Defines a pixel rectangle in the
window into which the final image is mapped. The
(x, y) parameter specifies the lower-left corner
of the viewport, and width and height are the
size of the viewport rectangle. By default, the
initial viewport values are (0, 0, winWidth,
winHeight), where winWidth and winHeight are the
size of the window.
back
to return to index
71
Viewports Mapping Drawing Coordinates(4)
Reshape Callback Function to draw into 2D system
To create a simple, basic two-dimensional
coordinate system into which you can draw a few
objects, call glutReshapeFunc(reshape), where
reshape() is the following function (Reshape
Callback Function) void reshape (int w, int
h) glViewport (0, 0, (GLsizei) w, (GLsizei)
h) glMatrixMode (GL_PROJECTION) glLoadIdentity
() gluOrtho2D (0.0, (GLdouble) w, 0.0,
(GLdouble) h) The internals of GLUT will pass
this function two arguments the width and
height, in pixels, of the new, moved, or resized
window. glViewport() adjusts the pixel rectangle
for drawing to be the entire new window. The next
three routines adjust the coordinate system for
drawing so that the lower-left corner is (0, 0),
and the upper-right corner is (w, h).
back
to return to index
72
7.- Selection Lógica general
  • Re-dibujar virtualmente la imagen, asignando como
    viewport una region pequena alrededor del cursor

Entrar al modo de seleccion (GL_SELECT)
Asignar una estructura para selection buffer (SB)
Mouse click
"Bautizar" unos primitivos y dibujarlos
virtualmente contando los "hits" y registrando
los resultados en un buffer temporal (BT)
Analizar e interpretar los registros de los
"hits" en SB
OpenGl escribir al SB la informacion del BT
sobre los "hits"
Regresar al modo normal (GL_RENDER)
to return to index
back
73
Selection The Name Stack I
  • The OpenGL API provides a mechanism for picking
    objects in a 3D scene. It allows to detect which
    objects are bellow the mouse or in a square
    region of the OpenGL window. The steps involved
    in detecting are
  • 1. Get the window coordinates of the mouse
  • 2. Enter selection mode
  • 3. Redefine the viewing volume so that only a
    small area of the window around the cursor is
    rendered
  • 4. Render the scene, either using all primitives
    or only those relevant to the picking operation
  • 5. Exit selection mode and identify the objects
    which were rendered on that small part of the
    screen.

back
to return to index
74
Selection The Name Stack II
  • In order to identify the rendered objects using
    the OpenGL API you must name all relevant objects
    in your scene. The OpenGL API allows you to give
    names to primitives, or sets of primitives
    (objects). When in selection mode, a special
    rendering mode provided by the OpenGL API, no
    objects are actually rendered in the framebuffer.
    Instead the names of the objects (plus depth
    information) are collected in an array. For
    unnamed objects, only depth information is
    collected.

back
to return to index
75
Selection hits and selection buffer
  • Terminology
  • a hit occurs whenever a primitive is rendered
    in selection mode. REGRESAR a "logica de
    Selection"
  • Hit records are stored in the selection buffer.
  • Functionality
  • Upon exiting the selection mode OpenGL returns
    the selection buffer with the set of hit records.
  • Since OpenGL provides depth information for
    each hit the application can then easily detect
    which object is closer to the user.

back
to return to index
76
7.8. Ilustración a lógica de construcción de
Selection Bufer
Hay nombre(s) en name stack?
Si un primitivo se dibuja anónimo, busque z-min
y z-max de todos sus vertices para escribirlos en
hit record anónimo
GL_SELECT
Dibujando un primitivo
Cuantos son?
El primitivo cruza el volumen de vista?
Si un primitivo se dibuja cuando hay uno o mas
nombres en name stack, incierta al registro el
número total de los nombres luego cada de los
nombres del hit y, finalmente, z-min y z-max de
todos los vértices relacionados a los primitivos
de "hits"
min max min
max
back
to return to index
77
Selection Introducing the Name Stack
  • As the title suggests, the names you assign to
    objects are stored in a stack. Actually you don't
    give names to objects, as in a text string.
    Instead you number objects. Nevertheless, the
    term name is used in OpenGL instead of number.
  • When an object is rendered, if it intersects the
    new viewing volume, a hit record is created. The
    hit record contains the names currently on the
    name stack plus the minimum and maximum depth for
    the object.
  • Note A hit record is created even if the name
    stack is empty, in which case it only contains
    depth information. If more objects are rendered
    before the name stack is altered or the
    application leaves the selection mode, then the
    depth values stored on the hit record are altered
    accordingly.
  • A hit record is stored on the selection buffer
    only when
  • the current contents of the name stack are
    altered
  • or when the application leaves the selection
    mode.
  • The rendering function for the selection mode
    therefore is responsible for the contents of the
    name stack as well as the rendering of
    primitives.

back
to return to index
78
Selection functions to manipulate the Name Stack
  • void glInitNames(void) This function
    creates an empty name stack. You are required to
    call this function to initialize the stack prior
    to pushing names. void glPushName(GLuint name)
    Adds name to the top of the stack. The stacks
    maximum dimension is implementation dependent,
    however according to the specs it must contain at
    least 64 names which should prove to be more than
    enough for the vast majority of applications.
    Nevertheless if you want to be sure you may query
    the state variable GL_NAME_STACK_DEPTH (use
    glGetIntegerv (GL_NAME_STACK_DEPTH)). Pushing
    values onto the stack beyond its capacity causes
    an overflow error GL_STACK_OVERFLOW. void
    glPopName() Removes the name from top of the
    stack. Popping a value from an empty stack causes
    an underflow, error GL_STACK_UNDERFLOW. void
    glLoadName(GLunit name) This function replaces
    the top of the stack with name. It is the same as
    calling glPopName()
  • glPushName(name)
  • Note Calls to the above functions are ignored
    when not in selection mode. This means that you
    may have a single rendering function with all the
    name stack functions inside it. When in the
    normal rendering mode the functions are ignored
    and when in selection mode the hit records will
    be collected.
  • Note You can't place these functions inside a
    glBegin glEnd construction, which is kind of
    annoying since that will require a new rendering
    function for the selection mode in some cases.

back
to return to index
79
Selection un ejemplo de manipulación con el
Name Stack
  • define BODY 1
  • define HEAD 2
  • ...
  • void renderInSelectionMode()
  • glInitNames() / create an empty stack. This
    is required before any
  • other operation on the stack
    such as Load, Push or Pop. /
  • glPushName(BODY) /A name is pushed onto the
    stack. The stack

  • now contains a single name. /
  • drawBody() / draw something. If any of the
    primitives called in here intersects the viewing
    volume a hit record is created. The contents of
    the hit record will be the name currently on the
    name stack, BODY, plus the minimum and maximum
    depth values for those primitives that intersect
    the viewing volume /
  • glPopName() /Removes the name of the top of
    the stack. Since the stack had a single item, it
    will now be empty. The name stack has been
    altered so if a hit record was created in 2 it
    will be saved in the selection buffer /
  • glPushName(HEAD) /A name is pushed onto the
    stack. The stack now contains a single name
    again. The stack has been altered, but there is
    no hit record so nothing goes into the selection
    buffer /
  • drawHead() /Another function that renders
    OpenGL primitives. Again if any of the primitives
    intersects the viewing volume a hit record is
    created /
  • drawEyes() /Yet another function which
    renders OpenGL primitives. If any of the
    primitives in here intersects the viewing volume
    and a hit record already exists from 6, the hit
    record is updated accordingly. The names
    currently in the hit record are kept, but if any
    of the primitives in drawEyes() has a smaller
    minimum, or a larger maximum depth, then these
    new values are stored in the hit record. If the
    primitives in drawEyes() do intersect the viewing
    volume but there was no hit record from drawHead
    then a new one is created. /
  • glPopName() /The name on the top of the
    stack is removed. Since the stack had a single
    name the stack is now empty. Again the stack has
    been altered so if a hit record was created it
    will be stored in the selection buffer /
  • drawGround() /If any if the primitives
    called in here intersects the viewing volume a
    hit record is created. The stack is empty, so no
    names will be stored in the hit record, only
    depth information. If no alteration to the name
    stack occurs after this point, then the hit
    record created will only be stored in the
    selection buffer when the application leaves the
    selection mode. This will be covered later on the
    tutorial. /

back
to return to index
80
Selection Name Stack ejemplo del contenido de
hit records registrado en el selection buffer
back
to return to index
81
8.- Bitmaps back
A bitmap is a rectangular array of 0s and 1s
that serves as a drawing mask for a corresponding
rectangular portion of the window. Suppose
you're drawing a bitmap and that the current
raster color is red -- Wherever there's a 1 in
the bitmap, the corresponding pixel is replaced
by a red pixel (or combined with a red pixel,
depending on which per-fragment operations are in
effect. -- If there's a 0 in the bitmap, the
contents of the pixel are unaffected. The most
common use of bitmaps is for drawing characters
on the screen.
to return to index
back
82
Bitmaps(II) void glBitmap()
  • Once you've set the desired raster position, you
    can use the glBitmap() command to draw the data.
  • void glBitmap(GLsizei width, GLsizei height,
    GLfloat xbo, GLfloat ybo, GLfloat xbi, GLfloat
    ybi, const GLubyte bitmap)
  • Draws the bitmap specified by bitmap, which is a
    pointer to the bitmap image. The origin of the
    bitmap is placed at the current raster position.
    If the current raster position is invalid,
    nothing is drawn, and the raster position remains
    invalid. The width and height arguments indicate
    the width and height, in pixels, of the bitmap.
    The width need not be a multiple of 8, although
    the data is stored in unsigned characters of 8
    bits each. (In the F example, it wouldn't matter
    if there were garbage bits in the data beyond the
    tenth bit since glBitmap() was called with a
    width of 10, only 10 bits of the row are
    rendered.) Use xbo and ybo to define the origin
    of the bitmap (positive values move the origin up
    and to the right of the raster position negative
    values move it down and to the left) xbi and ybi
    indicate the x and y increments that are added to
    the raster position after the bitmap is
    rasterized (see Figure 8-2).
  • Figure 8-2 Bitmap and Its Associated Parameters

back
to return to index
83
Bitmaps(III) Example 8-1 Drawing a Bitmapped
Character drawf.c back
include GLubyte rasters24 0xc0, 0x00,
0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0,
0x00, 0xff, 0x00, 0xff, 0x00, 0xc0, 0x00, 0xc0,
0x00, 0xc0, 0x00, 0xff, 0xc0, 0xff, 0xc0 void
init(void) glPixelStorei (GL_UNPACK_ALIGNMENT,
1) / Sets the
pixel-storage mode,
GL_UNPACK_ALIGNMENT Specifies the alignment
requirements for the start of each pixel row in
memory. The
allowable values are 1 (byte-alignment), 2 (rows
aligned to even-numbered bytes), 4 (word
alignment), and 8 (rows
start on double-word boundaries). Es decir, si,
p.e., el ancho de la fila es 10, y por lo tanto,
el 2o byte es incompleto,
para evitar cualquier duda, asignamos "
GL_UNPACK_ALIGNMENT 1" para
decir al OpenGl que la siguiente fila
inicia desde el proximo byte inmediato despues
del byte incompleto, see more
details in Discusion_sobre_alignment.doc
/ glClearColor (0.0, 0.0, 0.0, 0.0) void
display(void) glClear(GL_COLOR_BUFFER_BIT) glCol
or3f (1.0, 1.0, 1.0) glRasterPos2i (20, 20)
//The command glRasterPos() position //a
single bitmap on the screen. //
draw the character F three times on the
screen. glBitmap (10, 12, 0.0, 0.0, 11.0, 0.0,
rasters) // glBitmap() draw a single bitmap on
the screen glBitmap (10, 12, 0.0, 0.0, 11.0,
0.0, rasters) glBitmap (10, 12, 0.0, 0.0, 11.0,
0.0, rasters) glFlush()
back
to return to index
84
Bitmaps(IV) Figure 8-1 shows the F as a bitmap
and itscorresponding bitmap data.back
Figure 8-1
back
to return to index
85
Bitmaps(V) Choosing a Color for the Bitmap.back
The same glColor() and glIndex() commands are
used to set different state variables,
GL_CURRENT_RASTER_COLOR and GL_CURRENT_RASTER_IN
DEX, for rendering bitmaps. The raster color
state variables are set when glRasterPos()
is called, which can lead to a trap. In the
following sequence of code, the color of the
bitmap is white! glColor3f(1.0, 1.0, 1.0) /
white / glRasterPos3fv(position) glColor3f(1.0,
0.0, 0.0) / red / glBitmap(....) GL_CURRENT_R
ASTER_COLOR is set to white when glRasterPos3fv()
is called. The second call to glColor3f() changes
the value of GL_CURRENT_COLOR for future
geometric rendering, but the color used to render
the bitmap is unchanged.
back
to return to index
86
9.- Texture Mappingback
  • There are many possibilities for texture mapping
  • map textures to surfaces made of a set of
    polygons or to
  • curved surfaces,
  • repeat a texture in one or both directions to
    cover the surface.
  • A texture can even be one-dimensional.
  • automatically map a texture onto an object in
    such a way that the texture indicates contours or
    other properties of the item being viewed.
  • Shiny objects can be textured so that they
    appear to be in the
  • center of a room or other environment, reflecting
    the surroundings off their surfaces.
  • A texture can be applied to a surface in
    different ways
  • painted on directly (like a decal placed on a
    surface),
  • used to modulate the color the surface would
    have been painted otherwise,
  • or used to blend a texture color with the
    surface color.

to return to index
back
87
9.1.- Organigrama de uso de texturasback
Atar un nombre de textura con un objetivo
(target). Hay 3 opciones para objetivos de
dimensión 1, 2, o 3. En cada instante con cada de
los tres puede ser atada una sola textura. Al
atar otra con el mismo objetivo, se cancela el
atamiento anterior.
Configurar Target como el mapeo de un objerto de
Texture Memory a la pantalla
Determinar el mapeo de textura a un primitivo de
OpenGl
Specificar textura definir la relación (mapeo)
entre una estructura de datos en Processor Memory
y su interpretación en Texture Memory
Configurar entorno de aplicación de textura
Generar nombres para texturas
Sentido funcional
glBindTextures()
glGenTextures()
glTexImage()
glTexParameter()
glTexEnv()
Soporte mediante las Funciones OpenGL
glTexCoord()
Target GL_TEXTURE_1D GL_TEXTURE_2D
GL_TEXTURE_3D
El modo como se interactuan los colores de
engomado (la textura) con los colores del objeto
al cual lo pegamos
Nombre de textura valor entero
Contenido de Texture Memory
estructura de datos en Processor Memory
Objetos que se definen
Primitivo de OpenGL
to return to index
back
88
Texture Mapping (II)back
  • Steps in Texture Mapping
  • To use texture mapping, you perform these steps.
  • Create a texture object and specify a texture for
    that object.
  • 2. Indicate how the texture is to be applied to
    each pixel.
  • 3. Enable texture mapping.
  • 4. Draw the scene, supplying both texture and
    geometric coordinates.

back
to return to index
89
Texture Mapping (III)(Naming a texture object )
back
Naming A Texture Object Any nonzero unsigned
integer may be used as a texture name. To avoid
accident
Write a Comment
User Comments (0)
About PowerShow.com