Carlos Andújar <andujar@lsi.upc.edu>                Alvar Vinaqua

Alejandro <abeacco@lsi.upc.edu>


TEMA 2

Visualització realista de superfícies:

El color que l’observador veu en un determinat punt P és el color que “surt” de P en direcció a l’observador, si suposem que el medi de transmissió no és participatiu (no hi ha boira, etc).

Model de llum:


TEMA 3: Procés de visualització

Sistemes de coordenades

Coordenades homogènies

Tenim les coordenades del model (x, y, z, w) expressades en model space (també anomenat object space). El primer que fem és passar-les a coordenades (x’, y’, z’, w’) en world space (coordenades d’aplicació).

D’aquí les pasarem a coordenades d’observador. En OpenGL, la matriu Model View duu a terme les dues transformacions (de model a món i de món a ull).

Aquí és on es fa el calcul de l’iŀluminació, etc. Finalment, es fa una projecció a coordenades de clipping i finalment amb una homogenització s’obté les coordenades normalitzades de dispositiu.

Un cop fet tot això el resultat va a parar al rasteritzador, on s’obté fragments (píxels candidats) amb coordenades de dispositiu.


TEMA 4: Textures

Una textura està formada per texels (com píxels). Un texel pot representar propietats:

Espai (normalitzat) de textura: les coordenades de l’imatge van de (0, 0) a l’extrem inferior esquerra a (1, 1) a l’extrem superior dret.

Mapping:

La tècnica de mapping que utilitza OpenGL associa a cada vèrtex unes coordenades de textura (s, t). Es pot fer en temps de modelat o de visualització (generació automàtica de textura). Per a cada fragment s’interpola les coordenadees de textura i s’obté el color del texel corresponent a (s, t) utilitzant un filtrat de la textura.

Associació de vèrtex i coordenades de textura:

Manualment:

glNormal3f(nx, ny, nz);

glTexCoord2f(s, t);

glVertex3f(x, y, z);

Automàticament:

glTextGen:

Wrapping:

Un cop tenim les coordenades de textura (s, t) amb valors al rang [0, 1], aquestes corresponen al centre del pixel.

Filtres:

Combinar el color del fragment i el color de la textura

Generació de coordenades de textura

  1. Punts de la superfície a texturar (object space) - (xm, ym, zm)
  2. Punts de la superficie intermèdia (esfera / cilindre / torus / pla) - (xi, yi zi)
  3. Coordenades de textura (s, t)

Exemple S-mapping esfèric

         

Exemple O-mapping:

Projective Texture Mapping

(xm, ym, zm)        → model transformation → (xa, ya, za)

→ viewing projection (xc, yc, zc) →

→ div. perspectiva /viewport transf. (origen (0, 0) (w, h)=(1,1)) →

→ (xw, yw, zw) on xw=s i yw=t

Tècnica

Variació color en una sup. suau

Variació llum sup. rugosa

Motion parallax

Self occlusion

Detalls en la silueta

Info per texel

Indicat per a ...

Basat en

Color mapping

No

No

No

No

Color

Sup. suau

FS (Fragment Shader)

Bump mapping

No *

No

No

No

Height

Sup. rugoses (petites)

FS

Parallax mapping

No

No

No

Color

Height

Sup. rugoses (mitjanes)

FS

Relief mapping

Color

Normal

Height

“ “

FS

Displacement mapping

No *

Height

“ “

GS

FS

Bump mapping

Simular variació de la iŀluminació en superfícies rugoses.

Aplicació → dibuixa la geometria base

Shaders → calculen la iŀluminació per fragment, amb una normal perturbada N’

N’ es calcula com en un height field desplaçant la superfície P en direcció a la normal.

[Veure apunts Roger: «Tema 4 Textures».]

En espai tangent:

N’t = (-dF/du,  -dF/dv, 1)

...


TEMA 5: Interacció amb escenes 3D

Introducció

Elements a seleccionar:

Selecció:

Regió selecció:

Etapes:

Inclou en la selecció:

Tècniques:

Mode de selecció de l’OpenGL

Modes OpenGL (glRenderMode)

Selecció:

  1. especificar buffer de selecció (mida, ↑) - glSelectBuffer()
  2. passar a mode selecció - glRenderMode(GL_SELECT)
  3. inicialitzar l’ID dels elements - pila de GLint (glInitNames, glPushName, glLoadName)
  4. definir la viewing matrix com tota la vida
  5. definir la projection matrix tal que coincideixi amb la regió de selecció
            glLoadIdentity()
            gluPickMatrix(x, y, w, h, viewport) // mouseX, mouseY, 1, 1 - rectangle 2D
            gluPerspective(...)
  6. dibuixar escena, enviant els IDs de cada element
  7. passar a mode GL_RENDER        hits=glRenderMode(GL_RENDER)
  8. processar la selecció del buffer (llista de hits). Per cada hit:

