                                    LES 

                               TUNNELS BITMAP


Bon, je ne vais pas vous expliquer comme faire des tunnels
constitus de polygones mapps, mais simplement, les fameux
tunnels 2D si souvent vus et revus et bien plus facile 
programmer.

Le principe est simple, car tout est bas sur des tables
prcalcules. Vous aurez besoin de 2 tableaux de 64000 bytes si
vous voulez coder votre tunnel pour 320x200 pixels...il vous reste
encore la texture et l'cran virtuel, donc le tunnel + les tables
prendront environ 256k en mmoire.

Maintenant, assumons que le premier tableau s'appelle T_ANGLES et
le second T_DEPTHS. Pour le premier tableau, il convient de faire
le calcul suivant :

Ŀ
  t_angles[x,y]  = atan (y-ycentre / x-xcentre)


Xcentre et Ycentre vaudront respectivement 160 et 100 si vous tes
en 320x200. Vous pouvez tout aussi bien utiliser ATAN2 :

Ŀ
  t_angles[x,y]  = atan2 (x-xcentre , y-ycentre) 

             
D'habitude, les valeurs retournes sont exprimes en radians, pour
obtenir des dgres, vous devez procder  la conversion suivante :
       
Ŀ
  t_angles[x,y]  = (atan (y-ycentre / x-xcentre))*255/3.14


Ici, le 255 correspond  la largeur de la texture (256x256), donc
 modifier en fonction de la taille de la texture.

Ensuite,le tableau des profondeurs T_DEPTHS, qui peut tre calcul
comme ceci :
             
Ŀ
  valeur_sqrt    = sqrt((x-xcentre)^2 + (y-ycentre)^2)
  t_depths[x,y]  = (radius_tunnel * distance) / valeur_sqrt


Pour le radius du tunnel et la distance, prenez des puissances de
2 afin d'acclrer les calculs. De bonnes valeurs, sont 256 pour
la distance et 64 pour le radius. 

Pour rsumer, voici la boucle des prcalculations :
        
Ŀ
        largeur_ecran = 320
        hauteur_ecran = 200

        xcentre = largeur_ecran / 2
        ycentre = hauteur_ecran / 2

  for   y = 1 to hauteur_ecran - 1
  {
        for x = 0 to largeur_ecran - 1 
        {
        t_angles[x,y] = (atan (y-ycentre / x-xcentre))*255/3.14
        valeur_sqrt   = sqrt((x-xcentre)^2 + (y-ycentre)^2)
        t_depths[x,y] = (radius_tunnel * distance) / valeur_sqrt
        }
  }


Il ne reste plus qu' afficher le tunnel sur l'cran en se
rfrant aux tables d'angles et profondeurs :

Ŀ
  x_texture  = t_angles[x,y] + deplacement_x
  y_texture  = t_depths[x,y] + deplacement_y
  ecran[x,y] = texture[x_texture,y_texture]


Les variables "deplacement_x" et "deplacement_y" permettent de
faire tourner le tunnel et de le faire avancer. A chaque nouvelle
frame, il convient d'augmenter ou de diminuer ces valeurs. La
texture fait en gnral 256x256 pixels.

Cependant, il est parfois ncessaire de rcrer les tables
"directement dans le code", pour les intros 4k ou 64k, o des
tables prcalcules de 64k sont trop larges pour tenir dans
l'excutable final. Les programmeurs en C ou en PASCAL n'ont pas
ce problme car la fonction ATAN existe, mais ceux qui veulent
programmer cela en ASM, ne disposent pas de telles fonctions
trigonomtriques.

On peut trouver l'ATAN d'un nombre comme cela
                                       (merci Eclipse/Knights ;):

f(x)= (Pi*(2+3*x+3*x^2+2*x^3)+1/3*(-19-3*x+3*x^2+19*x^3)) / 
      (4*(x+1)*(2*x^2+x+2))

Cela retourne une valeur en degrs pour les nombres positifs, si
vous avez besoin l'ATAN d'un nombre ngatif, il suffit de changer
f(x) en -f(-x).

Pour les racines, il existe de nombreuses sources pour les
calculer, voici quand meme une routine (trouve dans les
librairies livres avec l'extender DOS32 - Adam Seychell) :

Ŀ
  ; entre : EAX = nombre dont on cherche la racine carre
  ; sortie : EAX = racine carre du nombre

  SQRT    Proc 
  mov     edi,eax
  bsr     ecx,edi             ; ca ne tournera que sur 486 et +
  shr     cl,1 
  mov     ebp,edi
  shr     ebp,cl

 calc_sqrt_Loop:
 push    ebp
 mov     ebx,ebp
 shl     ebx,1
 mov     eax,ebp
 mul     ebp
 sub     eax,edi           
 sbb     edx,0             
 idiv    ebx            
 sub     ebp,eax          
 pop     eax             
 cmp     ebp,eax         
 jne     calc_sqrt_Loop
 mov     eax,ebp     
 ret
 SQRT    Endp


Voila, avec ca, vous devriez pouvoir programmer de jolis tunnels
bitmap. Vous verrez qu'en modifiant certains paramtres, on peut
obtenir des effets trs intressants (cf. Television/Coma). :))
J'espre que c'est pas trop "fouilli" comme c'est bien souvent le
cas avec les docs ;)))
                                

                                     - DaKe / CaLoDoX -
                                     = dake@omedia.ch =
                             http://www.omedia.ch/pages/dake/ 
