Linha de produção de imagens com o OpenGL (OpenGL Rendering Pipeline)

Linha de produção de imagens com o OpenGL™

(OpenGL Rendering Pipeline)

Cena Virtual

objetos geométricosluzescâmeras

Complexidade do Algoritmo de Rastreamento de Raios

Para cada pixel da telaDefina um raio

Para cada objeto da cenaCalcule o objeto visível

Para cada luz da cenaLance um raioPara cada objeto da cena

Teste se o objeto faz sombraCalcule sua iluminação

Complexidade maior que O(num. de pixels num. de objetos2)

Uma outra forma de menor complexidade

Calcule a cor de cada vertice Projete cada vertice

Preencha o triângulo dos vértices projetados

Macro passos da linha de produção de imagens

Aplicação Geometria Rastreio

Transformações do modelo e de câmera

Iluminação

Projeção

Recorte

Mapeamento para tela

Conversão vetorial matricial

Operações de fragmentos

Mapas de cor e profundidade

Extração da posição, forma e aparência dos objetos na resolução

adequada

Descarte dos objetos fora do campo de

visão

Cinemática dos objetos e testes de

colisão

Um objeto em vários níveis de detalhe

Multi-resolução num mesmo objeto

Descarte de objetos fora do campo de visão

Descarte por planos oclusores

Instanciação de objetos na cena

- OpenGL Model View -

Instânciação de objetos

Instânciação de objetos- vários sistemas de coordendas -

Objetos posicionados diretamente

Tipos de primitivas gráficas do OpenGL

GL_POINTS

GL_LINES

GL_LINE_STRIP

GL_LINE_LOOP0 1

GL_POLYGON

GL_QUADS

GL_QUAD_STRIP

GL_TRIANGLES

GL_TRIANGLE_STRIP

GL_TRIANGLE_FAN

Projeção Cônica (Perspective)

aspect = w/h

void gluPerspective( GLdouble fovy, GLdouble aspect, GLdouble near_, GLdouble far_ );

Projeção Cônica (Frustum)

botton

left right

void glFrustum(GLdouble left,GLdouble right,GLdouble bottom, GLdouble top, GLdouble near_, GLdouble far_ );

Obs.: near e far são distâncias( > 0)

view frustum

Glu Look At

Dados: eye, center, up (definem o sistema de coordenadas do olho)

Determine a matriz que leva do sistema de Coordenadas dos Objetospara o sistema de Coordenadas do Olho

void gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz);

up eye

center

Coordenadas dosobjetos

Coordenadas doolho

Calculo do sistema - xe ye ze

center

centereyecentereye

e zupzup

eee xzy

dados:eye, center, up

Translada o eye para origem

center

Roda xe ye ze para xw yw zw

xe , xo

ye , yo

ze , zo

ezeyex

center

Matriz LookAt do OpenGL

exexex

eyeyex

ezeyex

at eye

centereyecentereye

e zupzup

eee xzy

exexex

eyeyex

ezeyex

Cor dos vértices

vrLn ˆˆˆˆ

n̂r̂

Projeção

Simplificação da projeção cônica

Projeção cônica

plano de projeçãoeye

direção de projeção

plano de projeção

Projeção ortográfica

Projeção cônica simples

n yeyp -ze=

xexp -ze=

Projeção cônica simples

Distorce o frustum de visão para o espaço da tela

ze = -n

ze = -f

ze = -n ze = -f

Transformação projetiva- a origem vai para o infinito em z+ -

133323130

23222120

13121110

03020100

33323130

23222120

13121110

03020100

323130

222120

121110

020100

Transformação projetiva- os pontos do plano z =–n ficam imóveis -

nmymxm

323130

222120

121110

020100

323130

222120

121110

020100

nmymxmx 020100

0, 121011121110 mmmnmymxmy

