b A*b Texture Matrix Stack Vertices Coordinates Begin/End Clamp to [0,1] Primitives Assembly Mask to [0,2 n!1 ] Enable/Disable

Transcription

1 EnableClientState DisableClientState EdgeFlagPointer TexCoordPointer ColorPointer IndexPointer NormalPointer VertexPointer InterLeavedArrays ArrayElement Vertex Array Control MapGrid EvalMesh Grid EvalPoint Application Evaluator Control The OpenGL Machine R DrawElements DrawArrays Map EvalCoord Evaluation The OpenGL! graphics system diagram, Version 1.1. Copyright " 1996 Silicon Graphics, Inc. All rights reserved. Map Enable/Disable EdgeFlag Current Edge Flag Enable/Disable TexCoord1 t 0 TexGen TexCoord2 r 0 OBJECT_LINEAR TexGen EYE_LINEAR TexGen b A*b A SPHERE_MAP Texture TexCoord3 TexCoord4 q 1 Current Texture TexGen Matrix Stack Vertices Coordinates Color3 Color4 Index A 1 Convert RGBA to float Convert index to float Current RGBA Color Current Color Index Enable/Disable Enable/Disable ColorMaterial Material Material Parameters Control Light Light Enable/Disable Parameters LightModel Material Light Model Parameters Parameters Begin/End Evaluators & Vertex Arrays Input Conversion & Current Values Texture Coordinate Generation Lighting Normal3 Convert normal coords to float Current Normal b M M*b Normalize RGBA Lighting Equation Color Index Lighting Equation Clamp to [0,1] Mask to [0,2 n!1 ] Primitive Assembly Vertex2 RasterPos2 Vertex3 RasterPos3 Vertex4 RasterPos4 Rect z 0 w 1 Rectangle Generation OBJECT COORDINATES M!T M M b M*b M EYE COORDINATES FrontFace Enable/Disable (Lighting) Matrix Control Clipping, Perspective, and Viewport Application Feedback & Selection Rasteriz! ation Pixels Texturing, Fog, and Antialiasing Per!Fragment Operations Frame Buffer & Frame Buffer Control Primitives Fragments Model View Matrix Stack Key to OpenGL Operations MatrixMode PushMatrix PopMatrix LoadIdentity LoadMatrix Matrix Control M*N N M ShadeModel ClipPlane b M M!T b Clip Planes Projection Matrix Stack Viewport DepthRange FrontFace PolygonMode CullFace Polygon Polygon Culling Mode Enable/Disable (Antialiasing/Stipple) PolygonOffset Polygon Rasterization Enable/Disable (Antialiasing) LineStipple MultMatrix Translate Scale Rotate Frustum Ortho Matrix Generators POLYGONS LINE SEGMENTS POINTS RASTER POS. Flatshading Polygon Clipping Line Clipping Point Culling b M M*b b M*b (Vertex Only) b M*b Polygon View Volume Clipping Line View Volume Clipping Point View Volume Culling Divide Vertex Coordinates by w Apply Viewport LineWidth Line Segment Rasterization Enable/Disable (Antialiasing) PointSize TexParameter Enable/Disable TexEnv Enable/Disable Fog Enable/Disable Enable/Disable Enable/Disable Enable/Disable StencilOp Enable/Disable Enable/Disable Enable/Disable Enable/Disable Scissor AlphaFunc StencilFunc DepthFunc BlendFunc LogicOp Current Raster Point Rasterization Texel Generation Texture Application Fog Coverage (antialiasing) Application Pixel Ownership Test Scissor Test Alpha Test (RGBA only) Stencil Test Depth Buffer Test Blending (RGBA only) Dithering Logic Op Position Notes: 1. Commands (and constants) are shown without the gl (or GL_) prefix. 2. The following commands do not appear in this diagram: glaccum, glclearaccum, glhint, display list commands, texture object commands, commands for obtaining OpenGL state (glget commands and glisenabled), and glpushattrib and glpopattrib. Utility library routines are not shown. 3. After their exectution, gldrawarrays and RenderMode Selection Encoding Selection Control Feedback Encoding Clear DepthMask PassThrough PolygonStipple PixelZoom Values StencilMask Selection Roma Tre, DIA, Informatica Grafica AA 2006 SelectBuffer Name FeedbackBuffer Bitmap Stack Unpack DrawPixels Pixel ClearStencil Pixels Rasterization ClearDepth TexImage Pixel Transfer Texture ClearIndex InitNames TexSubImage Frame Buffer Memory ClearColor Masking Frame Buffer LoadName Control PopName PixelStore PushName PixelTransfer ColorMask DrawBuffer PixelMap IndexMask gldrawelements leave affected current values indeterminate. 4. This diagram is schematic; it may not directly correspond to any actual OpenGL implementation. ReadPixels Pack Pixels Bitmap Rasterization CopyPixels CopyTexImage CopyTexSubImage Clear Clear Control Masking ReadBuffer Readback Control Esercitazione 15/3/2005 Portuesi Simone

