;dieses Include-File enth„lt alle fr die Darstellung von Texturen
;ben”tigten Makros.

txt_makevarl macro              ;l„dt die 3D-Variablen der linken Seite neu
.386
  movsx ebx,dyl                 ;Anzahl Schritte
  inc ebx
  push ecx
  push edx

  movsx eax,poly3d[bp]          ;3d-x holen
  shl eax,8                     ;unteren 8 Bit sind "Nachkomma"-Teil
  mov xl_3d,eax                 ;und schreiben
  movsx ecx,poly3d[bp+8]        ;Differenz bilden
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;Schrittweite bestimmen
  mov inc_xl,eax

  movsx eax,poly3d[bp+2]        ;3d-y holen
  shl eax,8
  mov yl_3d,eax
  movsx ecx,poly3d[bp+10d]      ;Differenz bilden
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;Schrittweite bestimmen
  mov inc_yl,eax

  movsx eax,poly3d[bp+4]        ;3d-z holen
  shl eax,8
  mov zl_3d,eax
  movsx ecx,poly3d[bp+12d]      ;Differenz bilden
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;Schrittweite bestimmen
  mov inc_zl,eax
  pop edx
  pop ecx
endm

txt_makevarr macro              ;l„dt die 3D-Variablen der rechten Seite neu
.386
  push eax
  push ebx
  movsx ebx,dyr                 ;Anzahl Schritte
  inc ebx

  movsx eax,poly3d[bp+8]        ;3d-x holen
  shl eax,8                     ;unteren 8 Bit sind "Nachkomma"-Teil
  mov xr_3d,eax                 ;und schreiben
  movsx ecx,poly3d[bp]          ;Differenz bilden
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;Schrittweite bestimmen
  mov inc_xr,eax

  movsx eax,poly3d[bp+10d]      ;3d-y holen
  shl eax,8
  mov yr_3d,eax
  movsx ecx,poly3d[bp+2]        ;Differenz bilden
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;Schrittweite bestimmen
  mov inc_yr,eax

  movsx eax,poly3d[bp+12d]      ;3d-z holen
  shl eax,8
  mov zr_3d,eax
  movsx ecx,poly3d[bp+4]        ;Differenz bilden
  shl ecx,8
  sub eax,ecx
  neg eax
  cdq
  idiv ebx                      ;Schrittweite bestimmen
  mov inc_zr,eax
  pop ebx
  pop eax
endm

txt_hline macro
hline_texture proc near         ;ersetzt Prozedur "hline" bei Texturen
.386
  push es
  pusha
  mov x0,ax                     ;Koordinaten fr sp„ter sichern
  mov y0,bx
  mov x1,cx
  sub cx,ax                     ;Anzahl zu zeichnender Punkte berechnen
  jne zzok2
  inc cx
zzok2:
  mov zz,cx

  mov bp,obere_Reihe
  mov bx,untere_Reihe
  mov eax,xr_3d[bx]             ;relative x-Koordinate bestimmen
  movsx ecx,poly3d[2]
  shl ecx,8                     ;auf "Festkomma"-Format bringen
  sub eax,ecx
  mov d_y,eax
  movsx ecx,w Spalte2[0]
  imul ecx                      ;mit Delta2 x multiplizieren
  mov esi,eax                   ;Ergebnis zwischenspeichern

  mov eax,xr_3d[bp]             ;relative y-Koordinate bestimmen
  movsx ecx,poly3d[0]
  shl ecx,8                     ;auf "Festkomma"-Format bringen
  sub eax,ecx
  mov d_x,eax
  movsx ecx,w Spalte2[4]
  imul ecx                      ;mit Delta2 y multiplizieren
  sub eax,esi                   ;Differenz (D1) bilden
  cdq                           ;Division vorbereiten
  idiv dword ptr D              ;durch Hauptdeterminante dividieren
  shl eax,8
  neg eax
  mov inc_lambda1,eax           ;fr Subtraktion sichern

  mov eax,d_x                   ;relative x-Koordinate holen
  movsx ecx,w Spalte1[4]
  imul ecx                      ;mit Delta1 y multiplizieren
  mov esi,eax                   ;Ergebnis zwischenspeichern

  mov eax,d_y                   ;relative y-Koordinate holen
  movsx ecx,w Spalte1[0]
  imul ecx                      ;mit Delta1 x multiplizieren
  sub eax,esi                   ;Differenz (D2) bilden
  cdq                           ;Division vorbereiten
  idiv dword ptr D              ;durch Hauptdeterminante dividieren
  shl eax,8
  neg eax
  mov inc_lambda2,eax           ;fr Subtraktion sichern

  mov eax,xl_3d[bx]             ;relative x-Koordinate bestimmen
  movsx ecx,poly3d[2]
  shl ecx,8                     ;auf "Festkomma"-Format bringen
  sub eax,ecx
  mov d_y,eax
  movsx ecx,w Spalte2[0]
  imul ecx                      ;mit Delta2 x multiplizieren
  mov esi,eax                   ;Ergebnis zwischenspeichern

  mov eax,xl_3d[bp]             ;relative y-Koordinate bestimmen
  movsx ecx,poly3d[0]
  shl ecx,8                     ;auf "Festkomma"-Format bringen
  sub eax,ecx
  mov d_x,eax
  movsx ecx,w Spalte2[4]
  imul ecx                      ;mit Delta2 y multiplizieren
  sub eax,esi                   ;Differenz (D1) bilden
  cdq                           ;Division vorbereiten
  idiv dword ptr D              ;durch Hauptdeterminante dividieren
  shl eax,8
  neg eax
  mov lambda1,eax               ;Lambda1 bestimmt
  sub inc_lambda1,eax

  mov eax,d_x                   ;relative x-Koordinate holen
  movsx ecx,w Spalte1[4]
  imul ecx                      ;mit Delta1 y multiplizieren
  mov esi,eax                   ;Ergebnis zwischenspeichern

  mov eax,d_y                   ;relative y-Koordinate holen
  movsx ecx,w Spalte1[0]
  imul ecx                      ;mit Delta1 x multiplizieren
  sub eax,esi                   ;Differenz (D2) bilden
  cdq                           ;Division vorbereiten
  idiv dword ptr D              ;durch Hauptdeterminante dividieren
  neg eax
  shl eax,8
  mov lambda2,eax               ;Lambda2 bestimmt
  sub inc_lambda2,eax

  mov ax,80d                    ;Offset bestimmen
  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                 ;VGA-Segment laden
  mov es,ax

  mov cx,x0                     ;Start-Plane maskieren
  and cx,3
  mov ax,1
  shl ax,cl                     ;entsprechendes Bit setzen
  mov b plane+1,al
  shl al,4                      ;und auf High-Nibble erweitern
  or b plane+1,al

  movsx ecx,zz                  ;Lambda-Schrittweiten ausrechnen
  mov eax,inc_lambda1           ;Gesamtl„nge holen
  cdq
  idiv ecx                      ;und durch Anzahl Schritte dividieren
  mov inc_lambda1,eax
  mov eax,inc_lambda2           ;Gesamtl„nge holen
  cdq
  idiv ecx                      ;und durch Anzahl Schritte dividieren
  mov inc_lambda2,eax

  mov bp,Txt_Nr                 ;Nummer der aktuellen Textur holen
  shl bp,1                      ;jeweils 2 Byte pro Eintrag
  mov bx,Txt_Groesse[bp]        ;aktuelle Gr”áenangabe holen
  mov b cs:Groesse_Patch+3,bl   ;und in Code patchen
  mov b cs:Groesse_Patch+7,bh

  mov ax,word ptr Txt_Offs[bp]  ;Offset dieser Textur holen

  push ds
  shl bp,1                      ;jeweils 4 Byte lange Eintr„ge
  lds si,dword ptr Txt_Daten[bp];Zeiger auf eigentliche Daten holen
  add si,ax
  mov w cs:Ofs_Patch+2,si       ;und in Code patchen

  mov dx,3c4h                   ;Timing Sequenzer
  mov ebp,lambda1               ;Register statt Variablen
  mov esi,lambda2