Selecció basada en lectura del framebuffer

Entrada: rectangle 2D: x, y, w, h

Sortida: llista d’elements visibles que es projecten

  1. netejar els buffers - glClear(), glClearColor()
  2. configurar el context
  1. definir les matrius ModelView i Projection com sempre
  2. activar glEnable(GL_DEPTH_TEST)
  3. desactivar tot allò que pugui afectar el color:
  1. GL_LIGHTING
  2. shading
  3. textures
  4. boira
  5. anti-aliasing
  1. pintar l’escena, codificant l’ID dels elements en el seu color
            unsigned int tmp = ID;
            GLubyte color[4];
            color[0] = ID % 256;
            tmp = ID / 256;
            color[1] = ID % 256;
            …
            glColor4ubv(color);
    [[ Amb glGetInteger(GL_{RED,GREEN,BLUE,ALPHA}_BITS, &bits) es pot consultar el nombre de bits de cada color. ]]
  2. llegir el buffer de color
    glReadPixels(x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, color)
  3. per a tot píxel, decodificar l’ID.

Tests intersecció / distància

Intersecció raig-escena / frustum-ecensa / esfera-escena / etc.

El raig es pot obtenir a partir de la posició del cursor, Q, i la posició de l’observador: (OBS, Q).

Obtenim Q a partir de (mouseX, mouseY), passant la posició de window space a world space amb glUnProject(mouseX, mouseY, 0, …, Q).

Si volem utilitzar la component Z (i no fixar-la a zero), podem obtenir-la amb:

GLfloat winZ;

glReadPixels(mouseX, viewport[3]-mouseY, 1, 1,

GL_DEPTH_COMPONENT, GL_FLOAT, winZ);


TEMA 6: Manipulació d’objectes 3D

Transformació

Representació de transformacions de modelat

Per cada objecte s’emmagatzema:

Interpretació 1

TRS

<-----

Interpretació 2

TRS

----->

Representació de rotació/orientació

Pintar objectes

per tot objecte:

glPushMatrix()

glTranslatef(tx, ty, tz)

glRotatef(...)                // l’objecte ha d’estar centrat

glScalef(sx, sy, sz)        // “”

render object

glPopMatrix()

Implicacions

Axis-aligned bounding box: object space != model space

Sphere: (c, r) → (c’, r’) on c’ = c+t, r’=Rmax(sx, sy, sz)

Translació d’objectes

Donada una acció de l’usuari (moviment del ratolí / dit sobre pantalla tàctil) calcular T.

Una opció intuitiva és limitar cada translacció incremental a un vector:

Opció 1

T’ = (ΔmouseX, ΔmouseY, 0)

T = K(viewing)-1·T’        (K és una constant de sensibilitat)

Opció 2

Entrada:

p: punt de l’objecte seŀleccionat (centre)

p’: projecció de P en espai d’imatge

T’: translacció en espai d’imatge

T: translacció en espai d’objecte

Calcula:

...


Ombres...


TEMA 8: Reflexions especulars

Un punt reflecteix llum directa (difosa i especular) i indirecta.

Equació del vector reflectit: R

Donats N i L unitaris, quin és R? Sabem que:

  1. L’angle incident i l’angle reflectit són el mateix.
  2. N, L i R són coplanars
  3. (veure imatges i equacions a les transparències)

Podem calcular-lo amb: R = 2(N·L) - L

Reflexió basada en objectes virtuals

Assumeix que el mirall és pla. Crea un còpia del model situat tal com si estiguès darrere del mirall.

Versió sense stencil

Pas 1: dibuixa l’objecte en la posició virtual.

Pas 2: dibuixa el “mirall” semi-transparent.

Pas 3: dibuixa l’objecte en posició real.

Limitacions:

Versió amb stencil:

Pas 1: dibuixar el mirall al stencil buffer

Pas 2: dibuixar els objectes en posició virtual, però només on el stencil estigui a 1

Pas 3: dibuixar el mirall semi-transparent

Pas 4: dibuixar objectes en posició real

Reflexió amb textures dinàmiques

Dibuixes l’imatge en una textura i l’apliques al mirall.

Environment mapping

Sphere maps

Pas 1: calcular el vector reflexat en el vèrtex (respecte OBS)

        L = (OBS-V) / ||OBS-V||, R = 2(N·L)N - L

Pas 2: calcular (px, py, pz) corresponents a R

pz=sqrt((rz+1) / 2)        px=rx/(2pz)        py=ry/(2pz)

Pas 3: (px, py, pz) → (u, v)

u=px        v=py

Pas 4: (u, v) → (s, t)

s=(u+1)/2        t=(v+1)/2

Cube maps

GLSL: texture2DCubeMap