3 D

grafica in tre dimensioni : visualizzazione su schermo (2D) di un "mondo" ovvero una "scena" di un insieme di oggetti a 3 dimensioni in questa parte sono presentati cenni su : orientamento del sistema degli assi in 3 D trasformazioni geometriche in 3 D passaggio da 3 D a 2 D : le proiezioni cenni di storia della prospettiva cenno sulla struttura dell' OpenGL (gl,glu,glut), tipi di prospettive (parallele, prospettiche)

3 D - geometria, prospettive, OpenGL 3D mondo oggetto, coordinate xw,yw,zw (world coord) mondo del centro vista, coordinate xv,yv,zv (viewing pnt)

il passaggio dal piano 2D (visto finora) al 3D presenta subito un'ambiguita' che comporta una scelta di orientamento: in 2D, l'orientamento degli assi ( coordinate x,y) e' sempre (*) * asse delle ascisse x orientato a destra, e * asse delle ordinate y orientato verso l'alto, nel caso dello spazio 3D sono usato due sistemi di riferimento in entrambi gli assi x e y sono orientati come usuale (colleghiamo l'asse x con il pollice e l'asse y con l'indice), per l'asse z abbiamo: * sistema destrorso abbiamo l'asse z orientato verso fuori (mano destra: asse x=pollice, asse y= indice, asse z=medio) (verso l'osservatore) * sistema sinistrorso: l'asse z e' orientato verso dentro (mano sinistra : asse x=pollice, asse y=indice, asse z=medio) (via dall'osservatore) graficamente... (*) o quasi

z y y x x sistema destrorso - regola della mano destra: x=pollice, y=indice, z=medio (esce dallo schermo) - in grafica e' il piu' usato, l' OGL usa questo sistema sinistrorso - regola della mano sinistra: x=pollice, y=indice, z=medio (entra nello schermo) meno usato

trasformazioni geometriche ricorda le trasformazioni geometriche in 2D: coordinate (x,y), trasformazioni: scalatura: fattore di scala: Sx, Sy rotazione: angolo: Θ traslazione: posizione: x, y inclinazione o scorrimento dei piani (shear), e altro, riflessione ecc

trasformazioni geometriche trasformazioni geometriche in 2D: coordinate (x,y), il OpenGL usa coordinate omogenee (x,y,h) trasformazioni: scalatura: fattore di scala: 2 parametri Sx, Sy rotazione: angolo: 1 parametro Θ traslazione: posizione: 2 parametri x, y la rotazione si intende sempre attorno l'asse z perpendicolare al piano x,y L'OpenGL prevede apposite funzioni per posizionare le matrici di trasformazione - dati i parametri essenziali riportati sopra

trasformazioni in 2D: coordinate omogenee (x,y,h) // ricordiamo la trafila per trasformazione in 2D // per disegnare una parte in posizione voluta: glMatrixMode(GL_MODELVIEW); // seleziona quale matrice glPushMatrix(); glLoadIdentity(); // azzera; segue: glTranslatef(xt, yt, 0.0); //rotaz attorno punto(x,y): 1)trasl 2)rotaz 3)traslIndiet glTranslatef(MyBariX, MyBariY, 0.0); glRotatef(MyAlfa, 0.0, 0.0, 1.0); glTranslatef(-MyBariX,-MyBariY,0.0); //scala attorno punto(x,y): 1)trasl 2)scala 3)traslIndiet glTranslatef(MyBariX,MyBariY,0.0); glScalef( MyScala, MyScala, 1.0); glTranslatef(-MyBariX,-MyBariY,0.0); MyRect( 0.5, 0.5, 0.5 ); // disegna qualcosa glPopMatrix(); //elimina trasformaz.da ultima push // fine trasforma e disegna una parte

trasformazioni in 3D: coordinate omogenee (x,y,h) 3 D - geometria: anche in 3D per le trasformazioni geometriche conviene passare dalle coordinate cartesiane (x,y,z) alle coordinate omogenee (x,y,z,h), e le trasformazioni di traslazione (posizione) e scala sono espresse dalle matrici di trasformazione: trasla o riposiziona ha 3 parametri: dx, dy, dz glTranslatef (dx,dy,dz); sx 0 0 0 0 sy 0 0 0 0 sz 0 0 0 0 1 0 0 dx 0 1 0 dy 0 0 1 dz 0 0 0 1 la scala ha 3 parametri: Sx, Sy, Sz glScalef( MyScala, MyScala, 1.0);

