A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

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

Apresentações semelhantes


Apresentação em tema: "Linha de produção de imagens com o OpenGL (OpenGL Rendering Pipeline)"— Transcrição da apresentação:

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

2 Cena Virtual objetos geométricos luzes câmeras

3 xexe yeye zeze xoxo yoyo zozo Complexidade do Algoritmo de Rastreamento de Raios Para cada pixel da tela Defina um raio Para cada objeto da cena Calcule o objeto visível Para cada luz da cena Lance um raio Para cada objeto da cena Teste se o objeto faz sombra Calcule sua iluminação Complexidade maior que O(num. de pixels num. de objetos 2 )

4 Uma outra forma de menor complexidade Calcule a cor de cada vertice Projete cada vertice Preencha o triângulo dos vértices projetados zeze xexe yeye

5 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

6 Um objeto em vários níveis de detalhe

7 Multi-resolução num mesmo objeto

8 Descarte de objetos fora do campo de visão

9 Descarte por planos oclusores

10 Instanciação de objetos na cena - OpenGL Model View -

11 Instânciação de objetos

12 Instânciação de objetos - vários sistemas de coordendas - x2x2 y z2z2 xz y2y2 x4x4 y4y4 z4z4 x6x6 x1x1 y1y1 z1z1 x3x3 y3y3 z3z3 x5x5 z5z5 y5y5 d1d1 d2d2

13 Objetos posicionados diretamente x z y

14

15 Tipos de primitivas gráficas do OpenGL 2 3

16 Projeção Cônica (Perspective) aspect = w/h void gluPerspective( GLdouble fovy, GLdouble aspect, GLdouble near_, GLdouble far_ ); xexe yeye zeze near far w h yeye zeze fovy

17 Projeção Cônica (Frustum) near yeye zeze far top botton xexe zeze near leftright far 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 zeze xexe yeye eye

18 Glu Look At Dados: eye, center, up (definem o sistema de coordenadas do olho) Determine a matriz que leva do sistema de Coordenadas dos Objetos para 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 dos objetos Coordenadas do olho eye

19 Calculo do sistema - x e y e z e yeye center eye zozo yoyo xoxo zeze xexe up dados: eye, center, up

20 Translada o eye para origem center eye zozo yoyo xoxo zeze xexe yeye zozo yoyo xoxo center eye zeze xexe yeye

21 Roda x e y e z e para x w y w z w x e, x o y e, y o z e, z o zozo yoyo xoxo center eye zeze xexe yeye

22 Matriz LookAt do OpenGL

23 Cor dos vértices xexe yeye zeze

24 Projeção

25 Simplificação da projeção cônica Projeção cônica plano de projeção eye direção de projeção plano de projeção Projeção ortográfica

26 Projeção cônica simples yeye zeze p xexe z e n y e z e xexe xpxp yeye ypyp -z e yeye ypyp n = n yeye ypyp = n xexe xpxp = n xexe xpxp = n n xexe

27 Projeção cônica simples yeye zeze p n xexe

28 Distorce o frustum de visão para o espaço da tela xexe yeye zeze z e = -n z e = -f xexe yeye zeze z e = -n z e = -f

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

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

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

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

33

34 Resumindo [ P ] = ? xexe yeye zeze xexe yeye zeze

35 xexe yeye zeze Outro enfoque: distorce o frustum de visão para o espaço da tela z e = -n z e = -f xexe yeye zeze z e = -n z e = -f d = n

36 Uma equação para profundidade Ptos no near (z=-n): Ptos no far (z=-f): [ H ] = n n n+f 0 0 n f 0

37 Transforma o prisma de visão cubo normalizado [-1,1]×[-1,1] ×[-1,1] xexe yeye zeze l r b t xexe yeye zeze -(r-l)/2 (r-l)/2 -(t-b)/2 (t-b)/2 (f-n)/2-(f-n)/2 xexe yeye zeze far near xnxn ynyn znzn near far