0, 212022222120` mmn

mnmymxmn

0, 313032323130 mmn

mnmymxm

0, 020100 mmm

Transformação projetiva- matriz P com estas condições -

Transformação projetiva- condição sobre os pontos do plano z = –f -

Resumindo

[ P ] = ?

Outro enfoque: distorce o frustum de

visão para o espaço da tela

ze = -n ze = -f

ze = -n

ze = -f

Uma equação para profundidade

ban Ptos no near (z=-n):

baf Ptos no far (z=-f):

[ H ] =

Transforma o prisma de visão cubo normalizado [-1,1]×[-1,1] ×[-1,1]

-(r-l)/2

(r-l)/2

-(t-b)/2

(t-b)/2

(f-n)/2 -(f-n)/2

2/)(100

2)(010

2)(001

-1-1-1

0)(200

00)(20

000)(2

-1-1-1

Matriz Frustum do OpenGL

2/)(100

2)(010

2)(001

0)(200

00)(20

000)(2

OpenGL Spec

2/)(100

2)(010

2)(001

0)(200

00)(20

000)(2

Resumo das transformações (até o momento)

center

Projeção Paralela(Ortho)

leftright

bottom

top near far

void glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_, GLdouble far_ );

void gluOrtho2D( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top );

direção de projeção

Matriz Ortho do OpenGL

OpenGL Spec

2/)(100

2)(010

2)(001

0)(200

00)(20

000)(2

Requisitos de uma câmera de uma estação de Realidade Virtual

Recorte

Diferentes problemas de recorte

Condição de pertinência

p é interior

ii 0pn

01 pn 01111 dzcybxa

Interseção de aresta × hiperplano

11 pnd

22 pndip

1 pppdd

intercepta 021 dd

segmento de retaou aresta

hiperplano

1 pppdd

Recorte de segmentos com base no algoritmo Cohen-Sutherland

Casos de clipping de linhas

(x1, y1)

(x2, y2)

(x’1, y’1)

(x’2, y’2)

Códigos das regiões

1001 1000 1010

0001 0000 0010

0101 0100 0110

Cálculo do código de um vértice

unsigned char code(double x, double y, double xmin, double xmax, double ymin, double ymax){ unsigned char code=0; if (y > ymax) code += 8; if (y < ymin) code += 4; if (x > xmax) code += 2; if (x < xmin) code += 1; return code;}

1001 1000 1010

0001 0000 0010

0101 0100 0110

void CohenSutherlandLineClip(double x0, double y0, double x1, double y1, double xmin, double xmax, double ymin, double ymax) { unsigned char outcode0, outcode1, outcodeOut; double x, y; boolean accept = FALSE, done = FALSE;

outcode0 = code(x0, y0, xmin, xmax, ymin, ymax); outcode1 = code(x1, y1, xmin, xmax, ymin, ymax);

do { if (outcode0 == 0 && outcode1 == 0) { accept = TRUE; done = TRUE; /* trivial draw and exit */ } else if((outcode0 & outcode1) != 0) { done = TRUE; /* trivial reject and exit */ } else { /* discart an out part */ outcode = (outcode0 != 0) ? outcode0 : outcode1; /* pick an out vertice */ if (outcodeOut & 8) { /* discart top */ x = x0 + (x1 - x0) * (ymax - y0) / (y1 - y0); y = ymax; } else if(outcodeOut & 4) { /* discart bottom */ x = x0 + (x1 - x0) * (ymin - y0) / (y1 - y0); y = ymin; } else if(outcodeOut & 2) { /* discart right */ y = y0 + (y1 - y0) * (xmax - x0) / (x1 - x0); x = xmax; } else if(outcodeOut & 1) { /* discart left */ y = y0 + (y1 - y0) * (xmin - x0) / (x1 - x0); x = xmin; } if (outcodeOut == outcode0) { x0 = x; y0 = y; outcode0 = code(x0, y0, xmin, xmax, ymin, ymax); } else { x1 = x; y1 = y; outcode1 = code(x1, y1, xmin, xmax, ymin, ymax); }

} } while (!done);

if (accept) DrawLineReal(x0, y0, x1, y1);}

Algoritmo deCohen & Sutherland

Algoritimo de Cyrus-Beck(Liang-Barsky)

P t P P P t 0 1 0( )

N P t PEi Ei 0

Algoritimo de Cyrus-Beck(Liang-Barsky)

P t P P P t 0 1 0( )

0 EiEi PtPN

N P t PEi Ei 0 N P t PEi Ei 0

N P t PEi Ei 0

tN P P

N P PEi Ei

Entrando ou Saindo ?

N P P PEEi 1 0 0

N P P PLEi 1 0 0

Recorte de segmentos com base no algoritmo de Cyrus-Beck

Cyrus-Beck - caso geral

{ Calcule Ni e escolha um PEi para cada aresta

tE = 0; tL = 1; for (cada aresta ){ if (Ni.(P1-P0)!=0 ){ /* aresta não é paralela ao segmento */ calcule t; use sign of Ni.(P1-P0) para categorizar como PE ou PL; if( PE ) tE = max(tE, t); if( PL ) tL = min(tL, t); } else { /* aresta paralela ao segmento */ if (Ni.(P0-PEi) > 0) /* está fora */ return nil; } if (tE > tL) return nil; else return P(tE) and P(tL) as true clip intersections; } }}

Liang e Barsky- caso particular -

Ei NEi PEi t

left: x = xmin (-1, 0) (xmin, y)-(x0-xmin)(x1-x0)

right: x = xmax (1, 0) (xmax, y)(x0-xmax)-(x1-x0)

bottom: y = ymin (0,-1) (x, ymin)-(y0-ymin)(y1-y0)

top: y = ymax (0, 1) (x, ymax)(y0-ymax)-(y1-y0)

xmin xmax

Liang e Barsky- Cálculo da interseção em uma fronteira -

boolean Clipt(double den, double num, double *tE, double *tL){ double t; if (den > 0) /* intersecao PE */ { t = num/den; if (t > *tL) /* tE > tL */ return FALSE; else if (t > *tE) *tE = t; } else if (den < 0) /* intersecao PL */ { t=num/den; if (t < *tE) /* tL < tE */ return FALSE; else if (t < *tL) *tL = t; } else if (num > 0) /* linha esta fora */ return FALSE; } return TRUE;}

Algoritimo de Liang e Barsky

boolean Clip2D(double *x0, double *y0, double *x1, double *y1, double xmin, double max, double ymin, double ymax){ double dx = *x1 - *x0; double dy = *y1 - *y0; boolean visible = FALSE; if (dx==0)&&(dy==0)&&ClipPoint(*x0,*y0,xmin,xmax,ymin,ymax) visible=TRUE; else { double tE=0.0, tL=1.0;

if ( Clipt(dx,xmin-*x0,&tE,&tL) ) if ( Clipt(-dx,*x0-max,&tE,&tL) ) if ( Clipt(dy,ymin-*y0,&tE,&tL) ) if ( Clipt(-dy,*y0-ymax,&tE,&tL) ) { visible=TRUE; if (tL<1.0) { (*x1)=(*x0)+tL*dx; (*y1)=(*y0)+tE*dy; } if (tE>0.0) { (*x0)=(*x0)+tE*dx; (*y0)=(*y0)+tE*dy; } } } return visible;}

Recorte de polígonos com base no algoritmo de Hodgman-Sutherland

Clip contra uma aresta (plano) de cada vez

Classificação de um segmento contra um hiperplano no algoritmo de Hodgman-Sutherland

Saída: pSaída: p Saída: iSaída: i Saída: i, pSaída: i, p

interno saindo externo entrando(a) (b) (c) (d)

• Para cada aresta (hiperplano) da região de recorte•Para cada segmento do polígono

• Existem quatro casos possiveis para um vértice e seu antessessor

Exemplo do algoritmo de Hodgman-Sutherland

A BCD E

s p saída

3 4 B e 4

6 1 D e 1

s p saída

4 5 F e 5

Clipping de polígonos(Exemplo 1)

S P Ação

2 3 store A,3

3 4 store 4

4 5 store 5

5 6 store B

S P Ação1 2 store A2 3 x3 4 store B,44 5 store 55 6 store C6 1 store D,1

CDx x x x

S P Ação

1 A store 1, A

A B store BB 4 store E4 5 store F,55 C store CC D store D

CDx x x x

B, E, F, 5, C, D, 1, AB, E, F, 5, C, D, 1, A

Clipping de polígonos(Concatenação de planos)

CDx x x x

1, A, B, E, F, 5, C, D1, A, B, E, F, 5, C, D

3 4 5 6

CDx x x x

first[0]S[0]P[0]

first[1]S[1]P[1]

APIs para definição de polígonosint npoints; double x[10],y[10];

FillPoly(npoints, x, y);

typedef struct { double x,y; } Point;

Point vertex[10];

FillPoly(npoints, vertex)

Begin(FILL); Vertex(30.,20.); Vertex(15.,18.); …End( );

void Vertex(double x, double y, double z) { ClipAtPlane( x, y, z);}

void End( );{ ClipAtPlane(xf,yf,zf); FillSavedPoly( );}

Recorte de polígono contra um plano

void ClipAtPlane( double x0, double y0, double x1, double y1, int plane ){ double d0 = Distance(x0,y0, plane); double d1 = Distance(x1,y1, plane);

if ((d0<0)^(d1<0)) { double t=d0/(d0-d1); SaveVertex(x0+t*(x1-x0),y0+t*(y1-y0),plane); } if (d1<=0.0) SaveVertex(x1,y1,plane);}

Saída: pSaída: p Saída: iSaída: i Saída: i, pSaída: i, p

interno saindo externo entrando(a) (b) (c) (d)

double Distance (double x, double y, int plane ){ switch( plane ) { case 0: return( x_min - x ); case 1: return( x - x_max ); case 2: return( y_min - y ); case 3: return( y - y_max ); } return( 0.0 );}

xmin xmax

void ClipVertex(double x, double y, int plane, int last){ static int first=1; static double x_first, y_first; static double x_previous, y_previous;

if (first) { x_first=x, y_first=y; first =0; } else if (!last) { ClipAtPlane(x_previous,y_previous,x,y, plane); } else { ClipAtPlane(x_previous,y_previous,x_first, y_first, plane); } x_previous=x; y_previous=y; }

void Begin(void){}

void Vertex(double x, double y) { int plane = 0; int last = 0; ClipVertex(x,y,plane,last);}

void End(void) { ClipVertex(0,0,0,1);}

Regiões de recorte do rendering pipeline

center

-1 xn 1 -1 yn 1 -1 zn 1

Problema do clipping no R3

222 fn

Escolhas dos hiperplanos do PR3

0 wsewxc

cl xwd

OpenGL Spec

Cálculo das distâncias aos hiperplanos no PR3

double Distance (double x, double y, double z, double w, int plane ){ switch( plane ) { case 0: return( -w - x ); case 1: return( -w + x ); case 2: return( -w - y ); case 3: return( -w + y ); case 4: return( -w - z ); case 5: return( -w + z ); } return( 0.0 );}

11 pnd

22 pndip

hiperplano

1 pppdd

intercepta 021 dd

1 pppdd

Recorte de polígonos de Sutherland-Hodgman

void ClipAtPlane( double x, double y, double z, double w, int plane ){ double d = Distance(x, y, z, w, plane); /* Check whether it is the first point */ if( first[plane] ) { fx[plane]=x; fy[plane]=y; fz[plane]=z; fw[plane]=w; fd[plane]=d; first[plane]=0; } else if ((sd[plane] < 0)^(d < 0)) Intersect( x, y, z, w, plane, sd[plane], d );

/* Save as previous */ sx[plane]=x; sy[plane]=y; sz[plane]=z; sw[plane]=w; sd[plane]=d; /* Check whether it is a visible point */ if ( d <= 0.0 ) { if ( plane == LAST_PLANE ) SaveVertex( x, y, z, w ); else ClipAtPlane( x, y, z, w, plane+1 ); }}

static int first[]={1,1,1,1,1};static double fx[5],fy[5],fz[5],fw[5],fd[5];static double sx[5],sy[5],sz[5],sw[5],sd[5];

Teste de interseção com uma fronteira

void Intersect(double x, double y, double z, double w, int plane, double d1, double d2){ double t = d1 / (d1 - d2);

double xi = sx[plane] + t * (x - sx[plane]); double yi = sy[plane] + t * (y - sy[plane]); double zi = sz[plane] + t * (z - sz[plane]); double wi = sw[plane] + t * (w - sw[plane]); if( plane == LAST_PLANE ) SaveVertex( xi, yi, zi, wi ); else ClipAtPlane( xi, yi,zi, wi, plane+1 );}

Fechando o processo

void ClipClose( int plane ){ if ((sd[plane]<0)^(fd[plane]<0)) Intersect( fx[plane], fy[plane], plane, sd[plane], fd[plane] );

first[plane]=1; if( plane == LAST_PLANE ) FillSavedPolygon( ); else ClipClose( plane+1 );}

void ClipClose( int plane ){ if ((sd[plane]<0)^(fd[plane]<0)) Intersect( fx[plane], fy[plane], plane, sd[plane], fd[plane] );

first[plane]=1; if( plane == LAST_PLANE ) FillSavedPolygon( ); else ClipClose( plane+1 );}

Begin(FILL); Vertex(30.,20.); Vertex(15.,18.); …End( );

Transformação para o viewport

-1-1-1

void glViewport(int x0, int y0, int w, int h );

zw[0.. zmax], zmax = 2n-1 geralmente 65535

Mapa de profundidade

cn znf

n=1n=10

n=30-f=-100

en znf

12,12 maxmax n

nw zzz

)(5.05.0

nf 15.05.0

5.05.0)(

max nfnf

nfnfnf

5.05.0)(max

ew znf

!!!39665534

65535,01.0,1000 max

Transformações de um vértice

OpenGL Spec

Modelo do Pintor

undidad

ZBuffer: idéia básica

MATRIZ DEPROFUNDIDADES

ZBuffer - pseudo-código

void ZBuffer( void){ int x,y;

for (x=0; x<w; x++) { for (y=0;y<h; y++) { WritePixel(x,y, bck_color); WriteZ(x,y,far+1); } }

for (each primitive) { for (each pixel in the projected primitive) { double pz = z coordinate of the (x,y) pixel; if (pz <= ReadZ(x,y)) { WritePixel(x,y, color); WriteZ(x,y,pz); } } }

} /* Zbuffer */

void glEnable( GL_DEPTH_TEST );void glEnable( GL_DEPTH_TEST );

Rastreio de Polígonos e Linhas

Coordenadas de um ponto na janela(windows coordinate)

w=6 e h=5

ponto: (3,2)tamanho 1sem anti-alias ponto: (3,3)

tamanho 3sem anti-alias

OpenGL Spec

0.5 1.5 2.5 3.5 4.5 5.5

0 1 2 3 4 5

Critério geométrico para linhas horizontais, verticais e à 450

0 1 2 3 4 5

linha: (0,0),(4,0)linha: (5,1),(5,4)linha: (0,2),(3,5)

Critério geométrico de Bresenham (1965) para linhas

linha: (0,0),(5,2)

0 1 2 3 4 5

x dominante

1212 yyxx x dominante, um pixel por coluna

1212 yyxx y dominante, um pixel por linha

Critérios geométricos para linhas do OpenGL™

linha: (0,0),(5,2)

0 1 2 3 4 5

Bresenham (1965)OpenGL™ spec

0 1 2 3 4 5

Algoritmo simples de rastreio de linha(no primeiro octante)

#define ROUND(x) (int)floor((x)+0.5)

void linha(int x1, int y1, int x2, int y2){ float m = (y2-y1)/(x2-x1); float b = y1 - m*x1; float y; fragmento(x1,y1); while( x1 < x2 ) { x1++; y = m*x1 + b; fragmento(x1,ROUND(y)); }}

bmxy ii

),( 11 yx

),( 22 yx

Podemos evitar a multiplicação?

0 1 2 3 4 5

Forma incremental do algoritmo simples de linha

void linha(int x1, int y1, int x2, int y2){ float m = (y2-y1)/(x2-x1); float b = y1 - m*x1; float y=y1; pixel(x1,y1); while( x1 < x2 ) { x1++; y += m; fragmento(x1,ROUND(y)); }}

bmxy ii

),( 11 yx

),( 22 yx

bxmy ii 11

bmxy ii

myy ii 1

Podemos evitar o uso de ponto flutuante?

Equação implícita da reta

12 xxx

F x y( , ) 0

cybxayxF ..),(

1121121212 xyyyxxxyyyxx

01121122112 xyyyxxyxxxyy

bmxy ii

Equação básica do algoritmo do ponto médio para linhas

cybxayxF ..),(

0),( mm yxF

xp+1 xp+2

yp+1/2

xp xp+1 xp+2

myp+1/2

yp+2mne

0),( mm yxF

Algoritimo do ponto médio- redução para inteiros -

),(2),( yxFyxd

escolha

escolhaFd

0)(2)(

ecybxayxFd ppppnovo 2)(2)2(2),2(2 2

add antnovo 2

cybxayxFd ppppnovo 2)(2)2(2),2(2 23

badd antnovo 22 ne

bane 22

xp xp+1 xp+2yp

myp+1/2

yp+3/2mne

bacybxayxFdini 22)(2)1(2),1(2 21

bad ini .2

Algoritimo do ponto médio para linhas- código C -

void linhaPM(int x1, int y1, int x2, int y2){ int a = y2-y1; int b = x1-x2; int d=2*a+b; /* valor inicial da var. decisao */ int incrE = 2*a; /* incremento p/ mover E */ int incrNE = 2*(a+b); /* incremento p/ mover NE */ fragmento(x1,y1);

while (x1<x2) { x1++; if (d<=0) /* escolha E */ d+=incrE; else { /* escolha NE */ d+=incrNE; y1++; } fragmento(x1,y1); }

Algoritimo do ponto médio para linhas com estilo - código C -

void linhaPM(int x1, int y1, int x2, int y2){ int a = y2-y1; int b = x1-x2; int d=2*a+b; /* valor inicial da var. decisao */ int incrE = 2*a; /* incremento p/ mover E */ int incrNE = 2*(a+b); /* incremento p/ mover NE */ int style[8]={1,1,0,0,1,1,0,0}; int k=1; fragmento(x1,y1); /* primeiro pixel */

while (x1<x2) { x1++; if (d<=0) /* escolha E */ d+=incrE; else { /* escolha NE */ d+=incrNE; y1++; } if (style[(++k)%8]==1) fragmento(x1,y1); }

Critério geométrico para rastreio de elipses

F(x,y) = 0

Rastreio de círculos

x=0,y=raio; fragmento(x,y);while (x<y) { x++; if (F(M)<0) escolha E; else escolha SE; fragmento(E ou SE);}

simetrias do círculo:cada ponto calculado define 8 pixels

F(x,y) = 0

Rastreio de polígonos

Conceito de interior num polígono qualquer (regra par-ímpar)

Preenchimento de polígonos

dados: {(x0,y0), (x1,y1), (x2,y2) (x3,y3), (x4,y4)}

acha ymax e ymin

Para cada y [ymax,ymin]

Para cada aresta calcula as interseções

ordena interseções

desenha linhas horizontais

vx= {xi1 , xi0 , xi4 , xi3}vx= {xi1 , xi0 , xi4 , xi3}

i0i1 i3i4

xi1 xi0 xi3

Interseção nos vértices

inclui vértices: i0-i1, i2-i3, i4-?

não inclui vértices: i0-?

Solução:

Otimização do algoritmo de preenchimento: interpolação linear

,2,, 000 dxxdxxx

Interpolação linear na aresta

ys+1dy = 1

x1x00 xi xi+1

,2,, 000 dccdccc

Otimizações do algoritmo de preenchimento: triângulos

Posições possíveis de um triângulo dado yA≥ yB ≥ yC

))(())(( ABACACAB yyxxyyxxbc

Rastreio de triângulo

Interpolação perspectiva

plano de projeção

Interpolação perspectiva

0P 00 zw

10)1()( swwssw

10)1()( ppp ttt

10)1()( PPP sss

)1()1(

)()( ts pp 10

)1( swws

)1( twwt

Interpolação de atributos

1)1( sIIsI o

)1(1( I

ItwIwtI

)1( twwt

wItwItI

OpenGL Spec

Interpolação de atributos homogêneos

)1( twwt

qtwqwt

utwuwt

wqtwqt

wutwut

OpenGL Spec

Suavização da tonalização

c12 c43c

Gouraud void glShadeModel (GL_FLAT);

void glShadeModel (GL_SMOOTH);

Interpolação da profundidade

1)1( szzsz o

)1(1( z

)1()1(

ztzzztz

)1( twwt

)1( tzzt

Uma outra forma de ver a interpolação da profundidade

en znf

Algortimo de ZBuffer

void ZBuffer( void){ for (cada primitva gráfica dos objetos da cena) { for (cada fragmento gerado pelo rastreio da primitiva) { if (o fragmento não pertencer a janela) break; /* pertinencia */ if (o fragmento não pertencer ao retangulo de janela de recorte) break; /* scissor test */ if (a profundidade do fragmento for maior que a corrente) break; /* profundidade */ . . . WritePixel(x,y, color); WriteZ(x,y,pz); } } }

Exercício 1

left right

topbotton

Derive a matriz de projeção da seguinte câmera

Cor e iluminação

Pipeline visualizaçãoou Cadeia de rendering

Partição Binária do Espaço

(Binary Space Partition)

Modelo do Pintor

undidad

Problemas na ordenação de faces

BSP trees: Binary Space Partion Trees

atrásfrente

2frente atrás

Exibição de uma BSP

void bspDisplay(bspTree *tree){ if (arvore não é vazia) { if (observador está a frente da raiz) { bspDisplay(treebackChild); DisplayPolygon(treeroot); bspDisplay(treefrontChild); } else { bspDisplay(treefrontChild); DisplayPolygon(treeroot); bspDisplay(treebackChild); } }}

Mostra a árvore detrás, a raiz e a árvoreda frente.

Mostra a árvore dafrente, a raiz e a árvorede atrás.

BSP trees: Dois exemplos de exibição

5a, 2, 1, 3, 5b, 45a, 2, 1, 3, 5b, 4

4, 5b, 3, 5a, 2, 14, 5b, 3, 5a, 2, 1

Sistema de Coordenadas do Modelo

OpenGL: Linha de produção de imagens

Câmera

Equação de um plano

N=(A,B,C)

P=(x,y,z)

N.P = N.(P0 + P) = N.P0 = d N.P = N.(P0 + P) = N.P0 = d

d = Ax + By + Cz d = Ax + By + Cz

N.P = Ax + By + Cz N.P = Ax + By + Cz

Ax + By + Cz +D = 0Ax + By + Cz +D = 0

(A, B, C) = NeD = -d = N.(-P0 )

Distância de um ponto a um plano

N=(A,B,C)

P=(x,y,z)

P N.P = Ax + By + Cz N.P = Ax + By + Cz

N.P = Ax + By + Cz+D N.P = Ax + By + Cz+D

N.Pp = d = -D N.Pp = d = -D

N. P = N.P - N.Pp N. P = N.P - N.Pp

Interseção de reta com plano

d1 = Ax1 + By1 + Cz1+D

d2 = Ax2 + By2 + Cz2+DP

P =d1 P2 - d2 P1

d1 - d2

Projeção de Vértices

m11 m12 m13 m14

m21 m22 m23 m24

m31 m32 m33 m34

m41 m42 m43 m44

P’ =

x’y’z’

xh /wyh/wzh/w

-1-1-1

Clipping em coordenadas homogêneas

x[left, right]y

-1 xh/w 1

xh/w 1

xh w , se w>0 xh w , se w>0

xh w , se w<0 xh w , se w<0

OpenGL Spec

Região de recorte no espaço normalizado

-1 xh/w 1 -1 yh/w 1 -1 zh/w 1

-1 xn 1 -1 yn 1 -1 zn 1

x[left, right] y[bottom, top]z[near, far]

-1-1-1

nearfarright

bottom

en znf

ez-n -f

Efeito de profundidade

Critério geométrico de Bresenham (1965) para linhas

x = 5, y =3

Linha de produção de imagens com o OpenGL (OpenGL Rendering Pipeline)

Documents

Transcript of Linha de produção de imagens com o OpenGL (OpenGL Rendering Pipeline)

Introduction to OpenGL & GLUTSep 09, 2008 · Introduction to OpenGL & GLUT The Design of OpenGL —Introduction OpenGL is an API for rendering raster images of 2-D & 3-D scenes.

Introduction to OpenGL and GLUTweb.cse.ohio-state.edu/.../opengl_introduction.pdf · OpenGL Basics • The main use: Rendering. • OpenGL can render: – Geometric primitives –

OpenGL - GAMMAgamma.cs.unc.edu/graphicscourse/12_OpenGL.pdf · OpenGL API Family OpenGL The main rendering API GLU OpenGL Utility functions Various helper functions for matrices,

Lighting & Shading - ETH ZLighting & Shading 12 Real-World vs. OpenGL •R wdlaleor – complex computations – see optics textbooks, photorealistic rendering •OpenGL – simplified

5. Lighting & Shading · 5. Lighting & Shading 3 Real-World vs. OpenGL •R wdllaeor –comepx clompounaitts – see optics textbooks, photorealistic rendering •OpenGL – simplified

Today … The rendering pipeline in detail What is OpenGL First OpenGL program Details about modeling.

Surface Rendering With OpenGL CS460 Project by Rui Yu 11/30/03.

GFX Part 7 - Introduction to Rendering Targets in OpenGL ES

OpenGL® - CERN · 2014-08-15 · Introduction to OpenGL 1 What Is OpenGL? 2 A Smidgen of OpenGL Code 5 OpenGL Command Syntax 7 OpenGL as a State Machine 9 OpenGL Rendering Pipeline

Orbiter OpenGL graphics client - Orbital Designsorbides.org/orbf/ogla-doc-100416.pdfИнструкция (User manual) OGLAClient 100416 Orbiter OpenGL graphics client Rendering engine

Introduction to OpenGL and GLUT - web.cse.ohio …web.cse.ohio-state.edu/.../cse581-2012-spring/opengl_introduction.pdf · OpenGL Basics • The main use: Rendering. • OpenGL can

OpenGL - GAMMAgamma.cs.unc.edu/graphicscourse/LECTURES/2016/OpenGL.pdf · What is OpenGL? Cross platform API for 2D and 3D rendering only provides rendering APIs, no windowing/input/sound

OpenGL ES with iOS 5 - Chris Mileschrismiles.info/presentations/SwipeConf-2012-OpenGL-ES-iOS5/Swipe... · @chrismiles Chris Miles OpenGL ES with iOS 5 Part 2: Rendering a masterpiece

OpenGL Rendering Pipeline

OpenGL & CUDA Tessellation - Nvidia · NVIDIA Confidential Agenda OpenGL 4.x Tessellation Motivation OpenGL 4.x Tessellation Pipeline Tessellation for terrain rendering Tessellating

GPU Shading and Rendering: OpenGL Shading Language

3D Rendering in OpenGL

Optimizing ARINC 661 Rendering for OpenGL with Hardware ...

Abstract - ISSFD · (a) Deﬁning the cube face normals (b) OpenGL Rendering the shaded cube Figure 4: OpenGL Shaded cube In building an OpenGL model, vertex normals do not necessarily

Animation Rendering Tool - Columbia Universitysedwards/classes/2016/4115... · Animation Rendering Tool Brett Jervey - baj2125 Gedion Metaferia - gym2103 ... ART utilizes the OpenGL