2 Menu del giorno Modello di Vista OpenGL Modello di Vista OpenGL Viewport Proiezioni Ortografiche & Prospettiche LookAt Confronto con PHIGS Esercizio: Modello PHIGS in OpenGL Richiami Trasformazioni

3

4 Viewport Transformation void glviewport( GLint x, GLint y, GLsizei width, GLsizei height ) x, y - Lower left corner of the viewport rectangle, in pixels. width, height - Width and height of the viewport.

5 Device Coordinates: DC=[1,1] [HW,WW] N N Normalized Device Coordinates: NDC=[-1,-1] [1,1] R R YDC (1, HW) (0,-1) YNDC (w+width, h+height) (x dc,y dc)=(x ndc,y ndc)? (-1,0) XNDC (0,0) (1,0) (w, h) (0,-1) (1,1) (WW, 1) XDC

6 XDC width/2 0 w+width/2 XNDC YDC = 0 height/2 h+ height/2 YNDC

7 Orthographic Projection void glortho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far ) left, right - Left and right vertical clipping/viewbox planes. bottom, top - Bottom and top horizontal clipping/viewbox planes. near, far - Nearer and farther depth clipping/viewbox planes. glortho describes a perspective matrix that produces a parallel projection. (left, bottom, -near) and (right, top, -near) specify the points on the near clipping plane that are mapped to the lower left and upper right corners of the window, respectively, assuming that the eye is located at (0, 0, 0). -far specifies the location of the far clipping plane. Both near and far can be either positive or negative.

8

9 (-1,1) L (-1,-1) ZNDC (0,1) (0,0) (0,-1) ZEYE -Near -Far (0,0,0) (1,1) R (1,-1) XEYE XNDC

10 N=-near F=-far YEYE (L,T,F)=(-1,1,-1) YNDC (R,T,F)= (1,1,-1) (L,T,N)=(-1,1,1) (R,T,N)=(1,1,1) (L,B,F) =(-1,-1,-1) (0,0,0) XNDC (R,B,F) = (1,-1,-1) ZNDC (L,B,N)= (-1,-1,1) (0,0,0) (R,B,N)=(1,-1,1) XEYE ZEYE

11 Perspective Projection void glfrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far ) left, right - Left and right vertical side of the viewing box at near plane Left and right clipping planes bottom, top - Bottom and top horizontal of the viewing box at near plan Bottom and left clipping planes near, far - Near and far depth clipping planes. Both distances must be positive. glfrustum describes a perspective matrix that produces a perspective projection. (left, bottom, -near) and (right, top, -near) specify the points on the near clipping plane that are mapped to the lower left and upper right corners of the window, respectively, assuming that the eye is located at (0, 0, 0). -far specifies the location of the far clipping plane. Both near and far must be positive.

12 z-buffer-bits= log2(r)

13 (-1,-1) (-1,1) L (0,-1) ZNDC (0,1) (0,0) ZEYE Near Far R (1,1) (1,-1) XEYE XNDC