38 Matriz Frustum do OpenGL OpenGL Spec

39

40 Resumo das transformações (até o momento) xexe yeye zeze center eye zozo yoyo xoxo up xnxn ynyn znzn

41 zeze Projeção Paralela (Ortho) xexe yeye left right 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 ); eye direção de projeção

42 Matriz Ortho do OpenGL OpenGL Spec

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

44 Recorte

45 Diferentes problemas de recorte

46 Condição de pertinência p é interior p

47 Interseção de aresta × hiperplano intercepta segmento de reta ou aresta hiperplano

48 Recorte de segmentos com base no algoritmo Cohen- Sutherland A B C D

49 Casos de clipping de linhas A B C E (x 1, y 1 ) (x 2, y 2 ) D (x 1, y 1 ) (x 2, y 2 )

50 Códigos das regiões tbrl

51 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; } tbrl

52 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 de Cohen & Sutherland

53 Algoritimo de Cyrus-Beck (Liang-Barsky)

54

55 Entrando ou Saindo ?

56 Recorte de segmentos com base no algoritmo de Cyrus- Beck C B A tete tete tete tsts tsts tete tete tsts tsts tsts tsts tete n n n n

57 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; }

58 Liang e Barsky - caso particular - Ei N Ei P Ei t left: x = x min (-1, 0)(x min, y) -(x 0 -x min ) (x 1 -x 0 ) right: x = x max (1, 0)(x max, y) (x 0 -x max ) -(x 1 -x 0 ) bottom: y = y min (0,-1)(x, y min ) -(y 0 -y min ) (y 1 -y 0 ) top: y = y max (0, 1)(x, y max ) (y 0 -y max ) -(y 1 -y 0 ) x min x max y min y max x y

59 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; }

60 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; }

61 Recorte de polígonos com base no algoritmo de Hodgman-Sutherland Clip contra uma aresta (plano) de cada vez

62 Classificação de um segmento contra um hiperplano no algoritmo de Hodgman-Sutherland Saída: p Saída: i Saída: i, p internosaindoexternoentrando(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 s p s p s p i s pi

63 Exemplo do algoritmo de Hodgman- Sutherland 1 5 AB C D E F AB C D AB C D E F spsaída 12A 23 34B e C 61D e 1 spsaída ABB B4E 45F e 5 5CC CDD D11 1AA

64 Clipping de polígonos (Exemplo 1) A B SPAção 12x 23store A,3 34store 4 45store 5 56store B 61x

65 Clipping de polígonos (Exemplo 2) 1 SP Ação 12store A 23x 34store B,4 45store 5 56store C 61store D, AB C D xxxx B C D A

66 Clipping de polígonos (Exemplo 2) 1 SPAção 1Astore 1, A ABstore B B4store E 45store F,5 5Cstore C CDstore D 4 5 AB C D xxxx E F x x D1x B, E, F, 5, C, D, 1, A

67 Clipping de polígonos (Concatenação de planos) 1 A B 4 5 C AB C D xxxx E F x x D 1, A, B, E, F, 5, C, D AB C D xxxx 1 5 AB C D xxxx E F x x first[0] S[0] P[0] first[1] S[1] P[1]

68 APIs para definição de polígonos int 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( ); }

69 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: p Saída: i Saída: i, p internosaindoexternoentrando(a)(b)(c)(d) s p s p s p i s pi

70 Recorte de polígono contra um plano 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 ); } x min x max y min y max x y

71 Recorte de polígono contra um plano 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; }

72 Recorte de polígono contra um plano 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); }

73 Regiões de recorte do rendering pipeline xexe yeye zeze center eye zozo yoyo xoxo up xnxn ynyn znzn -1 x n 1 -1 y n 1 -1 z n 1

74 Problema do clipping no R 3 w xexe yeye zeze p1p1 p2p2 xexe yeye zeze

75 Escolhas dos hiperplanos do PR 3 ynyn 1 xnxn OpenGL Spec

