Esercizi di programmazione in Pascal->Grafica - Funzioni 3D

Grafica - Funzioni 3D

In questo piccolo tutorial verrà spiegato come implementare un algoritmo in pascal che disegna una funzione 3D sullo schermo.

Il sorgente è stato scritto per l'ambiente di sviluppo Turbo Pascal, e come impostazione grafica, viene utilizzata la modalità grafica VGA con risoluzione 640x480 mediante le funzioni assembler in linea.

La funzione seguente è una funzione che prende un punto (x,y) e calcola la coordinata z. Potete cambiare questa funzione a vostro piacere.

Questa funzione può essere disegnata all'interno del dominio [-2, 2] nell'asse delle x, e [-2, 2] nell'asse delle y. Di seguito il risultato

Grafica - Funzioni 3D

L'assonimetria cavaliera consiste nel calcolare una proiezione di una figura in 3D nel piano 2D. Ecco in breve il calcolo:

Si noti che in questo caso la proiezione, riporta l'asse Y nell'asse X2, e l'asse Z nell'asse Y2. L'asse X viene riportata in diagonale nelle due assi X2 ed Y2.

Poiché lo schermo ha una dimensione di 640x480 occorre ridimensionare i valori (x2, y2) con una costante 'ridimensionamento' che dipende dalla funzione e dal dominio. Ecco come il calcolo può essere così riscritto:

Per disegnare la funzione al centro dello schermo, occorre modificare ulteriormente il calcolo, ed occorre anche considerare che un punto con y=0 si trova al di sopra dello schermo. Posto 'larghezza' la costante che definisce la larghezza dello schermo e 'altezza' la costante che definisce l'altezza dello schermo, abbiamo il seguente calcolo:

Per rendere il disegno 3D più raffinato è possibile determinare quali sono i punti che dovrebbero rimanere nascosti per evitare di stamparli a video. Occorre premettere che il calcolo dela funzione avviene inserendo i punti uno per volta, ed i punti vengono inseriti dal basso verso l'alto (rispetto alla proiezione in 2D, cioè allo schermo). In pratica in base alla proiezione, vengono disegnati prima i punti più vicini poi quelli più lontani.
Definiamo due vettori 'massimo' e 'minimo' dove 'massimo[x2]' contiene il valore massimo di y2 del punto (x2,y2) durante il disegno e 'minimo[x2]' il valore minimo. Inizialmente 'massimo[x2]' ha valore '0' e 'minimo[x2]' ha valore 'altezza'.
Durante il disegno, un punto (x2,y2) può essere disegnato se rimane all'interno dello schermo, e se y2 è magiore di 'massimo[x2]' oppure inferiore di 'minimo[x2]'. Ad ogni punto calcolato i vettori vengono aggiornati.
Si noti che i due vettori vengono aggiornati ad ogni nuovo punto. Se un punto (x2,y2) ha ad esempio y2 minore di 'massimo[x2]' allora sicuramente la proiezione della funzione 3D sta calcolando una porzione di punti che si trova dietro dei punti già disegnati. Questo perchè i punti disegnati per ultimi sono quelli più lontati.

Infine per ottenere un buon effetto estetico, occorre disegnare la funzione 3D mediante un reticolo evidenziando il bordo con un'altro colore.
Vediamo di seguito il corpo del programma.

program funzione_3D;
const
        larghezza = 640;
          altezza = 480;
           int_x1 = -2.00;
           int_x2 = 2.00;
           int_y1 = -2.00;
           int_y2 = 2.00;
      passo_bordo = 0.02;
   passo_reticolo = 0.1;
ridimensionamento = 100;
  colore_contorno = 2;
  colore_reticolo = 1;

var
  massimo,minimo : array [0..larghezza] of 0..altezza;

...................
...................

var
      d : char;
 rx,x,y : real;
      i : integer;

begin
  setVideoMode(18);
  for i:=1 to larghezza-1 do
  begin
    massimo[i]:=0;
    minimo[i]:=altezza;
  end;
  x := int_x1;
  y := int_y1;
  repeat
    punto(x, y, colore_contorno);
    y := y + passo_bordo;
  until (y>int_y2);
  repeat
    y := int_y1;
    punto(x, y, colore_contorno);
    y := int_y2;
    punto(x, y, colore_contorno);
    rx := x-int(x/passo_reticolo)*passo_reticolo;
    y := int_y1+rx+passo_reticolo;
    repeat
        punto(x, y, colore_reticolo);
        y := y+passo_reticolo;
    until (y>int_y2);
    y := int_y2-rx-passo_reticolo;
    repeat
        punto(x, y, colore_reticolo);
        y := y-passo_reticolo;
    until (y<int_y1);
    x := x + passo_bordo;
  until (x>int_x2);
  y := int_y1;
  x := int_x2;
  repeat
      punto(x, y ,colore_contorno);
      y := y + passo_bordo;
  until (y>int_y2);
  d := Carattere;
  setVideoMode(3);
end.

Si noti che il reticolo viene costruito in diagonale ed i punti del bordo vengono disegnati prima di quelli del reticolo.

Scarica sorgente ed eseguibile

(5 Kb)