14 (L*F/N,T*F/N,F)=(-1,1,-1) (R*F/N,T*F/N,N)= (1,1,-1) (L,T,N)=(-1,1,1) (R,T,N)=(1,1,1) XEYE (L*F/N,B*F/N,N)=(-1,-1,-1) (R*F/N,B*F/N,N) =(1,-1,-1) (L,B,N)=(-1,-1,1) (R,B,N)=(1,-1,1) XEYE ZEYE

15 void gluperspective( GLdouble fovy, GLdouble aspect, GLdouble znear, GLdouble zfar ) fovy - Field of view angle, in degrees, in the y direction. aspect - Fspect ratio that determines the field of view in the x direction. znear - Distance from the viewer to the near clipping plane (always positive). zfar - Distance from the viewer to the far clipping plane (always positive).

16 View Orientation Ora occorre inquadrare il modello nel volume di vista Ovvero spostare il mondo per farlo inquadrare il punto di vista E una normale trasformazione affine E più intuitivo posizionare e direzionare il punto di vista rispetto al mondo

17 Sia (Ex,Ey,Ez) la posizione voluta del punto di vista Effettuare una Traslazione tale da portare l origine in (-Ex,-Ey,-Ez) Ruotare in modo da vedere nella direzione giusta In casi semplici si può fare a mano

18 Yeye YWC (-Cx,-Cy,-Cz) Xeye XWC Zeye ZWC

19 YWC Yeye Xeye (-Cx,-Cy,-Cz) XWC ZWC Zeye

20 void glulookat( GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz ) eyex, eyey, eyez - Specifies the position of the eye point. centerx, centery, centerz - Specifies the position of the reference point. upx, upy, upz - Specifies the direction of the up vector. Yeye=(UPx,UPy,UPz) YWC Non esattamente Esatto se UP (C-E) Zeye (Ex,Ey,Ez) XWC (Cx,Cy,Cz) Xeye ZWC

21 A convenient way 1 to specify a virtual camera is to give the position of the eyepoint E, a point on the viewing direction R (reference point) and a direction V which should point upwards in the desired image

22 PHIGS

23 PHIGS uses 4 transformations to specify a view and a projection whereas OpenGL only uses 3. The view-orientation transformation in PHIGS translates the reference point to the origin of the normalized projection coordinate system, whereas in OpenGL the viewing transformation moves the eyepoint to the origin of the eye coordinate system. PHIGS performs clipping in the canonical view volume [-1,+1][-1,+1][-1,0], while OpenGL clips in [-1,+1][-1,+1] [-1,+1].

24 View Orientation VRP - View Reference Point Posizione nelle WC dell origine delle VRC VPN - View Plane Normal Versore nelle WC dell asse Z delle VRC (n) VUP - View Up Projection Versore nelle WC tale che se projettato sulla View Plane dà la direzione Y (v) L asse X è Y Z

25

26 Vvrc YWC Nvrc =VPN VRP XWC Uvrc ZWC

27

28 PHIGS->OpenGL VRP = EYE VPN / VPN = (EYE-CENTER) / (EYE- CENTER) VPN= EYE - CENTER CENTER = EYE - VPN VUP = UP Peccato VRP non è EYE!!!! ( VRP!=EYE ) Modifica in modo subdolo le proiezioni

29 /* If true implements PHIGS model using GL view as much as possible */ int useglprim=0; /* PHIGS View Orientation */ struct PHIGS_ViewOrientation { double vrp[3]; double vpn[3]; double vuv[3]; }; /* Macros for inline Vectro op, use with care */ /* apply (_ op c) to all elements of vector, result in vr */ #define VECT_OP_SCAL(vr,op,v1,c) { int i; for(i=0;i<3;i++) vr[i]=v1[i] op c; } /* apply (a op b) to every pair of coordinates, result in vr */ #define VECT_OP_VECT(vr,op,v1,v2) { int i; for(i=0;i<3;i++) vr[i]=v1[i] op v2[i]; } /* Vector norm, immediate result */ #define NORM_VECT(v) sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]) /* Vectro cross product vr= v1 x v2 */ #define CROSSPROD(vr,v1,v2) { vr[0]=v1[1]*v2[2]-v1[2]*v2[1]; \ vr[1]=v1[2]*v2[0]-v1[0]*v2[2]; \ vr[2]=v1[0]*v2[1]-v1[1]*v2[0]; }