76 Cálculo das distâncias aos hiperplanos no PR 3 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 ); } hiperplano intercepta

77 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];

78 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 ); }

79 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( ); Begin(FILL); Vertex(30.,20.); Vertex(15.,18.); … End( );

80 Transformação para o viewport xnxn ynyn znzn void glViewport(int x0, int y0, int w, int h ); z w [0.. z max ], z max = 2 n -1 geralmente xwxw ywyw w h 0 y0y0 x0x0

81 Mapa de profundidade 1 zeze znzn n=1 n=10 n=30 -f=-100

82 Mapa de profundidade

83 Transformações de um vértice OpenGL Spec

84 Modelo do Pintor profundidade z

85 ZBuffer: idéia básica z MATRIZ DE PROFUNDIDADES

86 ZBuffer - pseudo-código void ZBuffer( void) { int x,y; for (x=0; x

87 Rastreio de Polígonos e Linhas

88 Coordenadas de um ponto na janela (windows coordinate) w=6 e h=5 ponto: (3,2) tamanho 1 sem anti-alias ponto: (3,3) tamanho 3 sem anti-alias OpenGL Spec xwxw ywyw

89 Critério geométrico para linhas horizontais, verticais e à linha: (0,0),(4,0) linha: (5,1),(5,4) linha: (0,2),(3,5)

90 Critério geométrico de Bresenham (1965) para linhas linha: (0,0),(5,2) x dominante x dominante, um pixel por colunay dominante, um pixel por linha

91 Critérios geométricos para linhas do OpenGL linha: (0,0),(5,2) Bresenham (1965) OpenGL spec

92 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)); } Podemos evitar a multiplicação?

93 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)); } Podemos evitar o uso de ponto flutuante?

94 Equação implícita da reta x1x1 x2x2 y1y1 y2y2 x y

95 Equação básica do algoritmo do ponto médio para linhas e ne xpxp ypyp m xp+1xp+1 xp+2xp+2 y p +1/2 yp+1yp+1 yp+2yp+2 meme e ne e xpxp xp+1xp+1 xp+2xp+2 ypyp m y p +1/2 yp+1yp+1 yp+2yp+2 m ne e ne

96 Algoritimo do ponto médio - redução para inteiros - e ne e xpxp xp+1xp+1xp+2xp+2 ypyp m y p + 1/2 y p + 3/2 m ne meme

97 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

98 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

99 Critério geométrico para rastreio de elipses e se m meme m se F(x,y) = 0 x 45 o y

100 Rastreio de círculos x=0,y=raio; fragmento(x,y); while (x

101 Rastreio de polígonos

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

103 Preenchimento de polígonos y ysys x xi4xi4 y max y min 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= {x i1, x i0, x i4, x i3 } i0i0i1i1i3i3i4i4 xi1xi1 xi0xi0 xi3xi3

104 Interseção nos vértices inclui vértices: i0-i1, i2-i3, i4-? não inclui vértices: i0-? x y ysys i0i0 i2i2 i3i3 0 i1i1 i4i4 3 x y ysys i0i0 i2i2 i3i3 0 i1i1 i4i4 3 x y ysys i0i0 i2i2 i3i3 0 i1i1 i4i4 3 Solução: x y ysys i0i0 0 i4i4 3 ou x y ysys i0i0 i2i2 i3i3 0 i1i1 3

105 Otimização do algoritmo de preenchimento: interpolação linear Interpolação linear na aresta ys+1ys+1 dy = 1 x y y0y0 y1y1 ysys x1x1 x0x0 0 xixi x i+1

106 Otimizações do algoritmo de preenchimento: triângulos B C a b c x y A

107 Posições possíveis de um triângulo dado y A y B y C B C a b c x y A x y B C a b c A

108 Rastreio de triângulo B C a b c x y A yCyC yAyA yByB xaxa xbxb ysys B C a b c x y A yCyC yAyA yByB xcxc xbxb ysys

109 Interpolação perspectiva plano de projeção z eye

110 Interpolação perspectiva z eye n=1

111 Interpolação de atributos OpenGL Spec

112 Interpolação de atributos homogêneos OpenGL Spec

113 Suavização da tonalização c1c1 c4c4 c2c2 c3c3 c 12 c 43 c Gouraud void glShadeModel (GL_FLAT); void glShadeModel (GL_SMOOTH);

114 Interpolação da profundidade

115 Uma outra forma de ver a interpolação da profundidade z y y z z y -n -f

116 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); }

