texmap/tmap_ll.asm

   1 ;THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   2 ;SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   3 ;END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   4 ;ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   5 ;IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   6 ;SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   7 ;FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   8 ;CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
   9 ;AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  10 ;COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  11 ;
  12 ; $Source: /cvs/cvsroot/d2x/texmap/tmap_ll.asm,v $
  13 ; $Revision: 1.1.1.1 $
  14 ; $Author: bradleyb $
  15 ; $Date: 2001-01-19 03:30:16 $
  16 ;
  17 ; Linear, lighted texture mapper inner loop.
  18 ;
  19 ; $Log: not supported by cvs2svn $
  20 ; Revision 1.1.1.1  1999/06/14 22:13:55  donut
  21 ; Import of d1x 1.37 source.
  22 ;
  23 ; Revision 1.10  1995/02/20  18:22:54  john
  24 ; Put all the externs in the assembly modules into tmap_inc.asm.
  25 ; Also, moved all the C versions of the inner loops into a new module,
  26 ; scanline.c.
  27 ;
  28 ; Revision 1.9  1995/02/20  17:09:06  john
  29 ; Added code so that you can build the tmapper with no assembly!
  30 ;
  31 ; Revision 1.8  1994/11/19  23:52:56  mike
  32 ; rip out big unrolled loop to save 25K....remember when we cared more about speed?
  33 ;
  34 ; Revision 1.7  1994/11/12  16:39:41  mike
  35 ; jae to ja.
  36 ;
  37 ; Revision 1.6  1994/03/14  15:45:08  mike
  38 ; streamline code.
  39 ;
  40 ; Revision 1.5  1994/01/24  13:13:12  mike
  41 ; dithering.
  42 ;
  43 ; Revision 1.4  1994/01/14  14:02:47  mike
  44 ; *** empty log message ***
  45 ;
  46 ; Revision 1.3  1993/12/17  20:00:16  mike
  47 ; Change default setting of dither_intensity_lighting from 1 to 0
  48 ;
  49 ; Revision 1.2  1993/11/22  10:24:50  mike
  50 ; *** empty log message ***
  51 ;
  52 ; Revision 1.1  1993/09/08  17:29:52  mike
  53 ; Initial revision
  54 ;
  55 ;
  56 ;
  57
  58 [BITS 32]
  59
  60 global  _asm_tmap_scanline_lin_lighted
  61 global  asm_tmap_scanline_lin_lighted
  62
  63 [SECTION .data]
  64
  65 %include        "tmap_inc.asm"
  66
  67 ALLOW_DITHERING equ     1
  68
  69 _fx_dl_dx1      dd 0
  70 _fx_dl_dx2      dd 0
  71
  72 _loop_count     dd 0
  73
  74
  75 [SECTION .text]
  76
  77 ; --------------------------------------------------------------------------------------------------
  78 ; Enter:
  79 ;       _xleft  fixed point left x coordinate
  80 ;       _xright fixed point right x coordinate
  81 ;       _y      fixed point y coordinate
  82 ;       _pixptr address of source pixel map
  83 ;       _u      fixed point initial u coordinate
  84 ;       _v      fixed point initial v coordinate
  85 ;       _du_dx  fixed point du/dx
  86 ;       _dv_dx  fixed point dv/dx
  87
  88 ;   for (x = (int) xleft; x <= (int) xright; x++) {
  89 ;      _setcolor(read_pixel_from_tmap(srcb,((int) (u/z)) & 63,((int) (v/z)) & 63));
  90 ;      _setpixel(x,y);
  91 ;
  92 ;      u += du_dx;
  93 ;      v += dv_dx;
  94 ;      z += dz_dx;
  95 ;   }
  96
  97         align   4
  98 _asm_tmap_scanline_lin_lighted:
  99 asm_tmap_scanline_lin_lighted:
 100 ;        push    es  ; DPH: No selectors in windows :-(
 101 ;        push    fs
 102         pusha
 103
 104 ;        mov     es,[_pixel_data_selector]       ; selector[0*2] ; DPH: No... :-)
 105 ;        mov     fs,[_gr_fade_table_selector]    ; selector[1*2] ; fs = bmd_fade_table
 106
 107 ; Setup for loop:       _loop_count  iterations = (int) xright - (int) xleft
 108 ;   esi source pixel pointer = pixptr
 109 ;   edi initial row pointer = y*320+x
 110
 111 ; set esi = pointer to start of texture map data
 112         mov     esi,[_pixptr]
 113
 114 ; set edi = address of first pixel to modify
 115         mov     edi,[_fx_y]     ; this is actually an int
 116         cmp     edi,[_window_bottom]
 117         ja      near all_done
 118
 119         imul    edi,[_bytes_per_row]
 120         mov     ebx,[_fx_xleft]
 121         test    ebx,ebx
 122         jns     ebx_ok
 123         sub     ebx,ebx
 124 ebx_ok:
 125         add     edi,ebx
 126         add     edi,[_write_buffer]
 127
 128 ; set _loop_count = # of iterations
 129         mov     eax,[_fx_xright]
 130         cmp     eax,[_window_right]
 131         jl      eax_ok1
 132         mov     eax,[_window_right]
 133 eax_ok1:        cmp     eax,[_window_left]
 134         jg      eax_ok2
 135         mov     eax,[_window_left]
 136 eax_ok2:
 137
 138         sub     eax,ebx
 139         js      near all_done
 140         cmp     eax,[_window_width]
 141         jbe     _ok_to_do
 142         mov     eax,[_window_width]
 143 _ok_to_do:
 144         mov     [_loop_count],eax
 145
 146 ;       edi     destination pixel pointer
 147
 148
 149         mov     ecx,_gr_fade_table  ;originally offset _lighting_tables
 150         mov     eax,[_fx_u]     ; get 32 bit u coordinate
 151         shr     eax,6   ; get 6:10 int:frac u coordinate into low word
 152         mov     ebp,[_fx_v]     ; get 32 bit v coordinate
 153         shl     ebp,10  ; put 6:10 int:frac into high word
 154         mov     bp,ax   ; put u coordinate in low word
 155
 156         mov     eax,[_fx_du_dx] ; get 32 bit delta u
 157         shr     eax,6   ; get 6:10 int:frac delta u into low word
 158         mov     edx,[_fx_dv_dx] ; get 32 bit delta v
 159         shl     edx,10  ; put 6:10 int:frac into high word
 160         mov     dx,ax   ; put delta u in low word
 161
 162         sar     dword [_fx_dl_dx],8
 163         jns     dl_dx_ok
 164         inc     dword [_fx_dl_dx]       ; round towards 0 for negative deltas
 165 dl_dx_ok:
 166
 167 %if ALLOW_DITHERING
 168 ; do dithering, use lighting values which are .5 less than and .5 more than actual value
 169         mov     ebx,80h ; assume dithering on
 170         test    dword [_dither_intensity_lighting],-1
 171         jne     do_dither
 172         sub     ebx,ebx ; no dithering
 173 do_dither:
 174         mov     eax,[_fx_dl_dx]
 175         add     eax,ebx ; add 1/2
 176         mov     [_fx_dl_dx1],eax
 177         sub     eax,ebx
 178         sub     eax,ebx
 179         mov     [_fx_dl_dx2],eax
 180         mov     ebx,[_fx_xleft]
 181         xor     ebx,[_fx_y]
 182         and     ebx,1
 183         jne     dith_1
 184         xchg    eax,[_fx_dl_dx1]
 185 dith_1: mov     [_fx_dl_dx2],eax
 186 %endif
 187
 188         mov     ebx,[_fx_l]
 189
 190 ; lighting values are passed in fixed point, but need to be in 8 bit integer, 8 bit fraction so we can easily
 191 ; get the integer by reading %bh
 192         sar     ebx,8
 193
 194         test    dword [_Transparency_on],-1
 195         jne     do_transparency_ll
 196
 197 ;; esi, ecx should be free
 198 loop_test equ 1 ; set to 1 to run as loop for better profiling
 199 %if loop_test
 200         mov     esi,[_fx_dl_dx]
 201
 202         mov     ecx,[_loop_count]
 203         inc     ecx
 204         shr     ecx,1
 205         je      one_more_pix
 206         pushf
 207
 208         align   4
 209
 210 loop1:
 211         mov     eax,ebp ; get u, v
 212         shr     eax,26  ; shift out all but int(v)
 213         shld    ax,bp,6 ; shift in u, shifting up v
 214
 215         add     ebp,edx ; u += du, v += dv
 216
 217         add eax,[_pixptr] ; DPH: No selectors in windows
 218         movzx   eax,byte [eax]     ; get pixel from source bitmap
 219         mov     ah,bh   ; get lighting table
 220         add     ebx,esi ; _fx_dl_dx     ; update lighting value
 221         mov     al,[_gr_fade_table + eax]     ; xlat pixel through lighting tables
 222         mov     [edi],al        ; write pixel...
 223         inc     edi     ; ...and advance
 224
 225 ; --- ---
 226
 227         mov     eax,ebp ; get u, v
 228         shr     eax,26  ; shift out all but int(v)
 229         shld    ax,bp,6 ; shift in u, shifting up v
 230
 231         add     ebp,edx ; u += du, v += dv
 232
 233         add eax,[_pixptr] ; DPH:
 234         movzx   eax,byte [eax]     ; get pixel from source bitmap
 235         mov     ah,bh   ; get lighting table
 236         add     ebx,esi ; _fx_dl_dx     ; update lighting value
 237         mov     al,[_gr_fade_table + eax]     ; xlat pixel through lighting tables
 238         mov     [edi],al        ; write pixel...
 239         inc     edi     ; ...and advance
 240
 241         dec     ecx     ; _loop_count
 242         jne     loop1
 243
 244         popf
 245         jnc     all_done
 246
 247 one_more_pix:   mov     eax,ebp ; get u, v
 248         shr     eax,26  ; shift out all but int(v)
 249         shld    ax,bp,6 ; shift in u, shifting up v
 250
 251         add eax,[_pixptr] ; DPH:
 252         movzx   eax,byte [eax]     ; get pixel from source bitmap
 253         mov     ah,bh   ; get lighting table
 254         mov     al,[_gr_fade_table + eax]     ; xlat pixel through lighting tables
 255         mov     [edi],al        ; write pixel...
 256
 257 all_done:       popa
 258 ;        pop     fs
 259 ;        pop     es
 260         ret
 261
 262
 263 %else
 264
 265 ; usage:
 266 ;       eax     work
 267 ;       ebx     lighting value
 268 ;       ecx     _lighting_tables
 269 ;       edx     du, dv 6:10:6:10
 270 ;       ebp     u, v coordinates 6:10:6:10
 271 ;       esi     pointer to source bitmap
 272 ;       edi     write address
 273
 274 ;_size = (_end1 - _start1)/num_iters
 275 ;  note: if eax is odd, you will not be writing the last pixel, you must clean up at the end
 276 %if ALLOW_DITHERING
 277     mov eax,[_loop_count]
 278     shr eax,1
 279     neg eax
 280     add eax,num_iters
 281 %else
 282         mov     eax,num_iters
 283         sub     eax,[_loop_count]
 284
 285 %endif
 286         imul    eax,eax,(_end1 - _start1)/num_iters
 287         add     eax,_start1     ;originally offset _start1
 288         jmp     eax
 289
 290         align   4
 291 _start1:
 292
 293 ; usage:
 294 ;       eax     work
 295 ;       ebx     lighting value
 296 ;       ecx     _lighting_tables
 297 ;       edx     du, dv 6:10:6:10
 298 ;       ebp     u, v coordinates 6:10:6:10
 299 ;       esi     pointer to source bitmap
 300 ;       edi     write address
 301
 302 ; do all but the last pixel in the unwound loop, last pixel done separately because less work is needed
 303 %rep num_iters
 304 %if 1
 305
 306 ;**; inner loop if lighting value is constant
 307 ;**; can be optimized if source bitmap pixels are stored as words, then the mov ah,bh is not necessary
 308 ;**     mov     eax,ebp ; get u, v
 309 ;**     shr     eax,26  ; shift out all but int(v)
 310 ;**     shld    ax,bp,6 ; shift in u, shifting up v
 311 ;**
 312 ;**     add     ebp,edx ; u += du, v += dv
 313 ;**
 314 ;**     mov     al,[esi+eax]    ; get pixel from source bitmap
 315 ;**     mov     ah,bh   ; get lighting table
 316 ;**     mov     al,[ecx+eax]    ; xlat pixel through lighting tables
 317 ;**     mov     [edi],al        ; write pixel...
 318 ;**     inc     edi     ; ...and advance
 319
 320
 321 %if ALLOW_DITHERING
 322
 323 ; dithering
 324 ; loop contains two iterations which must be the same length
 325         mov     eax,ebp ; get u, v
 326         shr     eax,26  ; shift out all but int(v)
 327         shld    ax,bp,6 ; shift in u, shifting up v
 328
 329         add     ebp,edx ; u += du, v += dv
 330
 331         mov     al,[esi+eax]    ; get pixel from source bitmap
 332         mov     ah,bh   ; get lighting table
 333         add     ebx,[_fx_dl_dx1]        ; update lighting value
 334         mov     al,[ecx+eax]    ; xlat pixel through lighting tables
 335         mov     [edi],al        ; write pixel...
 336         inc     edi     ; ...and advance
 337
 338 ; second iteration
 339         mov     eax,ebp ; get u, v
 340         shr     eax,26  ; shift out all but int(v)
 341         shld    ax,bp,6 ; shift in u, shifting up v
 342
 343         add     ebp,edx ; u += du, v += dv
 344
 345         mov     al,[esi+eax]    ; get pixel from source bitmap
 346         mov     ah,bh   ; get lighting table
 347         add     ebx,[_fx_dl_dx2]        ; update lighting value
 348         mov     al,[ecx+eax]    ; xlat pixel through lighting tables
 349         mov     [edi],al        ; write pixel...
 350         inc     edi     ; ...and advance
 351 %else
 352         mov     eax,ebp ; get u, v
 353         shr     eax,26  ; shift out all but int(v)
 354         shld    ax,bp,6 ; shift in u, shifting up v
 355
 356         add     ebp,edx ; u += du, v += dv
 357
 358         mov     al,[esi+eax]    ; get pixel from source bitmap
 359         mov     ah,bh   ; get lighting table
 360         add     ebx,[_fx_dl_dx] ; update lighting value
 361         mov     al,[ecx+eax]    ; xlat pixel through lighting tables
 362         mov     [edi],al        ; write pixel...
 363         inc     edi     ; ...and advance
 364 %endif
 365
 366
 367 %else
 368
 369 ;obsolete: ; version which assumes segment overrides are in place (which they are obviously not)
 370 ;obsolete:      mov     eax,ebp ; get u, v
 371 ;obsolete:      shr     eax,26  ; shift out all but int(v)
 372 ;obsolete:      shld    ax,bp,6 ; shift in u, shifting up v
 373 ;obsolete:
 374 ;obsolete:      add     ebp,edx ; u += du, v += dv
 375 ;obsolete:
 376 ;obsolete:      mov     al,[eax]        ; get pixel from source bitmap
 377 ;obsolete:      mov     ah,bh   ; get lighting table
 378 ;obsolete:      add     ebx,esi ; update lighting value
 379 ;obsolete:      mov     al,[eax]        ; xlat pixel through lighting tables
 380 ;obsolete:      mov     [edi],al        ; write pixel...
 381 ;obsolete:      inc     edi     ; ...and advance
 382 %endif
 383 %endrep
 384
 385 _end1:
 386
 387 ; now do the leftover pixel
 388         mov     eax,ebp
 389         shr     eax,26  ; shift in v coordinate
 390         shld    ax,bp,6 ; shift in u coordinate while shifting up v coordinate
 391         mov     al,[esi+eax]    ; get pixel from source bitmap
 392         mov     ah,bh   ; get lighting table
 393  or ah,ah
 394  jns ok1
 395  sub ah,ah
 396 ok1:
 397         mov     al,[_gr_fade_table+eax] ; xlat pixel through lighting tables
 398         mov     [edi],al        ; write pixel...
 399
 400 _none_to_do:    popa
 401 ;        pop     fs
 402 ;        pop     es
 403         ret
 404
 405 %endif
 406 ; -- Code to get rgb 5 bits integer, 5 bits fraction value into 5 bits integer (for each gun)
 407 ; suitable for inverse color lookup
 408 ;**__test:
 409 ;** int 3
 410 ;**;                  rrrrrfffffrrrrrfffffxxbbbbbfffff
 411 ;**     mov     eax,11111001001010101110101101110111b
 412 ;**     and     eax,11111000001111100000001111100000b
 413 ;**     shld    ebx,eax,15
 414 ;**     or      bx,ax
 415
 416
 417 ;; esi, ecx should be free
 418 do_transparency_ll:
 419         mov     esi,[_fx_dl_dx]
 420
 421         mov     ecx,[_loop_count]
 422         inc     ecx
 423         shr     ecx,1
 424         je      one_more_pix2
 425         pushf
 426
 427         align   4
 428
 429 loop1a:
 430         mov     eax,ebp ; get u, v
 431         shr     eax,26  ; shift out all but int(v)
 432         shld    ax,bp,6 ; shift in u, shifting up v
 433
 434         add     ebp,edx ; u += du, v += dv
 435
 436         add eax,[_pixptr] ; DPH:
 437         movzx   eax,byte [eax]     ; get pixel from source bitmap
 438         cmp     al,255
 439         je      skip1a
 440         mov     ah,bh   ; get lighting table
 441         add     ebx,esi ; _fx_dl_dx     ; update lighting value
 442         mov     al,[_gr_fade_table + eax]     ; xlat pixel through lighting tables
 443         mov     [edi],al        ; write pixel...
 444 skip1a: inc     edi     ; ...and advance
 445
 446 ; --- ---
 447
 448         mov     eax,ebp ; get u, v
 449         shr     eax,26  ; shift out all but int(v)
 450         shld    ax,bp,6 ; shift in u, shifting up v
 451
 452         add     ebp,edx ; u += du, v += dv
 453
 454         add eax,[_pixptr] ; DPH:
 455         movzx   eax,byte [eax]     ; get pixel from source bitmap
 456         cmp     al,255
 457         je      skip2a
 458         mov     ah,bh   ; get lighting table
 459         add     ebx,esi ; _fx_dl_dx     ; update lighting value
 460         mov     al,[_gr_fade_table + eax]     ; xlat pixel through lighting tables
 461         mov     [edi],al        ; write pixel...
 462 skip2a: inc     edi     ; ...and advance
 463
 464         dec     ecx     ; _loop_count
 465         jne     loop1a
 466
 467         popf
 468         jnc     all_done_1
 469
 470 one_more_pix2:  mov     eax,ebp ; get u, v
 471         shr     eax,26  ; shift out all but int(v)
 472         shld    ax,bp,6 ; shift in u, shifting up v
 473
 474         add eax,[_pixptr] ; DPH:
 475         movzx   eax,byte [eax]     ; get pixel from source bitmap
 476         cmp     al,255
 477         je      skip3a
 478         mov     ah,bh   ; get lighting table
 479         mov     al,[_gr_fade_table + eax]     ; xlat pixel through lighting tables
 480         mov     [edi],al        ; write pixel...
 481
 482 skip3a:
 483 all_done_1:     popa
 484 ;        pop     fs ; DPH:
 485 ;        pop     es
 486         ret
 487