Le mappe normali e di altezza

Transcript

1 Informatica Grafica ][ Le mappe normali e di altezza Abbiamo visto come realizzare personaggi ed ambienti virtuali. I mondi visti fino ad adesso erano pero' "piatti": la terza dimensione non era un elemento fondamentale del terreno di movimento. Inoltre, non vi era nessun controllo per impedire l'attraversamento di muri o pareti. Marco Gribaudo marcog@di.unito.it Esistono numerose tecniche per effettuare tali controlli. Alcune sono basate su complessi calcoli matematici sulle geometrie, altre invece sfruttano particolari dati prodotti dagli strumenti con cui sono creati gli scenari. Le tecniche basate su calcoli matemaci sulle geometrie degli oggetti sono le piu' precise. Sono pero' anche le piu' difficili da implementare e quelle meno efficienti da effettuare in tempo reale. Le tecniche basate su dati ausiliari invece, forniscono solamente delle approssimazioni alla soluzione del problema. Sono pero' decisamente piu' facili da implementare, e molto piu' veloci da caloclare. Per contro, richiedo uno sforzo ulteriore nel configurare gli strumenti di authoring 3D per produrre i dati necessari all'approssimazione. In questo corso vedremo una tecnica basata su dati ausiliari chiamati. Questa tecnica, oltre ad essere abbastanza semplice da implementare, permette di vedere alcune metodologie utilizzate comunqmente nella nella realizzazione di applicazioni real-time

2 Una e' una immagine Bitmap i cui colori dei pixel rappresentano la distanza dei punti del terreno dal piano orizzontale. La difficolta' maggiore nell'utilizzo delle mappe di altezza sta nella precisione con cui i colori vengono definiti in una immagine bitmap. Un formato standard infatti, ammette solamente 256 livelli di rosso, 256 livelli di verde e 256 livelli di blu. Per risolvere questo problema, si inizia a stabilire quale sia la "gamma" di altezze presenti nella scena tridimensionale. Quindi si cerca di sfruttare al meglio tutte le combinazioni di colore possibile. Si inizia a calcolare quali siano gli estremi minimi e massimi lungo i tre assi x, y e z. I quattro angoli della texture corrisponderanno alle coordinate minime e massime lungo gli assi x e z. Consideriamo solo il canale rosso. Associamo il nero alla coordinata y di valore minimo, ed il rosso piu' intenso a quella di valore massimo.

3 I punti a parita' di livello di rosso, saranno contraddistinti dal livello del colore verde: l'intensita' di tale colore sara' superiore per i punti con una coordinata y maggiore. Infine, per i punti aventi gli stessi valori di verde e rosso, il colore blu discriminera' quelli piu' in alto. In questo modo, il punto con coordinata y minima sara' di colore nero, mentre quello di coordinata massima bianco. Inoltre, l'intera gamma delle altezze differenti sara' suddivisa in piu' di 16 milioni di possibili livelli, garantendo quindi una precisione piu' che adeguata per la maggior parte degli scopi. In Maya, un mappa di altezza puo' essere generata creando un particolare shader che assegna un colore differente in base all'altezza dei punti renderizzati ed una cinepresa ortografica che riprende "dall'alto" l'intera scena, posizionandosi esttamente sopra di essa.

4 L'intero processo di creazione degli shader, assegnazione dei materiali, creazione della cinpresa e rendering puo' essere automatizzato attraverso uno script M E L. Esso si puo' anche occupare di calcolare gli estremi inferiori e superiori lungo i tre assi coordinati. Normal Map In modo analogo alle, si possono creare le M a p p e d e l l e n o r m a l i (N o r m a l M a p). Esse non codificano l'altezza di un punto dal piano orizzontale, ma la direzione della normale alla superfice in quel punto. Normal Map Per le Normal Map, i tre colori primari (r, g, b) rappresentano la componente del vettore normale lungo i tre assi cartesiani (x, y, z). Normal Map Per le Normal Map non occorre la stessa precisione necessaria per le mappe di altezza. Ogni colore quindi codifica una componente del vettore, sfruttando solamente 8 bit (quindi 256 valori differenti). Normal Map Le normali possono servire per orientare un oggetto in modo che si adagi perfettamente sul terreno. Normal Map Anche se in questo corso non lo vedremo, le Normal Map vengono anche utilizzate come particolari strumenti per aumentare i dettagli di oggetti definiti da pochi triangoli.

5 Una mappa di altezza risulta utilizzabalie solamente se corredata dalla informazioni che permettano di decodificarla. Le prime righe indicheranno la risoluzione della mappa. Queste informazioni sono: la risoluzione della mappa, gli estremi inferiori e superiori dei tre assi cartesiani. Utilizzeremo quindi un nuovo tipo di file per memorizzare queste informazioni. Quindi seguiranno i limiti inferioiri lungo le coordinate x,y e z, e dunque i limiti superiori lungo le medesime coordinate. Infine ci sranno i nomi dei file contenti la mappa di altezza e quella delle normali Quindi creeremo un nuovo tipo dato per memorizzare le All'inizio del codice dovremo inserire un particolare informazioni di decodifica delle mappe. comando per poter leggere i colori presenti in una bitmap. Tipo di dati per il terreno Private Type Terrain ' Funzione di accesso alla memoria per poter leggere i pixel Private Declare Sub CopyMemoryRead Lib "kernel32" Alias _ "RtlMoveMemory" (Destination As Any, _ ByVal Source As Long, ByVal Length As Long) TexW As Integer ' Dimensione mappa TexH As Integer xmin As Single ' Grandezza mappa ymin As Single zmin As Single xmax As Single ymax As Single zmax As Single YTexName As String ' Mappa delle altezze YTex As Direct3DTexture8 NTexName As String ' Mappa delle normali NTex As Direct3DTexture8 Type

6 Le Bitmap verranno caricate come se fossero delle Texture, ma non verranno mai visualizzate direttamente. Aggiungeremo all'inizio una nuova variabile per contenere le definizioni del terreno. Inseriamo quindi il codice per il caricamento effettivo della mappa e delle informazioni necessarie alla sua decodifica. Private Function LoadTerrain(FileName As String) As Terrain With LoadTerrain Open FileName For Input As #1 Input #1,.TexW ' Carica i dati Input #1,.TexH Input #1,.xMin Input #1,.yMin Input #1,.zMin Input #1,.xMax Input #1,.yMax Input #1,.zMax Input #1,.YTexName Input #1,.NTexName Close #1 ' Carica la texture Set.YTex = D3DX.CreateTextureFromFileEx(D3DDevice, _.YTexName, D3DX_DEFAULT, D3DX_DEFAULT, _ 1, 0, D3DFMT_UNKNOWN, _ D3DPOOL_MANAGED, D3DX_FILTER_POINT, _ D3DX_FILTER_POINT, &HFF000000, _ ByVal 0, ByVal 0) Set.NTex = D3DX.CreateTextureFromFileEx(D3DDevice, _.NTexName, D3DX_DEFAULT, D3DX_DEFAULT, _ 1, 0, D3DFMT_UNKNOWN, _ D3DPOOL_MANAGED, D3DX_FILTER_POINT, _ D3DX_FILTER_POINT, &HFF000000, _ ByVal 0, ByVal 0) With Function Essa carica semplicemente i campi della struttura dati con i valori contenuti nel file... E poi le mappe vere proprie nelle texture.

7 Inseriamo poi la procedura per il calcolo dell'altezza in base alla mappa. Private Function GetTerrainY(T As Terrain, _ ByVal x As Single, ByVal z As Single) Dim YDef As D3DLOCKED_RECT Dim Pix00 As Long Dim Pix01 As Long Dim Pix10 As Long Dim Pix11 As Long Dim Y00 As Single Dim Y01 As Single Dim Y10 As Single Dim Y11 As Single Dim px As Long Dim pz As Long Dim ax As Single Dim az As Single ax = (x - T.xMin) / (T.xMax - T.xMin) * T.TexW az = (z - T.zMin) / (T.zMax - T.zMin) * T.TexH px = Int(ax) pz = Int(az) ax = ax - px az = az - pz (px >= 0 And px < T.TexW And pz >= 0 And pz < T.TexH) Then T.YTex.LockRect 0, YDef, ByVal 0, D3DLOCK_READONLY CopyMemoryRead Pix00, YDef.pBits + (pz * YDef.Pitch + px * 4), 4 CopyMemoryRead Pix01, YDef.pBits + (pz * YDef.Pitch + px * 4 + 4), 4 CopyMemoryRead Pix10, YDef.pBits + ((pz + 1) * YDef.Pitch + px * 4), 4 CopyMemoryRead Pix11, YDef.pBits + ((pz + 1) * YDef.Pitch + px * 4 + 4), 4 T.YTex.UnlockRect 0 Y00 = (Pix00 And &HFFFFFF) / (&HFFFFFF) Y01 = (Pix01 And &HFFFFFF) / (&HFFFFFF) Y10 = (Pix10 And &HFFFFFF) / (&HFFFFFF) Y11 = (Pix11 And &HFFFFFF) / (&HFFFFFF) Y00 = T.yMin + Y00 * (T.yMax - T.yMin) Y01 = T.yMin + Y01 * (T.yMax - T.yMin) Y10 = T.yMin + Y10 * (T.yMax - T.yMin) Y11 = T.yMin + Y11 * (T.yMax - T.yMin) GetTerrainY = (1 - az) * (Y00 * (1 - ax) + Y01 * (ax)) + _ (az) * (Y10 * (1 - ax) + Y11 * (ax)) Else GetTerrainY = 0 Function Essa prende in input le coordinate x e z del punto, e restituisce la coordinata y del terreno in quel punto. Per effettuare tale calcolo, usa diversi artifici quali ad esempio l'interpolazione dei valori specificati da piu' pixel vicini alla posizione richiesta. Inseriamo il comando per leggere la mappa nella fase di inizializzazione dell'applicazione.

8 Modifichiamo infine il codice che aggiorna la posizione dell'oggetto in corrispondenza del timer, in modo che utilizzi il valore ritornato dalla mappa per stabilire l'altezza dell'oggetto. Identificare i muri Oltre che per stabilire l'altezza del terreno, le mappe di altezza possono anche essere usate per definire i muri e gli ostacoli che possono impedire l'avanzamento di un oggetto. Se infatti l'altezza della posizione che deve essere raggiunta e' troppo superiore a quella attuale, allora si puo' supporre che vi sia un ostacolo che non puo' essere superato. Private Sub Timer1_Timer() Dim AutoTn As Integer Dim RuotaTn As Integer AutoTn = FindTn("Palla") Dim NewX As Single Dim NewY As Single Dim NewZ As Single Identificare i muri Per utilizzare le mappe di altezza per identificare gli ostacoli e' suffiente cambiare il codice presente nel timer in questo modo: NewX = TrnNds(AutoTn).tX + VelAuto * Sin(DirAuto * / 180) NewZ = TrnNds(AutoTn).tZ + VelAuto * Cos(DirAuto * / 180) NewY = GetTerrainY(Terr, NewX, NewZ) NewY > TrnNds(AutoTn).tY Then VelAuto = 0 Else TrnNds(AutoTn).tX = NewX TrnNds(AutoTn).tY = NewY TrnNds(AutoTn).tZ = NewZ TrnNds(AutoTn).rY = DirAuto CamTx = TrnNds(AutoTn).tX CamTy = TrnNds(AutoTn).tY CamTz = TrnNds(AutoTn).tZ CamPx = CamPx * * (TrnNds(AutoTn).tX * Sin(DirAuto * / 180)) CamPy = TrnNds(AutoTn).tY CamPz = CamPz * * (TrnNds(AutoTn).tZ * Cos(DirAuto * / 180)) Rot = Rot + VelAuto * 500 Rot >= 360 Then Rot = Rot RuotaTn = FindTn("PallaRoll") TrnNds(RuotaTn).rX = Rot Sub Identificare i muri La nuova posizione viene memorizzata in una variabile, invece che direttamente nelle trasformazioni del TN. Identificare i muri Se l'altezza alla nuova posizione e' troppo superiore a quella attuale, si ferma l'oggetto e non si aggiornano le posizioni.

9 Identificare i muri Altrimenti si aggiornano le posizioni dell'oggetto con quelle appena calcolate. Le pendenze Se il terreno non solo presenta divese altezze, ma anche delle pendenze, e l'oggetto che si muove ha una forma "piatta", allora occorre ruotarlo in modo che sia sempre "attaccato al terreno". In particolare occorre allineare la direzione verticale dell'oggetto alla normale del terreno. Le pendenze Allineando l'asse che indica la perpendicolare dell'oggetto alla normale, esso aderisce perfettamente al terreno. Le pendenze Le Normal Map ci forniscono il valore delle normali nei vari punti del terreno. Purtroppo i calcoli precisi per allineare l'oggetto alla normale del terreno sono molto complessi e richiedo strumenti matematici specifici. Presentiamo quindi una approssimazione di tale calcolo, che pur non essendo perfetta, da risultati tollerabili. Le pendenze In particolare aggiungamo la procedura che ricava le normali a partire dalla Bitamp. Questa procedura e' del tutto analoga a quella che ricava la coordinata y. Private Sub GetTerrainNormal(T As Terrain, x As Single, z As Single, _ nx As Single, ny As Single, nz As Single) Dim YDef As D3DLOCKED_RECT Dim Pix00 As Long Dim Pix01 As Long Dim Pix10 As Long Dim Pix11 As Long Dim Nx00, Ny00, Nz00 As Single Dim Nx01, Ny01, Nz01 As Single Dim Nx10, Ny10, Nz10 As Single Dim Nx11, Ny11, Nz11 As Single Dim px As Long Dim pz As Long Dim ax As Single Dim az As Single Dim norm As Single ax = (x - T.xMin) / (T.xMax - T.xMin) * T.TexW az = (z - T.zMin) / (T.zMax - T.zMin) * T.TexH px = Int(ax) pz = Int(az) ax = ax - px az = az - pz (px >= 0 And px < T.TexW And pz >= 0 And pz < T.TexH) Then T.NTex.LockRect 0, YDef, ByVal 0, D3DLOCK_READONLY CopyMemoryRead Pix00, YDef.pBits + (pz * YDef.Pitch + px * 4), 4 CopyMemoryRead Pix01, YDef.pBits + (pz * YDef.Pitch + px * 4 + 4), 4 CopyMemoryRead Pix10, YDef.pBits + ((pz + 1) * YDef.Pitch + px * 4), 4 CopyMemoryRead Pix11, YDef.pBits + ((pz + 1) * YDef.Pitch + px * 4 + 4), 4 T.NTex.UnlockRect 0 Nx00 = 2 * (Pix00 And &HFF0000) / (&HFF0000) - 1 Ny00 = 2 * ((Pix00 / 256) And &HFF) / (&HFF) - 1 Nz00 = 2 * (Pix00 And &HFF) / (&HFF) - 1 Nx01 = 2 * (Pix01 And &HFF0000) / (&HFF0000) - 1 Ny01 = 2 * ((Pix01 / 256) And &HFF) / (&HFF) - 1 Nz01 = 2 * (Pix01 And &HFF) / (&HFF) - 1 Nx10 = 2 * (Pix10 And &HFF0000) / (&HFF0000) - 1 Ny10 = 2 * ((Pix10 / 256) And &HFF) / (&HFF) - 1

10 Nz10 = 2 * (Pix10 And &HFF) / (&HFF) - 1 Nx11 = 2 * (Pix11 And &HFF0000) / (&HFF0000) - 1 Ny11 = 2 * ((Pix11 / 256) And &HFF) / (&HFF) - 1 Nz11 = 2 * (Pix11 And &HFF) / (&HFF) - 1 nx = (1 - az) * (Nx00 * (1 - ax) + Nx01 * (ax)) + _ (az) * (Nx10 * (1 - ax) + Nx11 * (ax)) nz = (1 - az) * (Ny00 * (1 - ax) + Ny01 * (ax)) + _ (az) * (Ny10 * (1 - ax) + Ny11 * (ax)) ny = (1 - az) * (Nz00 * (1 - ax) + Nz01 * (ax)) + _ (az) * (Nz10 * (1 - ax) + Nz11 * (ax)) norm = Sqr(nx * nx + ny * ny + nz * nz) nx = nx / norm: ny = ny / norm: nz = nz / norm Else nx = 0 ny = 1 nz = 0 Sub Private Sub Timer1_Timer() Dim AutoTn As Integer Dim AutoTn2 As Integer AutoTn = FindTn("Auto") AutoTn2 = FindTn("AutoRoll") Le pendenze Modifichiamo quindi la procedura richiamata allo scatto del timer, in modo che pieghi l'oggetto opportunamente. Dim NewX As Single Dim NewY As Single Dim NewZ As Single Dim nx As Single, ny As Single, nz As Single, vx As Single, vz As Single NewX = TrnNds(AutoTn).tX + VelAuto * Cos(DirAuto * / 180) NewZ = TrnNds(AutoTn).tZ - VelAuto * Sin(DirAuto * / 180) NewY = GetTerrainY(Terr, NewX, NewZ) NewY > TrnNds(AutoTn).tY Then VelAuto = 0 Else TrnNds(AutoTn).tX = NewX TrnNds(AutoTn).tY = NewY TrnNds(AutoTn).tZ = NewZ TrnNds(AutoTn).rY = DirAuto GetTerrainNormal Terr, NewX, NewY, nx, ny, nz vx = Cos((DirAuto - 90) * / 180) vz = -Sin((DirAuto - 90) * / 180) TrnNds(AutoTn2).rX = (Atn((vx * nx + vz * nz) / ny) / * 180) vx = Cos((DirAuto) * / 180) vz = -Sin((DirAuto) * / 180) TrnNds(AutoTn2).rZ = -(Atn((vx * nx + vz * nz) / ny) / * 180) CamPx = CamPx * * (TrnNds(AutoTn).tX _ * Cos(DirAuto * / 180)) CamPy = TrnNds(AutoTn).tY CamPz = CamPz * * (TrnNds(AutoTn).tZ _ * Sin(DirAuto * / 180)) Rot = Rot + VelAuto * 2000 Rot >= 360 Then Rot = Rot Sub CamTx = TrnNds(AutoTn).tX CamTy = TrnNds(AutoTn).tY CamTz = TrnNds(AutoTn).tZ