117 Exercício 1 zeze xexe yeye eye xexe zeze near left right far near yeye far top botton zeze Derive a matriz de projeção da seguinte câmera

118 FIM

119 Cor e iluminação

120 Luzes

121 Pipeline visualização ou Cadeia de rendering

122 BSP Partição Binária do Espaço (Binary Space Partition)

123 Modelo do Pintor profundidade z

124 Problemas na ordenação de faces + + zaza zbzb (a) (b)

125 BSP trees: Binary Space Partion Trees a 5b a 4 5b atrásfrente a 5b 3 4 5b atrásfrente 2 atrás 5a b 3 2 5a 1 4 5b

126 Exibição de uma BSP void bspDisplay(bspTree *tree) { if (arvore não é vazia) { if (observador está a frente da raiz) { bspDisplay(tree backChild); DisplayPolygon(tree root); bspDisplay(tree frontChild); } else { bspDisplay(tree frontChild); DisplayPolygon(tree root); bspDisplay(tree backChild); } Mostra a árvore de trás, a raiz e a árvore da frente. Mostra a árvore da frente, a raiz e a árvore de atrás.

127 BSP trees: Dois exemplos de exibição a 5b 3 2 5a 1 4 5b 5a, 2, 1, 3, 5b, a 5b 3 2 5a 1 4 5b 4, 5b, 3, 5a, 2, 1

128 Sistema de Coordenadas do Modelo

129 OpenGL: Linha de produção de imagens

130 Câmera

131 O Equação de um plano N=(A,B,C) P=(x,y,z) x y z P0P0 N.P = N.(P 0 + P) = N.P 0 = d P d = Ax + By + Cz d N.P = Ax + By + Cz Ax + By + Cz +D = 0 (A, B, C) = N e D = -d = N.(-P 0 ) (A, B, C) = N e D = -d = N.(-P 0 )

132 O Distância de um ponto a um plano N=(A,B,C) P=(x,y,z) PpPp x y z P N.P = Ax + By + Cz N. P = Ax + By + Cz+D N.P p = d = -D N. P = N.P - N.P p

133 Interseção de reta com plano P1P1 P2P2 x y z d 1 = Ax 1 + By 1 + Cz 1 +D d1d1 d2d2 d 2 = Ax 2 + By 2 + Cz 2 +D P P = d 1 P 2 - d 2 P 1 d 1 - d 2

134 Projeção de Vértices xhyhzhwxhyhzhw xyz1xyz1 m 11 m 12 m 13 m 14 m 21 m 22 m 23 m 24 m 31 m 32 m 33 m 34 m 41 m 42 m 43 m 44 = P P z x y P xyzxyz = P = xyzxyz x h /w y h /w z h /w = xdxd ydyd zdzd near far

135 Clipping em coordenadas homogêneas x [left, right] y -1 x h /w 1 1 x x h /w 1 x h w, se w>0 x h w, se w<0 OpenGL Spec

136 Região de recorte no espaço normalizado -1 x h /w 1 -1 y h /w 1 -1 z h /w 1 -1 x n 1 -1 y n 1 -1 z n 1 x [left, right] y [bottom, top] z [near, far] xnxn ynyn znzn near far right left bottom top

137 Mapa de profundidade -n -f

138 Efeito de profundidade x y x y

139 Critério geométrico de Bresenham (1965) para linhas x = 5, y =3


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

Apresentações semelhantes


Anúncios Google