30 void PHIGS_ViewOrientation(struct PHIGS_ViewOrientation *orientation) { /* Model Matrix */ glmatrixmode(gl_modelview); /* Load identity */ glloadidentity(); if(useglprim) {/* Try to use GL */ double center[3]; /* center = vrp - vpn */ VECT_OP_VECT(center,-,orientation->vrp,orientation->vpn); /* Look at */ glulookat(orientation->vrp[0],orientation->vrp[1],orientation->vrp[2], center[0],center[1],center[2], orientation->vuv[0],orientation->vuv[1],orientation->vuv[2]); } else { /* Do everything by hand */

31 } else { /* Do everythin by hand */ double rn[3],ru[3],rv[3]; double matrix[4][4]= { { 1, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 1 } }; double norm; /* Rn = VPN / VPN */ norm=norm_vect(orientation->vpn); VECT_OP_SCAL(rn,/,orientation->vpn,norm); /* Ru = VUV x RN */ /* Ru = Ru / Ru */ CROSSPROD(ru,orientation->vuv,rn); norm=norm_vect(ru); VECT_OP_SCAL(ru,/,ru,norm); /* Rv = Rn x Ru */ CROSSPROD(rv,rn,ru);

32 /* Insert Ru, Rv, Rn in Rotation Matrix */ matrix[0][0]=ru[0]; matrix[1][0]=ru[1]; matrix[2][0]=ru[2]; matrix[0][1]=rv[0]; matrix[1][1]=rv[1]; matrix[2][1]=rv[2]; matrix[0][2]=rn[0]; matrix[1][2]=rn[1]; matrix[2][2]=rn[2]; /* Rotate Translate(-VRP) */ glmultmatrixd(matrix); gltranslated(-orientation->vrp[0], -orientation->vrp[1], -orientation->vrp[2]); } }

33 View Map // PHIGS Coordinate in VRC degli estremi del volume di vista: (umin, umax, Vmin, Vmax, F=Nmin, B=Nmax ) In genere N=Nmin>0 ed F=Nmax<0 Vettore DOP=(Dopx, Dopu, Dopz) in VRC. (Direction of Projection) Non esiste in OpenGL. E la direzione di proiezione. Permette assonometrie non orthografiche. Il View volume in NDC è [-1,1]x[-1,1]x[0,-1]

34 (-1,0) umin ZNDC PRP DOP (0,0) (-1,-1) CW N =VPN Front=nmin (0,0,0)=VRP Back=nmax (0,-1) (1,0) umax (1,-1) XNDC U

35 CW=((umax +umin )/2, (umax +umin )/2,0) V vmax CW umin (0,0,0)=VRP umax U DOP vmin PRP (0,0,-1)=VPN N

36 Da definizione PHIGS:

37 View Model Parallel: VMPAR=TPAR ~ SPAR ~ SHPAR

38

39 Parallel: PHIGS -> OPENGL In OpenGL si assume DOP // ZEYE Occorre implementare lo Shearing Volume unitario è diverso Il piano di proiezione è in VRC (PHIGS) vs FRONT (GL). Non è un grosso problema perchè dopo shearing i piani L,R,T,B sono alla direzione proiezione.

40 /* Parallel or central projection */ enum PHIGS_PrjType { PARALLEL, PERSPECTIVE }; /* View Box */ struct PHIGS_box { double u_min; double v_min; double u_max; double v_max; double front; double back; }; /* PHIGS Viee Mapping Data */ struct PHIGS_ViewMapping { enum PHIGS_PrjType prjtype; double prp[3]; struct PHIGS_box box; };

