Forum Graph100

// Affiche un sprite 16*16 pour mode D3 ou DB
// avec OR avec clipping, au buffer voulu.
void d16clip_or(int x,int y,void* spr,unsigned int segm)
{
  unsigned char el=0xFF; // On commence par creer une variable de 8 bits,
  asm{               // car je n'aurai pas assez de registre.
       mov cx,x      // On met x dans CX.
       mov si,spr    // On place l'adresse du sprite dans SI.
       mov di,0x3FE  // On place l'offset vidéo sur le dernier mot, en haut a gauche de l'ecran.
       mov ax,segm   // On charge dans AX le segment video voulu par l'utilisateur,
       sub ax,y      // auquel on soustrait y pour pointer sur le bon mot.
       mov es,ax     // On peut alors placer AX dans ES.
       mov ax,cx     // On copie x dans AX.
       cmp ax,0      // On compare x a 0 pour savoir s'il y a un clipping gauche.
       jge clipping  // Si x est plus grand ou egal, on commence les tests de clipping.
       add ax,0x80   // Sinon, et c'est tres important, on positionne le pointeur video
       add di,0x10   // sur l'octet suivant. Cela va permettre d'eviter le bug classique
     }               // des nombres negatifs, et donc de ne pas ecrire n'importe
  clipping:          // ou dans la memoire video.
  asm{
       shr ax,0x3    // On effectue quelques calculs pour faire pointer
       sub di,ax     // DI sur l'octet correct en abscisse.
       or bx,0xFFFF  // On cree un masque (qui est pour l'instant transparent) dans BX et aussi dans EL.
       cmp cx,0x70   // On commence par le clipping droit.
       jle leftclip  // S'il n'y en a pas, on teste le clipping gauche.
       cmp cx,0x7F   // On teste si le sprite est positionne dans l'ecran.
       jg end        // Si ce n'est pas le cas, on n'affiche rien et on quitte directement.
       xor el,bl     // Le clipping droit : on annule tous les bits de EL, ce qui va
       cmp cx,0x78   // effacer la partie droite du sprite a afficher lors de l'application du masque.
       jl downclip   // On teste si on a besoin d'effacer l'octet au centre du sprite.
       xor bl,bl     // Si c'est le cas on le fait, puis on va directement tester
       jmp downclip  // le clipping bas, puisque qu'il est impossible d'avoir
     }               // en meme temps un clipping gauche et droit.
  leftclip:
  asm{
       cmp cx,0      // S'il n'y a pas eu de clipping droit, on reteste le gauche (on peut pas plus optimiser)
       jge downclip  // Si ce n'est pas le cas, on teste le clipping bas.
       cmp cx,-15    // S'il n'y a pas de sprite a afficher (qu'il sort completement de l'ecran)
       jl end        // On quitte directement sans rien afficher.
       xor bh,bh     // Le clipping gauche : on annule tous les bits de BH, ce qui va
       cmp cx,-8     // effacer la partie gauche du sprite a afficher lors de l'application du masque.
       jge downclip  // On teste si on a besoin d'effacer l'octet au centre du sprite.
       xor bl,bl     // Dans ce cas, on annule BL (le masque de l'octet du centre)
     }
  downclip:
  asm{
       and cl,0x7    // On calcule le decalage a appliquer au sprite pour qu'il soit positionne correctement en abscisse.
       mov ch,0x10   // On place dans CH le nombre de ligne a afficher (ici 16).
       mov ax,y      // On charge y dans AX,
       cmp ax,0x30   // et on teste si le sprite deborde en bas de l'ecran.
       jle upclip    // Si ce n'est pas le cas, on file au clipping haut.
       cmp ax,0x3F   // Sinon on teste s'il y a quelque chose a afficher.
       jg end        // S'il n'y a rien on quitte directement.
       shl ch,0x2    // Le clipping bas : on place 64 dans CH
       sub ch,al     // puis on soustrait le nombre de ligne a afficher
       jmp loop      // en soustrayant y (64-y = nombre de ligne a afficher)
     }               // Puis on commence a afficher le sprite.
  upclip:
  asm{
       cmp ax,0      // On teste s'il y a besoin ou non d'un clipping haut.
       jge loop      // Si non, on commence a afficher.
       cmp ax,-15    // On teste s'il faut afficher quelque chose.
       jl end        // Si non, on quitte directement (je l'ai pas deja dis ca?)
       mov dx,ax     // Le clipping haut : d'abord on copie y dans DX
       shl ax,0x1    // Ensuite on va repositionner le pointeur de donnees :
       sub si,ax     // on ne doit pas afficher la premiere ligne du sprite etant donne qu'elle n'apparait pas a l'ecran.
       neg dx        // On prend la valeur absolue de y,
       sub ch,dl     // que l'on soustrait au nombre de ligne a afficher. (16+y = nombre de ligne a afficher)
       mov ax,segm   // On repositionne le segment video a l'adresse voulue.
       mov es,ax
     }
  loop:
  asm{               // Apres tous ces tests, onaffiche enfin le sprite.
       xor dl,dl     // On efface le contenu de DL.
       mov ax,ds:[si] // On charge une des lignes du sprite a afficher dans AX.
       mov dh,al     // On copie la partie basse de AX dans la partie haute de DX.
       shr dx,cl     // Ce qui permet de decaler DX, pour recuperer la partie manquante du sprite a afficher.
       shr ax,cl     // On decale aussi AX.
       and ax,bx     // On pose les masques prepares auparavant. Ainsi, si le masque est completement
       and dl,el     // nul, alors il efface la partie qu'il ne faut pas afficher ; sinon, il conserve le sprite tel quel.
       or es:[di],ax // On pose la partie gauche du sprite,
       or es:[di-1],dl // puis la droite.
       sub di,0x10   // On fait pointer DI sur la ligne inferieure de la memoire video.
       add si,0x2    // On fait pointer SI sur la prochaine ligne du sprite.
       dec ch        // On decremente le nombre de ligne a afficher.
       jne loop      // Tant qu'il n'est pas nul, on continue la boucle.
     }
  end:
}