lp:                             ;wird fr jeden Punkt durchlaufen
  add ebp,inc_lambda1           ;Lambda1 und 2 weiter
  add esi,inc_lambda2

  mov ax,plane                  ;Plane holen
  out dx,ax                     ;und selektieren

  mov eax,ebp                   ;Offset innerhalb der Textur-Grafik bestimmen
  mov ebx,esi
Groesse_Patch:
  sar eax,11d                   ;Gr”áe einstellen, wird modifiziert
  sar ebx,11d
   imul eax,320d
  add ebx,eax

Ofs_Patch:
  mov al,ds:[bx+1111h]          ;Farbe aus Textur holen, wird modifiziert
  mov es:[di],al                ;Farbe eintragen
  dec cx                        ;Anzahl Punkte verringern
  je hlt_fertig                 ;alle Punkte fertig ?
  rol b plane+1,1               ;n„chste Plane
  cmp b plane+1,11h             ;Plane-šberlauf von 3 auf 0 ?
  jne lp                        ;nein, dann weiter
  inc di                        ;sonst Offset erh”hen
  jmp lp                        ;und weiter
hlt_fertig:
  pop ds
  popa
  pop es
  ret
hline_texture endp

endm

txt_Hauptdet macro              ;Hauptdeterminante berechnen
  xor si,si                     ;erster Versuch: Zeile 0 und 1
  mov di,2

naechste:
  mov ax,w delta1[si]           ;Haupt-Determinante berechnen
  imul w delta2[di]
  mov bx,ax                     ;Zwischenergebnis sichern
  mov cx,dx
  mov ax,w delta2[si]
  imul w delta1[di]
  sub bx,ax                     ;Differenz sichern
  sbb cx,dx
  mov w D,bx
  mov w D+2,cx
  or bx,cx                      ;Hauptdeterminante = 0 ?
  jne D_fertig
  add si,2                      ;dann neue Komponenten
  add di,2
  cmp di,4                      ;noch innerhalb der vorhandenen Zeilen ?
  jbe naechste
  xor di,di                     ;nein, dann oben wieder anfangen
  jmp naechste
D_fertig:
  movsx eax,delta1[si]          ;verwendete Spaltenwerte sichern
  mov spalte1[0],eax
  movsx eax,delta1[di]
  mov spalte1[4],eax
  movsx eax,delta2[si]
  mov spalte2[0],eax
  movsx eax,delta2[di]
  mov spalte2[4],eax
  shl si,1                      ;benutzte Spalten merken
  shl di,1
  mov obere_Reihe,si
  mov untere_Reihe,di
endm

txt_incl macro                  ;links weiterz„hlen
  push eax
  mov eax,inc_xl                ;3d x-Koordinate weiter
  add xl_3d,eax
  mov eax,inc_yl                ;3d y-Koordinate weiter
  add yl_3d,eax
  mov eax,inc_zl                ;3d z-Koordinate weiter
  add zl_3d,eax
  pop eax
endm
txt_incr macro                  ;rechts weiterz„hlen
  push eax
  mov eax,inc_xr                ;3d x-Koordinate weiter
  add xr_3d,eax
  mov eax,inc_yr                ;3d y-Koordinate weiter
  add yr_3d,eax
  mov eax,inc_zr                ;3d z-Koordinate weiter
  add zr_3d,eax
  pop eax
endm