41 void PHIGS_ViewMapping(struct PHIGS_ViewMapping *view) { double DOP[3]; double SHpar[4][4]= { { 1, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 1 } }; /* DOP = Center BOX - PRP */ DOP[0] = ( view->box.u_max + view->box.u_min ) / 2 - view->prp[0]; DOP[1] = ( view->box.v_max + view->box.v_min ) / 2 - view->prp[1]; DOP[2] = -view->prp[2]; /* Shear factors SHx = DOPx / DOPz, Shy= DOPy / DOPz */ SHpar[2][0]= - DOP[0] / DOP[2]; SHpar[2][1]= - DOP[1] / DOP[2]; /* Projection Matrix */ glmatrixmode(gl_projection); glloadidentity(); if(view->prjtype==parallel) {

42 if(view->prjtype==parallel) { if(useglprim) { /* Use GL prim */ /* Just do it (need to compose SHEAR yet ) */ glortho( view->box.u_min, view->box.u_max, view->box.v_min, view->box.v_max, -view->box.front, view->box.back ); } else { /* Set default viev voume, (GL clip planes) */ glortho( -1, 1, -1, 1, -1, 1); /* Spar ~ Tpar */ gltranslated( - ( view->box.u_min + view->box.u_max ) / 2, - ( view->box.v_min + view->box.v_max ) / 2, - ( view->box.front + view->box.back ) / 2 ); glscaled( 2 / ( view->box.u_max - view->box.u_min ), 2 / ( view->box.v_max - view->box.v_min ), 2 / ( view->box.front - view->box.back ) ); } /* Multiply (post compose) shear matrix */ glmultmatrixd(shpar); } else { /* TBD */

43 struct ViewPoints viewpoints[] = { { "onepoint", { { { 0,5,4 }, { 1,0,0 }, { 0,0,1 } }, { PERSPECTIVE, { 0,0,35 }, { -1, -1, 1, 1, 0, -1,} } } }, { "twopoint", { { { 0,0,4 }, { 3,2,0 }, { 0,0,1 } }, { PERSPECTIVE, { 0,0,35 }, { -1, -1, 1, 1, 0, -1,} } } }, { "threepoint", { { { 0,5,4 }, { 3,2,1 }, { 0,0,1 } }, { PERSPECTIVE, { 0,0,35 }, { -1, -1, 1, 1, 0, -1,} } } }, { "orthox", { { { 0,0,0 }, { 1,0,0 }, { 0,0,1 } }, { PARALLEL, { 0,0,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "orthoy", { { { 0,0,0 }, { 0,1,0 }, { 0,0,1 } }, { PARALLEL, { 0,0,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "orthoz", { { { 0,0,0 }, { 0,0,1 }, { 0,-1,0 } }, { PARALLEL, { 0,0,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "isometric", { { { 0,0,0 }, { , , }, { 0,0,1 } }, { PARALLEL, { 0,0,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "dimetric", { { { 0,0,0 }, { , , }, { 0,0,1 } }, { PARALLEL, { 0,0,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "trimetric", { { { 0,0,0 }, { , , }, { 0,0,1 } }, { PARALLEL, { 0,0,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "central cavalier", { { { 0,0,0 }, { 0,0,1 }, { -1,-1,0 } }, { PARALLEL, { 0,-1,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "left cavalier", { { { 0,0,0 }, { 0,0,1 }, { -0.5, ,1 } }, { PARALLEL, { 0,-1,1 },{ -1, -1, 1, 1, 1, -1,} } } }, { "right cavalier", { { { 0,0,0 }, { 0,0,1 }, { ,0.5,1 } }, { PARALLEL, { 0,-1,1 },{ -1, -1, 1, 1, 1, -1,} } } }, { "cabinet", { { { 0,0,0 }, { 0,1,0 }, { 0,0,1 } }, { PARALLEL, { , ,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "xcavalier", { { { 0,0,0 }, { 0,0,1 }, { 0,-1,0 } }, { PARALLEL, { 0,-1,1 }, { -1, -1, 1, 1, 1, -1,} } } }, { "ycavalier", { { { 0,0,0 }, { 0,0,1 }, { -1,0,0 } }, { PARALLEL, { 0,-1,1 }, { -1, -1, 1, 1, 1, -1,} } } } };

44 Re-implementare tutta la trasformazioni (modificandole per VBOX) Effettuare Shear e chiamare glortho con i parametri modificati. Attenzione a Front/Back vs Near/Far

45 View Map Centrale PHIGS Coordinate in VRC degli estremi del volume di vista: (umin, umax, Vmin, Vmax, F=Nmin, B=Nmax ) In genere F=Nmin>0 ed B=Nmax<0 PRP=COP=(Copx, Copy, Copz) in VRC. (Center of Projection) In OpenGL è (0,0,0) Il View volume in NDC è [-1,1]x[-1,1]x[0,-1]

46 (-1,0) umin (-1,-1) COP=PRP ZNDC (0,0) CW N =VPN Front=nmin (0,0,0)=VRP Back=nmax (0,-1) (1,0) umax XNDC U (1,-1)

47 View Model Perspective: VMPER=M ~ SPER ~ SHPAR~T(-PRP)

48

49 y y y=(vmax-vmin)/2 y = -z z=vrp' + F z z=vrp' z z=vrp' + B z -z z = z min -1 -z y = z

50

51 Parallel: PHIGS -> OPENGL Open GL implementa proiezioni obligue modificando il Box (VRP=Box Center) PHIGS usa un VRP esplicito (centro VRC) Il piano di proiezione è in VRC (PHIGS) vs FRONT (GL). Questo è un problema.

52 Trasformazioni

53

54 Stack Matrici su cui operare void glmatrixmode( GLenum mode ) GL_MODELVIEW, GL_PROJECTION, and GL_TEXTURE. Carica Matrice identità void glloadidentity( void ) Carica matrice void glloadmatrixd( const GLdouble *m ) void glloadmatrixf( const GLfloat *m ) Multiplica per matrice void glmultmatrixd( const GLdouble *m ) void glmultmatrixf( const GLfloat *m ) glmultmatrix multiplies the current matrix with the one specified in m. That is, if M is the current matrix and T is the matrix passed to glmultmatrix, then M is replaced with M T.

55 void glrotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) void glrotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) void glscaled( GLdouble x, GLdouble y, GLdouble z ) void glscalef( GLfloat x, GLfloat y, GLfloat z ) void gltranslated( GLdouble x, GLdouble y, GLdouble z ) void gltranslatef( GLfloat x, GLfloat y, GLfloat z )

56 C SPECIFICATION void glpushmatrix( void ) void glpopmatrix( void ) DESCRIPTION There is a stack of matrices for each of the matrix modes. In GL_MODELVIEW mode, the stack depth is at least 32. In the other two modes, GL_PROJECTION and GL_TEXTURE, the depth is at least 2. The current matrix in any mode is the matrix on the top of the stack for that mode. glpushmatrix pushes the current matrix stack down by one, duplicating the current matrix. That is, after a glpushmatrix call, the matrix on the top of the stack is identical to the one below it. glpopmatrix pops the current matrix stack, replacing the current matrix with the one below it on the stack.

57 glclear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT); glpushmatrix (); glrotatef (20.0, 1.0, 0.0, 0.0); glpushmatrix (); gltranslatef (-0.75, 0.5, 0.0); glrotatef (90.0, 1.0, 0.0, 0.0); glutsolidtorus (0.275, 0.85, 15, 15); glpopmatrix (); glpushmatrix (); gltranslatef (-0.75, -0.5, 0.0); glrotatef (270.0, 1.0, 0.0, 0.0); glutsolidcone (1.0, 2.0, 15, 15); glpopmatrix (); glpushmatrix (); gltranslatef (0.75, 0.0, -1.0); glutsolidsphere (1.0, 15, 15); glpopmatrix (); glpopmatrix (); glflush ();