PC Interdit/pc-interdit.iso/graph/texture.inc

Text File | 1994-10-17 | 10KB | 317 lines

txt_makevarl macro              ;recharge les variables 3D du côté gauche
.386
  movsx ebx,dyl                 ;nombre de pas
  inc ebx
  push ecx
  push edx

  movsx eax,poly3d[bp]          ;lit 3d-x
  shl eax,8                     ;les 8 bits inf sont la partie décimale
  mov xl_3d,eax                 ;enregistre
  movsx ecx,poly3d[bp+8]        ;forme la différence
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;définit le pas
  mov inc_xl,eax

  movsx eax,poly3d[bp+2]        ;lit 3d-y
  shl eax,8
  mov yl_3d,eax
  movsx ecx,poly3d[bp+10d]      ;forme la différence
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;définit le pas
  mov inc_yl,eax

  movsx eax,poly3d[bp+4]        ;lit 3d-z
  shl eax,8
  mov zl_3d,eax
  movsx ecx,poly3d[bp+12d]      ;forme la différence
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;définit le pas
  mov inc_zl,eax
  pop edx
  pop ecx
endm


txt_makevarr macro              ;recharge les variables 3D du côté droit
.386
  push eax
  push ebx
  movsx ebx,dyr                 ;nombre de pas
  inc ebx

  movsx eax,poly3d[bp+8]        ;lit 3d-x
  shl eax,8                     ;les 8 bits inf sont la partie décimale
  mov xr_3d,eax                 ;enregistre
  movsx ecx,poly3d[bp]          ;forme la différence
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;définit le pas
  mov inc_xr,eax

  movsx eax,poly3d[bp+10d]      ;lit 3d-y
  shl eax,8
  mov yr_3d,eax
  movsx ecx,poly3d[bp+2]        ;forme la différence
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;définit le pas
  mov inc_yr,eax

  movsx eax,poly3d[bp+12d]      ;lit 3d-z
  shl eax,8
  mov zr_3d,eax
  movsx ecx,poly3d[bp+4]        ;forme la différence
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;définit le pas
  mov inc_zr,eax
  pop ebx
  pop eax
endm


txt_hline macro
hline_texture proc near      ;remplace la procedure "hline" avec des textures
.386
  push es
  pusha
  mov x0,ax                  ;sauvegarde des coordonnées pour usage ultérieur
  mov y0,bx
  mov x1,cx
  sub cx,ax                     ;calcule le nombre de points à tracer
  jne zzok2
  inc cx
zzok2:
  mov zz,cx

  mov bp,ligne_sup
  mov bx,ligne_inf
  mov eax,xr_3d[bx]             ;détermine l'abscisse relative x
  movsx ecx,poly3d[2]
  shl ecx,8                     ;ramène au format "virgule fixe"
  sub eax,ecx
  mov d_y,eax
  movsx ecx,w colonne2[0]
  imul ecx                      ;multiplie par Delta2 x
  mov esi,eax                   ;sauvegarde intermédiaire

  mov eax,xr_3d[bp]             ;détermine l'ordonnée relative y
  movsx ecx,poly3d[0]
  shl ecx,8                     ;ramène au format "virgule fixe"
  sub eax,ecx
  mov d_x,eax
  movsx ecx,w colonne2[4]
  imul ecx                      ;multiplie par Delta2 y
  sub eax,esi                   ;forme la différence (D1)
  cdq                           ;prépare la division
  idiv dword ptr D              ;divise par le déterminant principal
  shl eax,8
  neg eax
  mov inc_lambda1,eax           ;sauvegarde pour soustraction

  mov eax,d_x                   ;lit l'abscisse relative x
  movsx ecx,w colonne1[4]
  imul ecx                      ;multiplie par Delta1 y
  mov esi,eax                   ;sauvegarde intermédiaire

  mov eax,d_y                   ;lit l'ordonnée relative y
  movsx ecx,w colonne1[0]
  imul ecx                      ;multiplie par Delta1 x
  sub eax,esi                   ;forme la différence (D2)
  cdq                           ;prépare la division
  idiv dword ptr D              ;divise par le déterminant principal
  shl eax,8
  neg eax
  mov inc_lambda2,eax           ;sauvegarde pour soustraction
mov eax,xl_3d[bx]               ;définit l'abscisse relative x
  movsx ecx,poly3d[2]
  shl ecx,8                     ;convertit au format virgule fixe
  sub eax,ecx
  mov d_y,eax
  movsx ecx,w colonne2[0]
  imul ecx                      ;multiplie par Delta2 x
  mov esi,eax                   ;sauvegarde intermédiaire

  mov eax,xl_3d[bp]             ;définit l'ordonnée relative y
  movsx ecx,poly3d[0]
  shl ecx,8                     ;convertit au format virgule fixe
  sub eax,ecx
  mov d_x,eax
  movsx ecx,w colonne2[4]
  imul ecx                      ;multiplie par Delta2 y
  sub eax,esi                   ;forme la différence (D1)
  cdq                           ;prépare la division
  idiv dword ptr D              ;divise par le déterminant principal
  shl eax,8
  neg eax
  mov lambda1,eax               ;lambda1 déterminé
  sub inc_lambda1,eax

  mov eax,d_x                   ;lit l'abscisse relative x
  movsx ecx,w colonne1[4]
  imul ecx                      ;multiplie par Delta1 y
  mov esi,eax                   ;sauvegarde intermédiaire

  mov eax,d_y                   ;lit l'oronnée relative y
  movsx ecx,w colonne1[0]
  imul ecx                      ;multiplie par Delta1 x
  sub eax,esi                   ;forme la différence (D2)
  cdq                           ;prépare la division
  idiv dword ptr D              ;divise par le déterminant principal
  neg eax
  shl eax,8
  mov lambda2,eax               ;lambda2 déterminé
  sub inc_lambda2,eax