glRotatef(MyAlfa, dirx, diry, dirz); trasformazioni in 3D: coordinate omogenee (x,y,h) 3 D - geometria: anche in 3D per le trasformazioni geometriche conviene passare dalle coordinate cartesiane (x,y,z) alle coordinate omogenee (x,y,z,h), la trasformazione di rotazione ha 4 parametri glRotatef(MyAlfa, dirx, diry, dirz); ( oppure si puo' definire con tre rotazioni attorno i tre assi x, y, z, di angoli ... Θ, Φ, Ψ ) ma .. richiede delle precisazioni ...

trasformazioni in 3D: coordinate omogenee (x,y,h) per specificare una rotazione nello spazio dobbiamo specificare un asse di rotazione V, e in relazione all' asse di rotazione definiremo l' angolo di rotazione OpenGL prevede la procedura di rotaz.generica : glRotatef(ang,Vx,Vy,Vz); (*) z x rotazione attorno asse z, sistema destro (*) MA nota: Vx,Vy,Vz e' una direzione, il punto di riferimento dell' asse e' l' origine !! e una rotazione generica ??

z OpenGL prevede la procedura di rotazione trasformazioni in 3D: coordinate omogenee (x,y,h) OpenGL prevede la procedura di rotazione glRotatef(ang,Vx,Vy,Vz); (*) V - asse di rotazione, ang = angolo di rotazione Verso rotazione: una rotazione attorno un asse V si intende positiva se e' in verso antiorario quando si guardi l'origine dell'asse V da una posizione generica del semiasse positivo: se mi metto su asse z (sist. destrorso, asse z in fuori) sul punto (0,0,1) del semiasse z positivo, allora una rotazione positiva ruotera' il piano x,y in verso antiorario y z x rotazione positi- va antioraria attorno asse z, sistema destro

che equivale alla matrice a sinistra: accanto alle trasformazioni di posizione e scala , che abbiamo visto c'e' la trasformazione di rotazione attorno un asse ad es. attorno l'asse z glRotatef(a, 0,0,1); che equivale alla matrice a sinistra: cos(a) -sin(a) 0 0 sin(a) cos(a) 0 0 0 0 1 0 0 0 0 1

che equivale alla matrice: accanto alle trasformazioni di posizione e scala , che abbiamo visto, c'e' la trasformazione di rotazione attorno un asse ad es. attorno l'asse z : glRotatef(a, 0,0,1); che equivale alla matrice: cos(a) -sin(a) 0 0 sin(a) cos(a) 0 0 0 0 1 0 0 0 0 1 Una rotazione attorno asse x e': 1 0 0 0 0 cos(a) -sin(a) 0 0 sin(a) cos(a) 0 0 0 0 1 ed e' data per esempio dalla glRotatef(a, 1,0,0);

la trasformazione sara' composta come segue: trasformazioni in 3D: rotazione generica: 0) rotazione generica di angolo a attorno ad un vettore v e un punto p (generici) , v y y la trasformazione sara' composta come segue: 1) traslazione del punto generico p nell'origine, affinche' l' asse di rotaz passi per l'origine; 2) rotazione di v attorno asse y finche' l'asse di rotaz v giace in piano y,z, 3) rotaz1 attorno asse x finche' l'asse di rotaz v coincide con l'asse z; 4) rotaz2 attorno z (che ora coincide con v) dell' angolo voluto a, v a p x p x z z 1) 2) y y v a p=(0,0,0) p x x z z=v a 3) 4)

e una rotazione generica di un oggetto (qui " ") di un angolo a trasformazioni in 3D: rotazione generica: e una rotazione generica di un oggetto (qui " ") di un angolo a attorno ad un vettore v asse che passa per un punto p (generico) ? nota: a,vx,vy,vz,px,py,pz 7 parametri ... v y a p x z 1)

