home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #6 / amigaacscoverdisc1998-061998.iso / games / descent / source / texmap / tmap_ld.asm < prev    next >
Assembly Source File  |  1998-06-08  |  10KB  |  390 lines
  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: f:/miner/source/texmap/rcs/tmap_ld.asm $
  13. ; $Revision: 1.4 $
  14. ; $Author: mike $
  15. ; $Date: 1994/11/30 00:56:53 $
  16. ;
  17. ; Inner loop of rgb lighted dithered linear texture mapper
  18. ;
  19. ; $Log: tmap_ld.asm $
  20. ; Revision 1.4  1994/11/30  00:56:53  mike
  21. ; optimization.
  22. ; 
  23. ; Revision 1.3  1994/11/12  16:39:40  mike
  24. ; jae to ja.
  25. ; 
  26. ; Revision 1.2  1993/11/22  10:23:58  mike
  27. ; *** empty log message ***
  28. ; 
  29. ; Revision 1.1  1993/09/08  17:29:49  mike
  30. ; Initial revision
  31. ; 
  32. ;
  33. ;
  34.  
  35. ; Inner loop of rgb lighted dithered linear texture mapper
  36. ; Unlike tmap_rgb.asm, this version does lighting by writing alternate
  37. ; pixels in the light color, and the other colors based on the texture map pixel data.
  38.  
  39.     .386
  40.  
  41.     public    asm_tmap_scanline_lin_ld_
  42.  
  43.     include    tmap_inc.asm
  44.  
  45. _DATA    SEGMENT DWORD PUBLIC USE32 'DATA'
  46.  
  47.     extrn    _fx_u:dword
  48.     extrn    _fx_v:dword
  49.     extrn    _fx_du_dx:dword
  50.     extrn    _fx_dv_dx:dword
  51.     extrn    _fx_y:dword
  52.     extrn    _fx_xleft:dword
  53.     extrn    _fx_xright:dword
  54.  
  55.     extrn    _pixptr:dword
  56.  
  57.     extrn    _x:dword
  58.     extrn    _loop_count:dword
  59.  
  60.     extrn    _reds_16:byte
  61.  
  62.     extrn    _fx_rgb:dword,_fx_drgb_dx:dword
  63.  
  64.     extrn    _fx_r:dword,_fx_g:dword,_fx_b:dword,_fx_dr_dx:dword,_fx_dg_dx:dword,_fx_db_dx:dword
  65.  
  66. _DATA    ENDS
  67.  
  68. DGROUP    GROUP    _DATA
  69.  
  70. _TEXT   SEGMENT PARA PUBLIC USE32 'CODE'
  71.  
  72.     ASSUME    DS:_DATA
  73.     ASSUME    CS:_TEXT
  74.  
  75. ; --------------------------------------------------------------------------------------------------
  76. ; Enter:
  77. ;    _xleft    fixed point left x coordinate
  78. ;    _xright    fixed point right x coordinate
  79. ;    _y    fixed point y coordinate
  80. ;    _pixptr    address of source pixel map
  81. ;    _u    fixed point initial u coordinate
  82. ;    _v    fixed point initial v coordinate
  83. ;    _du_dx    fixed point du/dx
  84. ;    _dv_dx    fixed point dv/dx
  85.  
  86. ;   for (x = (int) xleft; x <= (int) xright; x++) {
  87. ;      _setcolor(read_pixel_from_tmap(srcb,((int) (u/z)) & 63,((int) (v/z)) & 63));
  88. ;      _setpixel(x,y);
  89. ;
  90. ;      u += du_dx;
  91. ;      v += dv_dx;
  92. ;      z += dz_dx;
  93. ;   }
  94.  
  95.     align    4
  96. asm_tmap_scanline_lin_ld_:
  97.     pusha
  98.  
  99. ; Setup for loop:    _loop_count  iterations = (int) xright - (int) xleft
  100. ;    esi    source pixel pointer = pixptr
  101. ;    edi    initial row pointer = y*320+x
  102.  
  103. ; set esi = pointer to start of texture map data
  104.     mov    esi,_pixptr
  105.  
  106. ; set edi = address of first pixel to modify
  107.     mov    edi,_fx_y
  108.  
  109.     cmp    edi,_window_bottom
  110.     ja    _none_to_do
  111.  
  112.     imul    edi,_bytes_per_row
  113.     mov    eax,_fx_xleft
  114.     sar    eax,16
  115.     jns    eax_ok
  116.     sub    eax,eax
  117. eax_ok:
  118.     add    edi,eax
  119.     add    edi,write_buffer
  120.  
  121. ; set _loop_count = # of iterations
  122.     mov    eax,_fx_xright
  123.     sar    eax,16
  124.     cmp    eax,_window_right
  125.     jb    eax_ok1
  126.     mov    eax,_window_right
  127. eax_ok1:    cmp    eax,_window_left
  128.     ja    eax_ok2
  129.     mov    eax,_window_left
  130. eax_ok2:
  131.  
  132.     mov    ebx,_fx_xleft
  133.     sar    ebx,16
  134.     sub    eax,ebx
  135.     js    _none_to_do
  136.     cmp    eax,_window_width
  137.     jbe    _ok_to_do
  138.     mov    eax,_window_width
  139. _ok_to_do:
  140.     mov    _loop_count,eax
  141.  
  142. ;    edi    destination pixel pointer
  143.  
  144.     mov    ebx,_fx_u
  145.     mov    ebp,_fx_v
  146.  
  147.     shl    ebx,10
  148.     shl    ebp,10
  149.  
  150.     shl    _fx_du_dx,10
  151.     shl    _fx_dv_dx,10
  152.  
  153. ; rgb values are passed in the following peculiar, confidential, trade secreted, copyrighted, patented format:
  154. ; [ 5 bits ] [ 5 bits ] [ 5 bits ] [ 5 bits ] [ 2 bits ] [ 5 bits ] [ 5 bits ]
  155. ;   red int   red frac   blue int  blue frac    unused   green int  green frac
  156. ; The reason they are stored in the order red, blue, green is to optimize the process of packing together the three 5 bit
  157. ; values for red, green, blue in the conventional manner, suitable for an inverse table lookup
  158.  
  159. ; convert fixed point values in _fx_dr_dx, _fx_dg_dx, _fx_db_dx to _fx_drgb_dx
  160.     mov    eax,_fx_dg_dx    ; get green value
  161.     sar    eax,11    ; after shift, low order 10 bits are what we want
  162.     jns    dgok1
  163.     inc    eax
  164. dgok1:    shrd    ecx,eax,10    ; shift green 5i.5f into destination
  165.  
  166.     shr    ecx,2    ; shift in two don't care bits
  167.  
  168.     mov    eax,_fx_db_dx
  169.     sar    eax,11
  170.     jns    dbok1
  171.     inc    eax
  172. dbok1:    shrd    ecx,eax,10
  173.  
  174.     mov    eax,_fx_dr_dx
  175.     sar    eax,11
  176.     jns    drok1
  177.     inc    eax
  178. drok1:    shrd    ecx,eax,10    ; now %ecx is correct!
  179.     mov    _fx_drgb_dx,ecx
  180.  
  181. ; convert fixed point values in _fx_r, _fx_g, _fx_b to _fx_rgb (which is the above peculiar format)
  182.     mov    eax,_fx_g    ; get green value
  183.     sar    eax,11    ; after shift, low order 10 bits are what we want
  184.     jns    rok1
  185.     sub    eax,eax
  186. rok1:    shrd    ecx,eax,10    ; shift green 5i.5f into destination
  187.  
  188.     shr    ecx,2    ; shift in two don't care bits
  189.  
  190.     mov    eax,_fx_b
  191.     sar    eax,11
  192.     jns    bok1
  193.     sub    eax,eax
  194. bok1:    shrd    ecx,eax,10
  195.  
  196.     mov    eax,_fx_r
  197.     sar    eax,11
  198.     jns    gok1
  199.     sub    eax,eax
  200. gok1:    shrd    ecx,eax,10    ; now %ecx is correct!
  201.  
  202.  
  203. ; double deltas because we are only writing half as many pixels
  204.     sal    _fx_du_dx,1
  205.     sal    _fx_dv_dx,1
  206.     sal    _fx_drgb_dx,1
  207.  
  208. ; ---------- Check x and y coords to figure whether to write pixel:light or light:pixel ----------
  209.     mov    eax,_fx_xleft    ; get x coordinate
  210.     shr    eax,16    ; preserve only integer portion
  211.     xor    eax,_fx_y    ; get checkerboard status
  212.     shr    eax,1    ; if cy set, then we were odd, else even
  213.     jc    _xy_odd
  214.  
  215. ; even case, write pixel:light
  216.     test    edi,1    ; even align to start
  217.     je    _even1    ; we are already even aligned
  218.  
  219. ; we are going to write to an odd address, so write pixel first
  220.  
  221. ; do the regular texture mapper linear interpolation to get the pixel from the source bitmap
  222.     sub    edx,edx
  223.     shld    edx,ebp,6    ; shift in v coordinate
  224.     add    ebp,_fx_dv_dx    ; update v coordinate
  225.     shld    edx,ebx,6    ; shift in u coordinate while shifting up v coordinate
  226.     add    ebx,_fx_du_dx    ; update u coordinate
  227.     mov    al,[esi+edx]    ; get pixel from source bitmap
  228.  
  229. ; write the pixel
  230.     mov    [edi],al    ; write texture map pixel, then red value
  231.     inc    edi
  232.  
  233.     dec    _loop_count
  234.     js    _none_to_do    ; all done
  235.  
  236.     inc    _loop_count
  237.     shr    _loop_count,1
  238.     je    _odd_do_last_pixel    ; want to write light for last pixel
  239.  
  240.     pushf
  241.     jmp    write_light_pixel_loop
  242.  
  243. _even1:
  244.  
  245. ; now write all the double pixels, light, then pixel
  246.     inc    _loop_count
  247.     shr    _loop_count,1
  248.     je    _even_do_last_pixel
  249.  
  250.  
  251.     pushf
  252. ; usage:
  253. ;    eax    work
  254. ;    ebx    u coordinate
  255. ;    ecx    rgb (actually rbg, each i5.f5 with 2 bits between blue and green)
  256. ;    edx    work
  257. ;    ebp    v coordinate
  258. ;    esi    pointer to source bitmap
  259. ;    edi    write address
  260.  
  261. ; do all but the last pixel in the unwound loop, last pixel done separately because less work is needed
  262. ; interpolate the rgb values
  263. write_pixel_light_loop:
  264. _loop1:    sub    eax,eax
  265.     shld    eax,ecx,4    ; shift in high 4 bits of red gun
  266.     add    ecx,_fx_drgb_dx
  267.  
  268.     mov    ah,_reds_16[eax]    ; get color index for 4 bit red value
  269.  
  270. ; do the regular texture mapper linear interpolation to get the pixel from the source bitmap
  271.     sub    edx,edx
  272.     shld    edx,ebp,6    ; shift in v coordinate
  273.     add    ebp,_fx_dv_dx    ; update v coordinate
  274.     shld    edx,ebx,6    ; shift in u coordinate while shifting up v coordinate
  275.     add    ebx,_fx_du_dx    ; update u coordinate
  276.     mov    al,[esi+edx]    ; get pixel from source bitmap
  277.  
  278. ; write the pixel
  279.     mov    [edi],ax    ; write texture map pixel, then red value
  280.     add    edi,2
  281.  
  282.     dec    _loop_count
  283.     jne    _loop1
  284.  
  285.     popf
  286.     jnc    _none_to_do
  287.  
  288. ; now do the leftover pixel
  289.  
  290. ; do the regular texture mapper linear interpolation to get the pixel from the source bitmap
  291. _even_do_last_pixel:
  292.     sub    edx,edx
  293.     shld    edx,ebp,6    ; shift in v coordinate
  294.     shld    edx,ebx,6    ; shift in u coordinate while shifting up v coordinate
  295.     mov    al,[esi+edx]    ; get pixel from source bitmap
  296.  
  297. ; write the pixel
  298.     mov    [edi],al
  299.  
  300. _none_to_do:    popa
  301.  
  302.     ret
  303.  
  304. _xy_odd:
  305. ; even case, write pixel:light
  306.     test    edi,1    ; even align to start
  307.     je    _even2    ; we are already even aligned
  308.  
  309. ; we are going to write to an odd address, so write light first
  310.  
  311.     sub    eax,eax
  312.     shld    eax,ecx,4    ; shift in high 4 bits of red gun
  313.     add    ecx,_fx_drgb_dx
  314.  
  315.     mov    al,_reds_16[eax]    ; get color index for 4 bit red value
  316.     mov    [edi],al    ; write texture map pixel, then red value
  317.     inc    edi
  318.  
  319.     dec    _loop_count
  320.     js    _done2    ; all done
  321.  
  322. ; now write all the double pixels, light, then pixel
  323.     inc    _loop_count
  324.     shr    _loop_count,1
  325.     je    _even_do_last_pixel
  326.  
  327.     pushf
  328.     jmp    write_pixel_light_loop
  329. _even2:
  330.  
  331. ; now write all the double pixels, light, then pixel
  332.     inc    _loop_count
  333.     shr    _loop_count,1
  334.     je    _odd_do_last_pixel
  335.  
  336.  
  337.     pushf
  338. ; usage:
  339. ;    eax    work
  340. ;    ebx    u coordinate
  341. ;    ecx    rgb (actually rbg, each i5.f5 with 2 bits between blue and green)
  342. ;    edx    work
  343. ;    ebp    v coordinate
  344. ;    esi    pointer to source bitmap
  345. ;    edi    write address
  346.  
  347. ; do all but the last pixel in the unwound loop, last pixel done separately because less work is needed
  348. ; interpolate the rgb values
  349. write_light_pixel_loop:
  350. _loop2:    sub    eax,eax
  351.     shld    eax,ecx,4    ; shift in high 4 bits of red gun
  352.     add    ecx,_fx_drgb_dx
  353.  
  354.     mov    al,_reds_16[eax]    ; get color index for 4 bit red value
  355.  
  356. ; do the regular texture mapper linear interpolation to get the pixel from the source bitmap
  357.     sub    edx,edx
  358.     shld    edx,ebp,6    ; shift in v coordinate
  359.     add    ebp,_fx_dv_dx    ; update v coordinate
  360.     shld    edx,ebx,6    ; shift in u coordinate while shifting up v coordinate
  361.     add    ebx,_fx_du_dx    ; update u coordinate
  362.     mov    ah,[esi+edx]    ; get pixel from source bitmap
  363.  
  364. ; write the pixel
  365.     mov    [edi],ax    ; write texture map pixel, then red value
  366.     add    edi,2
  367.  
  368.     dec    _loop_count
  369.     jne    _loop2
  370.  
  371.     popf
  372.     jnc    _done2
  373.  
  374. ; now do the leftover light pixel
  375. _odd_do_last_pixel:
  376.     sub    eax,eax
  377.     shld    eax,ecx,4    ; shift in high 4 bits of red gun
  378.     mov    al,_reds_16[eax]    ; get color index for 4 bit red value
  379.     mov    [edi],al    ; write texture map pixel, then red value
  380.  
  381. _done2:
  382.     popa
  383.     ret
  384.  
  385. _TEXT    ends
  386.  
  387.     end
  388.  
  389.  
  390.