mov ax,80d                      ;définit l'offset
  mov bx,y0
  mul bx
  mov bx,x0                     ;(x div 4) + y*80
  shr bx,2
  add ax,bx
  add ax,vpage
  mov di,ax
  mov ax,0a000h                 ;charge le segment VGA
  mov es,ax

  mov cx,x0                     ;masque le plan de début
  and cx,3
  mov ax,1
  shl ax,cl                     ;met à un le bit correspondant
  mov b plane+1,al
  shl al,4                      ;extension au quartet supérieur
  or b plane+1,al
movsx ecx,zz                    ;calcule les accroissements des lambda
  mov eax,inc_lambda1           ;lit la longueur totale
  cdq
  idiv ecx                      ;divise par le nombre de pas
  mov inc_lambda1,eax
  mov eax,inc_lambda2           ;lit la longueur totale
  cdq
  idiv ecx                      ;divise par le nombre de pas
  mov inc_lambda2,eax
mov bp,Txt_Nr                   ;lit le numéro de la texture courante
  shl bp,1                      ;2 octets par élément
  mov bx,Txt_Taille[bp]         ;lit l'indication de taille courante
  mov b cs:Taille_Patch+3,bl    ;et modifie le code en conséquence
  mov b cs:Taille_Patch+7,bh

  mov ax,word ptr Txt_Offs[bp]  ;lit l'offset de cette texture

  push ds
  shl bp,1                      ;4 octets par élément
  lds si,dword ptr Txt_Data[bp] ;pointe sur les données proprement dites
  add si,ax
  mov w cs:Ofs_Patch+2,si       ;et modifie le code en conséquence

  mov dx,3c4h                   ;timing sequencer
  mov ebp,lambda1               ;variables dans registres
  mov esi,lambda2
lp:                             ;boucle parcourue pour chaque point
  add ebp,inc_lambda1           ;mise à jour lambda1 et 2
  add esi,inc_lambda2

  mov ax,plane                  ;lit le plan
  out dx,ax                     ;et le sélectionne

  mov eax,ebp                  ;détermine l'offset à l'intérieur du graphique de texture
  mov ebx,esi
Taille_Patch:
  sar eax,11d                   ;fixe la taille (modifiée)
  sar ebx,11d
   imul eax,320d
  add ebx,eax

Ofs_Patch:
  mov al,ds:[bx+1111h]          ;lit la couleur de la texture (modifiée)
  mov es:[di],al                ;reporte la couleur
  dec cx                        ;diminue le nombre de points
  je hlt_fini                   ;tous les points traités ?
  rol b plane+1,1               ;plan suivant
  cmp b plane+1,11h             ;débordement de plan de 3 à  0 ?
  jne lp                        ;non, on continue
  inc di                        ;sinon on augmente l'offset
  jmp lp                        ;et on continue
hlt_fini:
  pop ds
  popa
  pop es
  ret
hline_texture endp
endm


txt_Detprinc macro              ;calcul de déterminant principal
  xor si,si                     ;premier essai : lignes  0 et 1
  mov di,2
suivante:
  mov ax,w delta1[si]           ;calcule le déterminant principal
  imul w delta2[di]
  mov bx,ax                     ;sauvegarde résultat intermédiaire
  mov cx,dx
  mov ax,w delta2[si]
  imul w delta1[di]
  sub bx,ax                     ;sauvegarde la différence
  sbb cx,dx
  mov w D,bx
  mov w D+2,cx
  or bx,cx                      ;déterminant principal = 0 ?
  jne D_fini
  add si,2                      ;alors nouvelles composantes
  add di,2
  cmp di,4                      ;dans la ligne disponible?
  jbe suivante
  xor di,di                     ;non, on recommence en haut
  jmp suivante
D_fini:
  movsx eax,delta1[si]          ;sauvegarde les valeurs de colonnes utilisées
  mov colonne1[0],eax
  movsx eax,delta1[di]
  mov colonne1[4],eax
  movsx eax,delta2[si]
  mov colonne2[0],eax
  movsx eax,delta2[di]
  mov colonne2[4],eax
  shl si,1                      ;prend note des colonnes utilisées
  shl di,1
  mov ligne_sup,si
  mov ligne_inf,di
endm


txt_incl macro                  ;poursuite du comptage à gauche
  push eax
  mov eax,inc_xl                ;avance l'abscisse 3d x
  add xl_3d,eax
  mov eax,inc_yl                ;avance l'ordonnée 3d y
  add yl_3d,eax
  mov eax,inc_zl                ;avance la profondeur 3d z
  add zl_3d,eax
  pop eax
endm
txt_incr macro                  ;poursuite du comptage à droite
  push eax
  mov eax,inc_xr                ;avance l'abscisse 3d x
  add xr_3d,eax
  mov eax,inc_yr                ;avance l'ordonnée 3d y
  add yr_3d,eax
  mov eax,inc_zr                ;avance la profondeur 3d z
  add zr_3d,eax
  pop eax
endm