rotazione generica attorno ad vettore v e punto p generici: la trasformazione sara' composta (come gia' visto per il 2D, ma qui i passi sono di piu' !!) come segue (ripeto i primi passi): 1) traslazione del punto generico p nell'origine, per fare in modo che l' asse di rotazione passi per l'origine; 2) rotazione di v attorno all'asse y finche' l'asse di rotazione v non giace nel piano y,z, e poi 3) attorno all'asse x fino a far coincidere l'asse di rotazione v con l'asse z; ora siamo in una situazione nota: 4) infine si ruota attorno l'asse z dell' angolo voluto a, e poi si rifanno i passi 1,2,3 a ritroso, 5) rotazione inversa di 3): il vettore v torna nel piano yz 6) rotazione inversa di 2): il vettore v torna com'era, ma in orig 7) traslazione inversa di 1): il vettore v torna al punto p ... e siamo a posto ;-) (7 trasformazioni!!)

proiezione 3D -> 2D il passaggio dal mondo 3D della scena composta da diversi oggetti al mondo 2D dello schermo dove si visualizza la scena implica vari sistemi di riferimento di coordinate

trasformazioni in 2D: tre sistemi di riferimento nel caso 2D abbiamo tre sistemi di coordinate nel mondo degli oggetti - 1) coordinate oggetto per il riferimento dei singoli elementi costitutivi dell' oggetto [ad es una mano rispetto il corpo] 2) coordinate riferimento dell' oggetto nel mondo della scena (trasformazione da coordinate della parte (dell'oggetto) alle coordinate della scena (mondo "utente") [ad es il corpo rispetto il centro stanza] 3) coordinate del dispositivo di visualizzazione (trasformazione window -> viewport->schermo )

trasformazioni in 3D: sei sistemi di riferimento nel caso 3D per il passaggio dal mondo oggetti al mondo del dispositivo di visualizzazione dobbiamo considerare piu' passaggi: coordinate mondo oggetti coordinate punto di vista ** proiezione (da 3D a 2D) coordinate piano di proiezione 2D passaggio finestra utente -> viewport coordinate dispositivo di visualizzazione

la proiezione di un oggetto 3D su un piano di proiezione 2D e' definita da un insieme di rette di proiezione ("proiettori") che hanno tutte un' origine comune nel punto "centro di proiezione" e congiungono il centro di proiezione con tutti i punti dell' oggetto; il centro di proiezione = punto di vista, dove immagino l'occhio dell'osservatore); e da un piano di proiezione centro di proiezione oggetto da rap- presen- tare raggi proiettori piano di proiezione

la proiezione di un oggetto 3D su un piano di proiezione 2D e' data dall' intersezione dei proiettori con il piano di proiezione; i proiettori = un insieme di rette di proiezione che hanno tutte un' origine comune nel punto "centro di proiezione" (punto di vista, dove possiamo immaginare l'occhio dell'osservatore) e passano per tutti i punti dell' oggetto; Si noti che in generale una proiezione puo' essere definita da "proiettori curve" (non rette) che passano tutte per il centro di proiezione e intersecano una superficie di proiezione (non piana) [altre applicazioni, in particolare, cartografia] centro di proiezione oggetto da rap- presen- tare proiettori piano di proiezione

3 D - geometria, prospettive, OpenGL 3D Pv Pw oggetto piano di proiezione punto di vista

un'osservazione banale: ben noto (oggi): oggetti a distanza diversa dal punto di vista appaiono di grandezza diversa sul piano di proiezione, e questo e' uno degli effetti visivi di lontananza (spesso usato)

prima della prospettiva ? prima della prospettiva il disegnatore non si poneva il problema della rappresentazione realistica di una scena: la scena "raccontava" una storia, con finalita' e tecniche molto diverse di oggi ... la prospettiva appare solo 550 anni fa ...

vediamo in circa 10 slide l' evoluzione del disegno PRIMA della prospettiva dalle figure rupestri di 20000 anni fa (paleolitico) agli affreschi Egiziani (4000 anni fa) alle immagini murali e dei vasi greci (2500 anni fa) (le immagini migliori su legno sono tutte andate perse), agli affreschi delle tombe greche (il tuffatore), alle iconografie bizantine (Ravenna) e romaniche (1200 anni fa) e gotiche (800 anni fa) fino a Giotto compreso (700 anni fa) ...

Pitture rupestri grotte di Lascaux (Pirenei, Francia) e dintorni Pitture risalenti al paleolitico 30.000 - 15.000 anni fa;

dopo piu' di 10.000 anni (quante generazioni a 10-15 anni per generazione?)

Nefertari Merytmut circa 1290-1255 BC, prima moglie di Ramses nell' atto di preghiera (circa il periodo in cui i fenici svilupparono l'alfabeto, ripreso vari secoli dopo dai greci)

Immagine dal " Libro delle preghiere dei morti " della tomba di Hunefer, circa 2000 b.c.

dopo circa 1500 anni (quante generazioni a 10-15 anni per generazione

alcune immagini greche di circa 500 anni prima di Cristo: tavoletta votiva con scena di sacificio alla grazia/nimfa Carithes, 530 b.c., pittura su legno, trovata in una grotta a Pitsa, Corinto

due scene murali dalla tomba di Paestum (vicino Eboli), cultura greca, 480 b.c. sopra: "symposium" o convivio, sotto: "il tuffatore"

circa 1400 anni dopo ... Mosaico Bizantino 900 d.c. chiesa di Hagia Sophia Costantinopoli

sopra: discussione tra i dotti Rabanus, Alcuinus (Ealhwine) e Otgar, corte di Carlomagno, circa 820 d.c. a destra: illustrazione da libro di epoca Carolingia circa 820 d.c.

Giotto di Bondone (circa 1300) La strage degli innocenti, Capella degli Scrovegni, Padova

Mappa della citta' di Costantinopoli, 1422, disegno di cartografo fiorentino (32 anni prima della conquista da parte dei Turchi)

nell'ambiente ricco dell' inizio rinascimento (anche se la richezza era limitata a pochi) dell' Italia, Olanda, Germania di fine medio evo nascono esigenze nuove, e nascono risposte nuove...

Duerer, 1525 : lezione di prospettiva: disegno di un liuto ! la visualizzazione prospettica risale al rinascimento, il pittore tedesco Duerer l'ha imparato nei suoi viaggi in Italia (Venezia)

Donato Bramante, attorno al 1500, a Roma Pf nota il palazzo a destra, disegnato in prospettiva a un punto di fuga situato circa in mezzo alla scena

Donato Bramante : Donato di Angelo di Pascuccio, detto il Bramante (Monte Adrualdo 1444 - Roma 1514) famoso pittore e architetto italiano. Nato a Monte Adrualdo (Urbino), si formò artisticamente nella sua città natale ma iniziò ben presto a viaggiare e a lavorare a Mantova, Milano e Roma. Fu influenzato (prospettiva, classicità) da Leon Battista Alberti, Andrea Mantegna e Melozzo da Forlì. L'influsso di quest'ultimo si manifesta in particolare nelle opere milanesi. Lo studio di Vitruvio, degli antichi edifici classici e le discussioni con Leonardo, lo indirizzarono verso l'impiego di forme architet-toniche possenti e classiche - esempio la sua Prospettiva di città ideale, un manifesto della nuova architettura milanese rinascimentale. Bramante è riuscito a ricreare un edificio che abbia tutte le caratteristiche classiche. Di Donato Bramante era anche affermato pittore “illusionista”, ossia creatore di prospettive e d’architetture fittizie, segue es.:

L'abside della chiesa San Satiro abside della chiesa di Santa Maria presso San Satiro a Milano, illusione pittorica di un grande spazio dietro l'altare - che non c'e' in realta' : dietro l'altare vi sono 90 cm di spazio... vedi slide seguente

ma ritorniamo ora alla prospettiva per quanto ci riguarda nella visualizzazione di scene 3D con il sistema OpenGL rivediamo alcune cose ...

l' OpenGL consente la definizione di vari tipi di prospettive con alcune procedure di libreria; ricordiamo che l' OpenGL e' un sistema formato da piu' livelli di librerie: + insieme base libreria GL di procedure con prefisso gl + la libreria GLU (OpenGL Utility Lib) + le librerie di interfaccia per diversi sistemi operativi, ciascuna con procedure di gestione di finestre, menu, eventi ecc come previsto nei diversi S.O., + la libreria GLUT (OpenGL Utility Toolkit)

l'OpenGL insieme base con prefisso gl = un insieme di primitive base per la visualizzazione di oggetti 3D su uno schermo 2D es... glBegin(); glBlend();.. sono tutte procedure,funzioni,tipi,cost., con prefisso gl [c'e gia' nel Borland Builder 4 !! ] poi c'e' l'insieme con prefisso glu: * libreria GLU (OpenGL Utility Lib) = procedure di specifica di proiezioni, resa di poligoni e superfici nello spazio, e altro; tutte le procedure hanno un nome che inizia con glu (prefisso) (es: gluLookAt(...) gluPerspective(..), ecc ) inoltre ...

alcune proc di OpenGL base, prefisso gl: glBegin( alcune proc di OpenGL base, prefisso gl: glBegin(..), glEnd(), glBitmap(..), glBlend(..), glCallList(..), glClear(..), glClip(..), glColor*(..), glCopy(..), ... glRect*(..), glTex(..), .. glTranslate*(..), glVertex*(..), glViewport(..), ..glWindowPos*(..), dove * sta per 2f,3f,4f,2i,.. in particolare, tutte le glSet.. e glGet.. per gestire le variabili di stato dell'OpenGL, (circa 200 procedure) * proc di GLU(OpenGL UtilityLib) prefisso glu: gluBeginCurve(..), .. gluLookAt(...), gluNewQuadric(..), gluNurbs(..), gluPerspective(..), ..gluSphere(..), gluTessNormal(..), gluUnProject(..).. (circa 50 procedure),

l'OpenGL: 1) procedure di base con prefisso gl; 2) libreria GLU (OpenGL Utility Lib), procedure prefisso glu 3) alle parti 1 e 2 manca l'interfaccia grafica tra S.O. e utente: ma queste sono MOLTO diverse nei vari sistemi, e quindi esistono (esistevano) delle librerie per l'uso dell' interfaccia grafica dei sistemi operativi piu' diffusi: prefisso glX per X-Window, prefisso wgl per MS Windows pref. agl per l'Apple OS9, non riportiamo nulla ... per il nostro corso ci limiteremo ad una particolare interfaccia ...

OpenGL: 1) libreria gl: procedure di base con prefisso gl; 2) libr. GLU (OpenGL Utility Lib), procedure prefisso glu 3) librer. per l'uso dell' interfaccia grafica di DIVERSI sist. operativi: prefissi glX per Unix X, wgl per MS Windows, agl per l'Apple OS9, infine: 4) GLUT: nel Mark Kilgard scrisse una libreria SEMPLIFICATA di interfaccia SO-utente (per il Unix X-Window system) che ebbe subito successo e fu portata su altri sistemi, come MSWindows dove continua a funzionare (+ o - ;-) GLUT = OpenGL Utility Toolkit: le procedure di questa libreria hanno il prefisso glut, ad es: glutMainLoop();

* libreria GLUT(OpenGL Utility Toolkit) con prefisso glut : glutCreateWindow(..), glutDisplayFunc(..), glutIdleFunc(..), .. glutMainLoop(..), glutSolidCone(..), .. glutWireTorus(..),.. (circa 30 procedure)

nella prospettiva interessano la posizione e l'orientamento del piano di proiezione rispetto il centro di proiezione e rispetto gli oggetti che vogliamo rappresentare : centro di proiezione N proiettori piano di proiezione normale al piano di proiezione asse z spazio oggetti

orientamento del piano di vista e del vettore normale N

posizioni del piano di proiezione sull'asse z

posizioni del piano di proiezione sull'asse z distz distz y x z nota orientam. asse z; qui l'oggetto sta dalla parte delle z negative posizioni del piano di proiezione rispetto l'asse oggetto-centro proiezione

3 D - prospettiva parallela distz distz y x z prospettiva parallela: la posizione del piano di proiezione rispetto l'asse oggetto-centro proiezione non e' rilevante (il punto di vista sta all'infinito)

definiz del vettore normale al piano di vista il punto Pref viene scelto di solito come origine del mondo degli oggetti fig. da D.Hearn e M.P.Baker "Comp.Graph with OpenGL Pearson Prentice Hall 3.rd ed.,2004

posizioni di riferimento per l' OpenGL 3D Nel caso dell' OpenGL il punto di vista default sta all'origine, l'oggetto sta nell'origine (reference point - in qualche caso sta in (0,0,-1), il piano di vista sta nell' origine - il tutto va benissimo per le prospettive paralelle

OpenGL 3D: posizione oggetto / centro prosp. camera per la visualizzazione (specie se prospettica) di un oggetto 3D conviene separare il centro di vista (il punto dove sta la camera o l'occhio) dall'oggetto - o spostando la camera (sinistra) o spostando l'oggetto (destra) che ha ora le z negative

proiezioni geometriche piane (*) (*) Fondam. di grafica tridimensionale interattiva di R.Scateni,P.Cignoni, C.Montani,R.Scopigno, McGrawHill It, 2005;

proiezioni geometriche piane (*) parallele (vediamo prima queste) - e sono: ortografiche piante e alzati, assonometriche isometriche, dimetriche, trimetriche oblique cavaliera cabinet altre prospettiche: e sono: a 1 punto di fuga, a 2 punti di fuga, a 3 punti di fuga

proiezione ortogonale o parallela: il punto di vista sta all'infinito, i raggi di proiezione sono paralleli. non c' e' " distanza " tra : - piano proiezione, punto vista, - oggetto: quindi l'asse z e le distanze z sono " irrilevanti "

proiezione parallela: il punto di vista sta all'infinito, i raggi di proiezione sono paralleli, non c' e' "distanza" tra piano proiezione, punto vista, oggetto: l'asse z e' "irrilevante". se la direzione di proiezione e la normale al piano di proiezione coincidono allora abbiamo le proiezioni parallele ortografiche - le piu'comuni nel disegno tecnico: il piano di proiezione e' perpendicolare ad uno degli assi cartesiani, l' asse e' la direzione di proiezione; abbiamo: vista frontale, vista laterale e pianta (vista dall'alto)

3 D- prospettiva ortografica (o ortogonale) pianta laterale frontale

proiezioni parallele ortografiche punto di vista all'infinito, raggi di proiezione paralleli agli assi: vista frontale, laterale e dall'alto (pianta). Si usano perche' dal disegno si possono rilevare le distanze e le dimensioni dell'oggetto; ma la resa 3D e' modesta, le tre prospettive non danno l'idea immediata di come e' fatto l'oggetto in 3D (infatti, in figura..)

se nella proiezione parallela ortografica la direzione di proiezione NON coincide con alcuno degli assi cartesiani abbiamo le proiezioni assonometriche:

Le prospettive assonometriche (isometrica dove la direzione di proiezione forma angoli uguali con i tre assi di proiezione, dimetrica se due angoli tra direzione di proiezione e assi vartesiani sono uguali, in generale e' trimetrica) si ottengono dalle ortografiche con direzione parallela all'asse z ruotando l'oggetto opportunamente. PROIEZIONI OBLIQUE: la direzione di proiezione forma un angolo obliquo con il piano di proiezione; l'oggetto rappresentato conserva l'informazione della natura 3D (a differenza della proiez.ortografica fronte/fianco/pianta), ma appare deformato (*) in figura, prospettiva parallela obliqua (non ortografica) Cavaliera, gli spigoli laterali (*) hanno la stessa lunghezza dei frontali (o), angolo 30o d d (o) d

3 D - geometria, prospettive, OpenGL 3D in generale una prospettiva parallela (ortho) puo' essere obliqua, come qui in figura, o come nella figura seguente ..

3 D - geometria, prospettive, OpenGL 3D

PROIEZIONI OBLIQUE: la direzione di proiezione forma un angolo obliquo con il piano di proiezione; l'oggetto rappresentato conserva l'informazione della natura 3D (a differenza della proiez.ortografica fronte/fianco/pianta), ma appare deformato un rimedio e' l'accorciamento dei segmenti laterali (paralleli all'asse z che e' rivolto verso l'osservatore), nella proiezione cabinet la lunghezza delle linee laterali si riduce a meta': l'OpenGL non prevede le prospettive obliqui come "predefinite", anche se e' possibile definire la matrice di trasformazione anche per tale prospettiva d d/2 d

3 D - prospettiva orto in OpenGL: glOrtho(xwinmin,xwinmax,ywinmin,ywinmax,distnear,distfar)

3 D - geometria, prospettive, OpenGL 3D glOrtho (xwinmin,xwinmax, ywinmin,ywinmax, distnear,distfar) nota: asse z verso chi guarda, assi x e y nel piano di vista (z=near)

nota: la procedura ortho e la procedura ortho2D sono "quasi" le stesse, nel senso che l'asse z e' quasi irrilevante; cambia il volume di visualizzazione, che nel caso della ortho ha una dimensione sull'asse z da specificare, gli oggetti fuori tale spazio saranno eliminati (clipping) ortho2D assume znear 1 e zfar -1, per cui tutti gli oggetti in 2D con z=0 sono dentro il volume di visualizzazione.

3 D - geometria, prospettive, OpenGL 3D glOrtho (xwinmin,xwinmax, ywinmin,ywinmax, distnear,distfar); attenzione: l'asse z e' orientato verso chi guarda, siamo su punto con z zero e stiamo guardando verso l'asse z negativo; gli oggetti sono di solito messi lungo l'asse z negativo; gli ultimi due parametri specificano due distanze (positive!) per i piani di clipping vicino e lontano da cui ho la posizione per gli oggetti; ad es. con znear=10 e zfar=50 (distanza da chi guarda min e max) allora l'oggetto (che sta lungo l'asse z negativo), deve essere nella posizione tra -10 e -50. se non specifico nulla, si assume il volume unitario, come nella figura seguente:

glOrtho(xwinmin,xwinmax,ywinmin,ywinmax, distnear,distfar)

nota: i lati si mantengono paralleli! (prog. EGD3D_01ORTHO) prospettiva parallela in OpenGL: glMatrixMode( GL_PROJECTION); glLoadIdentity(); segue la specifica del tipo di proiezione e dei limiti dello spazio degli oggetti visualizzati, con piano di proiezione z==0, e con gli oggetti nell' origine: glOrtho(-2.0,2.0, -2.0,2.0, -2.0,2.0); // xmin,xmx, ymin,ymx, znear,zfar poi, in Display: glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glPushMatrix(); glTranslatef(dx,dy,dz); glRotatef(ang,1.0,1.0,1.0); /*rotate ang degrees (/360) around vector 1,1,1*/ glScalef( 1.0, 1.0, 1.0); DrawCube(); nota: i lati si mantengono paralleli! (prog. EGD3D_01ORTHO)

provare l'uso e leggere con cura il programma OGL3D_1ORTHO in figura, visualizzazione con proiezione parallela (orthographic) con oggetto (cubo) ruotato in due modi diversi

ancora un' immagine in prospettiva ortografica, programma EGD3D_1ORTHO, con angoli di rotazione ax=-10, ay=-10, az=0

segue ora una breve presentazione del programma EGD3D_01ORTHO

dal programma EGD3D_01ORTHO void DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2 */ //per disegnare le linee verdi da z<0 a z>0 1-5, 2-8, 4-6, 3-7 glLineWidth(3.0); glColor3f(0.0,1.0,0.0); glBegin(GL_LINES); glVertex3f(-0.5,-0.5,-0.5 ); glVertex3f(-0.5,-0.5,+0.5 );//1-5 glVertex3f(+0.5,-0.5,-0.5 ); glVertex3f(+0.5,-0.5,+0.5 );//2-8 glVertex3f(-0.5,+0.5,-0.5 ); glVertex3f(-0.5,+0.5,+0.5 );//4-6 glVertex3f(+0.5,+0.5,-0.5 ); glVertex3f(+0.5,+0.5,+0.5 );//3-7 glEnd(); ...

dal programma EGD3D_01ORTHO void DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2 */ //disegna le linee blu della faccia dietro (z<0) punti 1,2,3,4 glColor3f(0.0, 0.0, 1.0); /* linee blu */ glBegin(GL_LINE_LOOP); /* 1-2-3-4 blu back face */ glVertex3f(-0.5, -0.5, -0.5 ); glVertex3f(+0.5, -0.5, -0.5 ); glVertex3f(+0.5, +0.5, -0.5 ); glVertex3f(-0.5, +0.5, -0.5 ); glEnd();

dal programma EGD3D_01ORTHO void DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2 */ //disegna linee gialle faccia davanti (z>0) punti 5,6,7,8 glColor3f(1.0, 1.0, 0.0); /* giallo z=0.5, */ glBegin(GL_LINE_LOOP); /* 5-6-7-8 yellow front face */ glVertex3f(-0.5, -0.5, +0.5 ); glVertex3f(-0.5, +0.5, +0.5 ); glVertex3f(+0.5, +0.5, +0.5 ); glVertex3f(+0.5, -0.5, +0.5 ); glEnd();

dal programma EGD3D_01ORTHO void DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2 */ // lo stesso disegno si ottiene con la procedura di libreria: glLineWidth(5.0); glColor3f(1.0,1.0,1.0); /* bianco */ glutWireCube(1.0); /* lato lungo 1, centro in origine */

// a faccie piene (rettangoli), proc di libr: glutSolidCube(1.0); // o, stesso disegno con GL_POLY: /* 4-------3 not wire - . / | / | disegna 4 poligoni . 6------7 .| attenzione all'ordine e . | 1--- |-- 2 al verso di orientamento . | / | / dei poligoni . 5-------8 */ glEnable(GL_BLEND); glBlendFunc( .., ...); // usa alfa glColor4f(0.4,0.4,0.4, alf); /* grigio */ glBegin(GL_POLYGON); /* 1-2-5-8 bottom y=-0.5 */ glVertex3f(-0.5, -0.5, -0.5 ); glVertex3f(+0.5, -0.5, -0.5 ); glVertex3f(+0.5, -0.5, +0.5 ); glVertex3f(-0.5, -0.5, +0.5 ); glEnd(); glBegin(GL_POLYGON); /* 6-7-3-4 top y= +0.5 */ glVertex3f(-0.5, +0.5, +0.5 ); glVertex3f(+0.5, +0.5, +0.5 ); glVertex3f(+0.5, +0.5, -0.5 ); glVertex3f(-0.5, +0.5, -0.5 ); ... ecc per le altre facce

inizializzazioni per uso della prospettiva void myPerspectiveSet(){ glMatrixMode( GL_PROJECTION); glLoadIdentity(); /* 4x4 projection matrix for openGL hw */ glOrtho( xmin, xmax, ymin, ymax, znear, zfar ); /* usa prospettiva parallela */ } /* myPerspectiveSet */ void myGLInit ( ) { myWiWi=glutGet(GLUT_WINDOW_WIDTH); myWiHe=glutGet.. glViewport(0,0,myWiWi, myWiHe); myPerspectiveSet(); glMatrixMode( GL_MODELVIEW); glLoadIdentity(); } /* myInitGL */ void myReshape ( int w, int h ) { myWiWi=w; myWiHe= h; glViewport( 0, 0, w, h ); PerspectiveSet(); glMatrixMode( GL_MODELVIEW); glLoadIdentity(); glutPostRedisplay(); } /* myReshape */

// la procedura che disegna ha la struttura: void myDisplay() { // start display glClearColor( 0.1, 0.1, 0.3, 1.0f ); glClear( GL_COLOR_BUFFER_BIT ); myPerspectiveSet(); /* esegue glOrtho( xmin, xmax, ... zfar);*/ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); /* unita' */ glPushMatrix(); /* fai una copia, cambia la copia della matr. */ /* - non accumulare la trasformaz.che segue */ glTranslatef( tx, ty, tz ); /* inizia con tx=ty=tz=0.0 */ glRotatef( angx, 1.0, 0.0, 0.0); /* ruota di angx attorno asse x */ glRotatef( angy, 0.0, 1.0, 0.0); /* attorno asse y */ glRotatef( angz, 0.0, 0.0, 1.0 ); /* attorno asse z */ glScalef( 1.5, 1.5, 1.5 ); /* ingrandisci il cubo, e' -0.5..+0.5 */ myDrawCube(); /* fa il disegno del cubo */ glPopMatrix(); /* elimina tutte le trasformazioni fatte dal push */ glFlush(); /* fai passare da scheda grafica su schermo */ } /* myDisplay */

/* e il programma ha la struttura come segue */ int main (int argc, char * argv[]) { SpiegaFig(); SpiegaTasti(); myOpenWin( argc, argv ); myDataInit(); myInit( ); glutDisplayFunc( myDisplay); glutReshapeFunc( myReshape ); glutKeyboardFunc( myKeyboard ); glutSpecialFunc( myArrow_keys ); glutMainLoop( ); return 0; /* ma non si ritorna qui */ } /* main */ void myOpenWin(int argc, char * argv[]){ glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE ); glutInitWindowPosition(WinX0, WinY0); glutInitWindowSize( WinSizex, WinSizey ); glutCreateWindow( "<OGL3D_01ORTHO>"); } /* OpenWinPlease */