home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #6 / amigaacscoverdisc1998-061998.iso / games / descent / source / vecmat / vecmat.asm < prev    next >
Assembly Source File  |  1998-06-08  |  34KB  |  1,616 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/vecmat/rcs/vecmat.asm $
  13. ; $Revision: 1.54 $
  14. ; $Author: matt $
  15. ; $Date: 1995/01/31 00:14:50 $
  16. ;
  17. ; Source for vector/matrix library
  18. ;
  19. ; $Log: vecmat.asm $
  20. ; Revision 1.54  1995/01/31  00:14:50  matt
  21. ; Took out int3 from dotprod overflow, since it saturates now
  22. ; 
  23. ; Revision 1.53  1994/12/14  18:29:33  matt
  24. ; Made dotprod overflow check stay in, and return saturated value
  25. ; 
  26. ; Revision 1.52  1994/12/14  12:34:13  matt
  27. ; Disabled now-unused vector_2_matrix_norm()
  28. ; 
  29. ; Revision 1.51  1994/12/13  16:55:13  matt
  30. ; Ripped out optimization from last version, which was bogus
  31. ; 
  32. ; Revision 1.50  1994/12/13  14:55:18  matt
  33. ; Use quick normalize in a couple of places where it was safe to do so
  34. ; 
  35. ; Revision 1.49  1994/12/13  14:44:12  matt
  36. ; Added vm_vector_2_matrix_norm()
  37. ; 
  38. ; Revision 1.48  1994/12/13  13:26:49  matt
  39. ; Fixed overflow check
  40. ; 
  41. ; Revision 1.47  1994/12/03  15:39:54  matt
  42. ; Gracefully handle some vector_2_matrix problems
  43. ; 
  44. ; Revision 1.46  1994/11/19  17:15:05  matt
  45. ; Assemble out some code not used in DESCENT
  46. ; 
  47. ; Revision 1.45  1994/11/17  11:41:05  matt
  48. ; Put handling in extract_angles_from_matrix to deal with bad matrices
  49. ; 
  50. ; Revision 1.44  1994/11/16  11:48:10  matt
  51. ; Added error checking to vm_extract_angles_matrix()
  52. ; 
  53. ; Revision 1.43  1994/09/19  22:00:10  matt
  54. ; Fixed register trash
  55. ; 
  56. ; Revision 1.42  1994/09/11  19:23:05  matt
  57. ; Added vm_vec_normalized_dir_quick()
  58. ; 
  59. ; Revision 1.41  1994/08/14  13:28:38  matt
  60. ; Put in check for zero-length vector in extract angles
  61. ; 
  62. ; Revision 1.40  1994/07/19  18:52:53  matt
  63. ; Added vm_vec_normalize_quick() and vm_vec_copy_normalize_quick()
  64. ; 
  65. ; Revision 1.39  1994/06/16  18:24:22  matt
  66. ; Added vm_vec_mag_quick()
  67. ; 
  68. ; Revision 1.38  1994/06/10  23:18:38  matt
  69. ; Added new code for vm_vec_ang_2_matrix() which may be better, but may
  70. ; not be.
  71. ; 
  72. ; Revision 1.37  1994/05/22  18:17:29  mike
  73. ; Optimize vm_vec_dist_quick, using jns in place of abs_eax.
  74. ; 
  75. ; Revision 1.36  1994/05/19  12:07:04  matt
  76. ; Fixed globals and macros and added a constant
  77. ; 
  78. ; Revision 1.35  1994/05/19  09:19:00  matt
  79. ; Made vm_vec_normalized_dir() return mag of vector
  80. ; 
  81. ; Revision 1.34  1994/05/18  22:28:01  matt
  82. ; Added function vm_vec_normalized_dir()
  83. ; Added C macros IS_ZERO_VEC(), vm_vec_zero(), and vm_set_identity()
  84. ; Added C global static vars vmd_zero_vector & vmd_identity_matrix
  85. ; 
  86. ; Revision 1.33  1994/05/18  21:44:16  matt
  87. ; Added functions:
  88. ;   vm_extract_angles_vector()
  89. ;   vm_extract_angles_vector_normalized()
  90. ;   vm_vec_copy_normalize()
  91. ; 
  92. ; Revision 1.32  1994/05/13  12:41:51  matt
  93. ; Added new function, vm_vec_dist_quick(), which does an approximation.
  94. ; 
  95. ; Revision 1.31  1994/05/04  17:41:31  mike
  96. ; Comment out debug_brk on null vector.
  97. ; 
  98. ; Revision 1.30  1994/04/15  21:41:31  matt
  99. ; Check for foward vector straigt up in extract angles routine
  100. ; 
  101. ; Revision 1.29  1994/03/30  15:45:05  matt
  102. ; Added two functions, vm_vec_scale_add() & vm_vec_scale_add2()
  103. ; 
  104. ; Revision 1.28  1994/02/26  19:23:35  matt
  105. ; Do an int3 when we get a null vector when computing surface normal
  106. ; 
  107. ; Revision 1.27  1994/02/10  18:29:45  matt
  108. ; Changed 'if DEBUG_ON' to 'ifndef NDEBUG'
  109. ; 
  110. ; Revision 1.26  1994/02/10  18:28:55  matt
  111. ; Fixed bugs in extract angles function
  112. ; 
  113. ; Revision 1.25  1994/01/31  22:46:07  matt
  114. ; Added vm_extract_angles_matrix() function
  115. ; 
  116. ; Revision 1.24  1994/01/30  19:29:55  matt
  117. ; Put in debug_brk when vm_vec_2_matrix got zero-length vector
  118. ; 
  119. ; Revision 1.23  1994/01/25  15:27:59  matt
  120. ; Added debugging check for dotprod overflow
  121. ; 
  122. ; Revision 1.22  1994/01/24  11:52:59  matt
  123. ; Added checking for dest==src for several functions where this is not allowed
  124. ; 
  125. ; Revision 1.21  1994/01/19  23:13:02  matt
  126. ; Fixed bug in vm_vec_ang_2_matrix()
  127. ; 
  128. ; Revision 1.20  1994/01/04  12:33:43  mike
  129. ; Prevent divide overflow in vm_vec_scale2
  130. ; 
  131. ; Revision 1.19  1993/12/21  19:46:26  matt
  132. ; Added function vm_dist_to_plane()
  133. ; 
  134. ; Revision 1.18  1993/12/13  17:26:23  matt
  135. ; Added vm_vec_dist()
  136. ; 
  137. ; Revision 1.17  1993/12/02  12:43:39  matt
  138. ; New functions: vm_vec_copy_scale(), vm_vec_scale2()
  139. ; 
  140. ; Revision 1.16  1993/10/29  22:39:29  matt
  141. ; Changed matrix order, making direction vectors the rows
  142. ; 
  143. ; Revision 1.15  1993/10/29  18:06:01  matt
  144. ; Fixed vm_vector_2_matrix() bug when forward vector was straight down
  145. ; 
  146. ; Revision 1.14  1993/10/26  18:51:26  matt
  147. ; Fixed some register trashes in vm_vec_ang_2_matrix()
  148. ; 
  149. ; Revision 1.13  1993/10/25  11:49:37  matt
  150. ; Made vm_vec_delta_ang() take optional forward vector to return signed delta
  151. ; 
  152. ; Revision 1.12  1993/10/20  01:09:42  matt
  153. ; Added vm_vec_delta_ang(), vm_vec_delta_ang_norm(), and vm_vec_ang_2_matrix()
  154. ; 
  155. ; Revision 1.11  1993/10/17  17:03:08  matt
  156. ; vm_vector_2_matrix() now takes optional right vector
  157. ; 
  158. ; Revision 1.10  1993/10/10  18:11:42  matt
  159. ; Changed angles_2_matrix so that heading & bank rotate in the 
  160. ; correct directions.
  161. ; 
  162. ; Revision 1.9  1993/09/30  16:17:59  matt
  163. ; Fixed bug in vector_2_matrix() by adding another normalize
  164. ; 
  165. ; Revision 1.8  1993/09/29  10:51:58  matt
  166. ; Fixed bad register trashes in crossprod, perp, & normal
  167. ; 
  168. ; Revision 1.7  1993/09/28  12:16:46  matt
  169. ; Fixed bugs in cross product
  170. ; Added func vm_vector_2_matrix()
  171. ; 
  172. ; Revision 1.6  1993/09/24  21:19:37  matt
  173. ; Added vm_vec_avg() and vm_vec_avg4()
  174. ; 
  175. ; Revision 1.5  1993/09/20  18:15:07  matt
  176. ; Trap zero-length vectors in vm_vec_normalize(), vm_vec_perp(), and vm_vec_normal()
  177. ; 
  178. ; Revision 1.4  1993/09/20  14:56:43  matt
  179. ; Fixed bug in vm_vec_normal(), made that routine normalize the results,
  180. ; and added new function vm_vec_perp().
  181. ; 
  182. ; Revision 1.3  1993/09/20  10:12:06  mike
  183. ; no changes
  184. ; 
  185. ; Revision 1.2  1993/09/17  11:10:33  matt
  186. ; Added vm_vec_add2() and vm_vec_sub2(), which take 2 args (dest==src0)
  187. ; 
  188. ; Revision 1.1  1993/09/16  20:10:24  matt
  189. ; Initial revision
  190. ; 
  191. ;
  192. ;
  193.  
  194. .386
  195.     option    oldstructs
  196.  
  197.     .nolist
  198.     include    psmacros.inc
  199.     include    vecmat.inc
  200.     .list
  201.  
  202.     assume    cs:_TEXT, ds:_DATA
  203.  
  204. _DATA    segment    dword public USE32 'DATA'
  205.  
  206. rcsid    db    "$Id: vecmat.asm 1.54 1995/01/31 00:14:50 matt Exp $"
  207.     even
  208.  
  209. ;these symbols enable/disable code which is unused in DESCENT
  210. AVG4_ENABLED    = 0
  211. V2MN_ENABLED    = 0
  212.  
  213. ;temporary vectors for surface normal calculation
  214. tempv0    vms_vector <>
  215. tempv1    vms_vector <>
  216.  
  217. xvec    vms_vector <>
  218. yvec    vms_vector <>
  219. zvec    vms_vector <>
  220.  
  221. tempav    vms_angvec <>
  222.  
  223. ;sine & cosine values for angles_2_matrix
  224. sinp    fix    ?
  225. cosp    fix    ?
  226. sinb    fix    ?
  227. cosb    fix    ?
  228. sinh    fix    ?
  229. cosh    fix    ?
  230.  
  231. ;These should never be changed!
  232. _vmd_zero_vector    label    vms_vector
  233.     fix    0,0,0
  234.  
  235. _vmd_identity_matrix label    vms_matrix
  236.     fix    f1_0,0,0
  237.     fix    0,f1_0,0
  238.     fix    0,0,f1_0
  239.  
  240. _DATA    ends
  241.  
  242.  
  243.  
  244. _TEXT    segment    dword public USE32 'CODE'
  245.  
  246. ;add two vectors, filling in dest
  247. ;takes eax=dest, esi,edi=sources, returns eax=dest
  248. vm_vec_add:    push    ebx    ;save work reg
  249.  
  250.     for    ofs,<x,y,z>
  251.      mov    ebx,[esi].ofs
  252.      add    ebx,[edi].ofs
  253.      mov    [eax].ofs,ebx
  254.     endm
  255.  
  256.     pop    ebx
  257.  
  258.     ret
  259.  
  260. ;subtracts two vectors, filling in dest
  261. ;takes eax=dest, esi,edi=sources, returns eax=dest
  262. vm_vec_sub:    push    ebx    ;save work reg
  263.  
  264.     for    ofs,<x,y,z>
  265.      mov    ebx,[esi].ofs
  266.      sub    ebx,[edi].ofs
  267.      mov    [eax].ofs,ebx
  268.     endm
  269.  
  270.     pop    ebx
  271.  
  272.     ret
  273.  
  274.  
  275. ;adds one vector to antother
  276. ;takes edi=dest, esi=source, returns edi=dest
  277. vm_vec_add2:    push    ebx    ;save work reg
  278.  
  279.     for    ofs,<x,y,z>
  280.      mov    ebx,[esi].ofs
  281.      add    [edi].ofs,ebx
  282.     endm
  283.  
  284.     pop    ebx
  285.  
  286.     ret
  287.  
  288. ;subtract one vector from another
  289. ;takes edi=dest, esi=source, returns edi=dest
  290. vm_vec_sub2:    push    ebx    ;save work reg
  291.  
  292.     for    ofs,<x,y,z>
  293.      mov    ebx,[esi].ofs
  294.      sub    [edi].ofs,ebx
  295.     endm
  296.  
  297.     pop    ebx
  298.  
  299.     ret
  300.  
  301. ;averages two vectors. takes eax=dest, esi,edi=srcs
  302. vm_vec_avg:    push    ebx
  303.  
  304.     for    ofs,<x,y,z>
  305.      mov    ebx,[esi].ofs
  306.      add    ebx,[edi].ofs
  307.      sar    ebx,1
  308.      mov    [eax].ofs,ebx
  309.     endm
  310.  
  311.     pop    ebx
  312.     ret
  313.  
  314.     if    AVG4_ENABLED
  315. ;averages four vectors. takes eax=dest, esi,edi,ecx,edx=srcs
  316. vm_vec_avg4:    push    ebx
  317.  
  318.     for    ofs,<x,y,z>
  319.      mov    ebx,[esi].ofs
  320.      add    ebx,[edi].ofs
  321.      add    ebx,[ecx].ofs
  322.      add    ebx,[edx].ofs
  323.      sar    ebx,2
  324.      mov    [eax].ofs,ebx
  325.     endm
  326.  
  327.     pop    ebx
  328.     ret
  329.     endif
  330.  
  331. ;scales a vector in place.  takes ebx=vector, ecx=scale. returns ebx=vector
  332. vm_vec_scale:    pushm    eax,edx
  333.  
  334.     for    ofs,<x,y,z>
  335.      mov    eax,[ebx].ofs
  336.      fixmul    ecx
  337.      mov    [ebx].ofs,eax
  338.     endm
  339.  
  340.     popm    eax,edx
  341.     ret
  342.  
  343. ;scales and copies a vector.  takes edi=dest, ebx=src, ecx=scale. returns edi=vector
  344. vm_vec_copy_scale:    pushm    eax,edx
  345.  
  346.     for    ofs,<x,y,z>
  347.      mov    eax,[ebx].ofs
  348.      fixmul    ecx
  349.      mov    [edi].ofs,eax
  350.     endm
  351.  
  352.     popm    eax,edx
  353.     ret
  354.  
  355. ;scales a vector, adds it to another, and stores in a 3rd
  356. ;takes edi=dest, ebx=src1, esi=src2, ecx=scale. returns edi=vector
  357. vm_vec_scale_add:    pushm    eax,edx
  358.  
  359.     for    ofs,<x,y,z>
  360.      mov    eax,[esi].ofs
  361.      fixmul    ecx
  362.      add    eax,[ebx].ofs
  363.      mov    [edi].ofs,eax
  364.     endm
  365.  
  366.     popm    eax,edx
  367.     ret
  368.  
  369. ;scales a vector and adds it to another.  takes edi=dest, esi=src, ecx=scale. returns edi=vector
  370. vm_vec_scale_add2:    pushm    eax,edx
  371.  
  372.     for    ofs,<x,y,z>
  373.      mov    eax,[esi].ofs
  374.      fixmul    ecx
  375.      add    [edi].ofs,eax
  376.     endm
  377.  
  378.     popm    eax,edx
  379.     ret
  380.  
  381. ;scales a vector in place, taking n/d for scale.  takes edi=vector, ebx=n,ecx=d. returns edi=vector
  382. vm_vec_scale2:    pushm    eax,edx
  383.  
  384.     or    ecx,ecx    ; @mk, 01/04/94, prevent divide overflow
  385.     je    vmvs_out
  386.     for    ofs,<x,y,z>
  387.      mov    eax,[edi].ofs
  388.      imul    ebx
  389.      idiv    ecx
  390.      mov    [edi].ofs,eax
  391.     endm
  392.  
  393.     popm    eax,edx
  394. vmvs_out:    ret
  395.  
  396. ;compute the distance between two points. (does sub and mag)
  397. ;takes esi,edi=points, returns eax=dist
  398. vm_vec_dist:    pushm    ebx,ecx,edx
  399.  
  400.     mov    eax,[esi].x
  401.     sub    eax,[edi].x
  402.     imul    eax
  403.     mov    ebx,eax
  404.     mov    ecx,edx
  405.  
  406.     mov    eax,[esi].y
  407.     sub    eax,[edi].y
  408.     imul    eax
  409.     add    ebx,eax
  410.     adc    ecx,edx
  411.  
  412.     mov    eax,[esi].z
  413.     sub    eax,[edi].z
  414.     imul    eax
  415.     add    eax,ebx
  416.     adc    edx,ecx
  417.  
  418.     call    quad_sqrt
  419.  
  420.     popm    ebx,ecx,edx
  421.     ret
  422.  
  423.  
  424. ;computes an approximation of the magnitude of a vector
  425. ;uses dist = largest + next_largest*3/8 + smallest*3/16
  426. ;takes esi=vector, returns eax=dist
  427.     align    4
  428. vm_vec_mag_quick:    pushm    ebx,ecx,edx
  429.  
  430.     mov    eax,[esi].x
  431.     or    eax,eax
  432.     jns    eax_ok2
  433.     neg    eax
  434. eax_ok2:
  435.  
  436.     mov    ebx,[esi].y
  437.     or    ebx,ebx
  438.     jns    ebx_ok2
  439.     neg    ebx
  440. ebx_ok2:
  441.  
  442.     mov    ecx,[esi].z
  443.     or    ecx,ecx
  444.     jns    ecx_ok2
  445.     neg    ecx
  446. ecx_ok2:
  447.  
  448. mag_quick_eax_ebx_ecx:
  449.  
  450.     cmp    eax,ebx
  451.     jg    no_swap_ab
  452.     xchg    eax,ebx
  453. no_swap_ab:    cmp    ebx,ecx
  454.     jg    do_add
  455.     xchg    ebx,ecx
  456.     cmp    eax,ebx
  457.     jg    do_add
  458.     xchg    eax,ebx
  459.  
  460. do_add:    sar    ebx,2    ;    b*1/4
  461.     sar    ecx,3    ;            c*1/8
  462.     add    ebx,ecx    ;    b*1/4 + c*1/8
  463.     add    eax,ebx    ;a + b*1/4 + c*1/8
  464.     sar    ebx,1    ;    b*1/8 + c*1/16
  465.     add    eax,ebx    ;a + b*3/4 + c*3/16
  466.  
  467.     popm    ebx,ecx,edx
  468.     ret
  469.  
  470. ;computes an approximation of the distance between two points.
  471. ;uses dist = largest + next_largest*3/8 + smallest*3/16
  472. ;takes esi,edi=points, returns eax=dist
  473.     align    4
  474. vm_vec_dist_quick:    pushm    ebx,ecx,edx
  475.  
  476.     mov    ebx,[esi].x
  477.     sub    ebx,[edi].x
  478.     jns    ebx_ok
  479.     neg    ebx
  480. ebx_ok:
  481.  
  482.     mov    ecx,[esi].y
  483.     sub    ecx,[edi].y
  484.     jns    ecx_ok
  485.     neg    ecx
  486. ecx_ok:
  487.     mov    eax,[esi].z
  488.     sub    eax,[edi].z
  489.     jns    eax_ok
  490.     neg    eax
  491. eax_ok:
  492.     jmp    mag_quick_eax_ebx_ecx
  493.  
  494.  
  495. ;compute magnitude of vector. takes esi=vector, returns eax=mag
  496. vm_vec_mag:    pushm    ebx,ecx,edx
  497.  
  498.     mov    eax,[esi].x
  499.     imul    eax
  500.     mov    ebx,eax
  501.     mov    ecx,edx
  502.  
  503.     mov    eax,[esi].y
  504.     imul    eax
  505.     add    ebx,eax
  506.     adc    ecx,edx
  507.  
  508.     mov    eax,[esi].z
  509.     imul    eax
  510.     add    eax,ebx
  511.     adc    edx,ecx
  512.  
  513.     call    quad_sqrt
  514.  
  515.     popm    ebx,ecx,edx
  516.     ret
  517.  
  518.  
  519. ;return the normalized direction vector between two points
  520. ;dest = normalized(end - start).
  521. ;takes edi=dest, esi=endpoint, ebx=startpoint.  Returns mag of dir vec
  522. ;NOTE: the order of the parameters matches the vector subtraction
  523. vm_vec_normalized_dir:
  524.     pushm    ebp,eax,ebx,edx
  525.     mov    ebp,ebx
  526.  
  527.     mov    eax,[esi].x
  528.     sub    eax,[ebp].x
  529.     mov    [edi].x,eax
  530.     imul    eax
  531.     mov    ebx,eax
  532.     mov    ecx,edx
  533.  
  534.     mov    eax,[esi].y
  535.     sub    eax,[ebp].y
  536.     mov    [edi].y,eax
  537.     imul    eax
  538.     add    ebx,eax
  539.     adc    ecx,edx
  540.  
  541.     mov    eax,[esi].z
  542.     sub    eax,[ebp].z
  543.     mov    [edi].z,eax
  544.     imul    eax
  545.     add    eax,ebx
  546.     adc    edx,ecx
  547.  
  548.     call    quad_sqrt
  549.  
  550.     mov    ecx,eax    ;mag in ecx
  551.     jecxz    no_div2
  552.  
  553.     for    ofs,<x,y,z>
  554.      mov    eax,[edi].ofs
  555.      fixdiv    ecx
  556.      mov    [edi].ofs,eax
  557.     endm
  558.  
  559. no_div2:
  560.     ;return value (mag) in ecx
  561.  
  562.     popm    ebp,eax,ebx,edx
  563.     ret
  564.  
  565.     
  566. ;save as vm_vec_normalized_dir, but with quick sqrt
  567. ;takes edi=dest, esi=endpoint, ebx=startpoint.  Returns mag of dir vec
  568. vm_vec_normalized_dir_quick:
  569.     pushm    eax,edi,esi
  570.  
  571.     mov    eax,edi
  572.     mov    edi,ebx    ;regs right for sub
  573.     call    vm_vec_sub
  574.  
  575.     mov    esi,eax
  576.     call    vm_vec_normalize_quick
  577.  
  578.     ;return value (mag) in ecx
  579.  
  580.     popm    eax,edi,esi
  581.     ret
  582.  
  583.     
  584.  
  585. ;normalize a vector in place.  takes esi=vector
  586. ;returns ecx=mag of source vec. trashes edi
  587. vm_vec_normalize:    push    edi
  588.     mov    edi,esi
  589.     call    vm_vec_copy_normalize
  590.     pop    edi
  591.     ret
  592.  
  593. ;normalize a vector.  takes edi=dest, esi=vector
  594. ;returns ecx=mag of source vec
  595. vm_vec_copy_normalize:
  596.     pushm    eax,ebx,edx
  597.  
  598.     mov    eax,[esi].x
  599.     imul    eax
  600.     mov    ebx,eax
  601.     mov    ecx,edx
  602.  
  603.     mov    eax,[esi].y
  604.     imul    eax
  605.     add    ebx,eax
  606.     adc    ecx,edx
  607.  
  608.     mov    eax,[esi].z
  609.     imul    eax
  610.     add    eax,ebx
  611.     adc    edx,ecx
  612.  
  613.     call    quad_sqrt
  614.  
  615.     mov    ecx,eax    ;mag in ecx
  616.     jecxz    no_div
  617.  
  618.     for    ofs,<x,y,z>
  619.      mov    eax,[esi].ofs
  620.      fixdiv    ecx
  621.      mov    [edi].ofs,eax
  622.     endm
  623.  
  624. no_div:    popm    eax,ebx,edx
  625.  
  626.     ret
  627.  
  628. ;normalize a vector in place.  takes esi=vector
  629. ;returns ecx=mag of source vec. trashes edi
  630. ;uses approx. dist
  631. vm_vec_normalize_quick:
  632.     push    edi
  633.     mov    edi,esi
  634.     call    vm_vec_copy_normalize_quick
  635.     pop    edi
  636.     ret
  637.  
  638. ;normalize a vector.  takes edi=dest, esi=vector
  639. ;returns ecx=mag of source vec
  640. ;uses approx. dist
  641. vm_vec_copy_normalize_quick:
  642.     pushm    eax,ebx,edx
  643.  
  644.     call    vm_vec_mag_quick
  645.  
  646.     mov    ecx,eax    ;mag in ecx
  647.     jecxz    no_div_q
  648.  
  649.     for    ofs,<x,y,z>
  650.      mov    eax,[esi].ofs
  651.      fixdiv    ecx
  652.      mov    [edi].ofs,eax
  653.     endm
  654.  
  655. no_div_q:    popm    eax,ebx,edx
  656.  
  657.     ret
  658.  
  659. ;compute dot product of two vectors. takes esi,edi=vectors, returns eax=dotprod
  660. vm_vec_dotprod:    pushm    ebx,ecx,edx
  661.  
  662.     mov    eax,[esi].x
  663.     imul    [edi].x
  664.     mov    ebx,eax
  665.     mov    ecx,edx
  666.  
  667.     mov    eax,[esi].y
  668.     imul    [edi].y
  669.     add    ebx,eax
  670.     adc    ecx,edx
  671.  
  672.     mov    eax,[esi].z
  673.     imul    [edi].z
  674.     add    eax,ebx
  675.     adc    edx,ecx
  676.  
  677.     shrd    eax,edx,16
  678.  
  679.     ;ifndef    NDEBUG    ;check for overflow
  680.     ;always do overflow check, and return saturated value
  681.     sar    edx,16    ;get real sign from high word
  682.     mov    ebx,edx
  683.     cdq        ;get sign of our result 
  684.     cmp    bx,dx    ;same sign?
  685.     je    no_oflow
  686.     ;;debug_brk    'overflow in vm_vec_dotprod'
  687.     mov    eax,7fffffffh
  688.     or    ebx,ebx    ;check desired sign
  689.     jns    no_oflow
  690.     neg    eax
  691. no_oflow:
  692.     ;endif
  693.  
  694.     popm    ebx,ecx,edx
  695.  
  696.     ret
  697.  
  698.  
  699. ;computes cross product of two vectors. takes eax=dest, esi,edi=src vectors
  700. ;returns eax=dest.  Note: this magnitude of the resultant vector is the
  701. ;product of the magnitudes of the two source vectors.  This means it is
  702. ;quite easy for this routine to overflow and underflow.  Be careful that
  703. ;your inputs are ok.
  704. vm_vec_crossprod:
  705.     ifndef    NDEBUG
  706.      cmp    eax,esi
  707.      break_if    e,'crossprod: dest==src0'
  708.      cmp    eax,edi
  709.      break_if    e,'crossprod: dest==src1'
  710.     endif
  711.  
  712.     pushm    ebx,ecx,edx,ebp
  713.  
  714.     mov    ebp,eax
  715.  
  716.     mov    eax,[edi].y
  717.     imul    [esi].z
  718.     mov    ebx,eax
  719.     mov    ecx,edx
  720.     mov    eax,[edi].z
  721.     imul    [esi].y
  722.     sub    eax,ebx
  723.     sbb    edx,ecx
  724.     shrd    eax,edx,16
  725.     ifndef    NDEBUG    ;check for overflow
  726.      mov    ebx,edx    ;save
  727.      cdq        ;get sign of result
  728.      shr    ebx,16    ;get high 16 of quad result
  729.      cmp    dx,bx    ;sign extension the same?
  730.      break_if    ne,'overflow in crossprod'
  731.     endif
  732.     mov    [ebp].x,eax
  733.  
  734.     mov    eax,[edi].z
  735.     imul    [esi].x
  736.     mov    ebx,eax
  737.     mov    ecx,edx
  738.     mov    eax,[edi].x
  739.     imul    [esi].z
  740.     sub    eax,ebx
  741.     sbb    edx,ecx
  742.     shrd    eax,edx,16
  743.     ifndef    NDEBUG    ;check for overflow
  744.      mov    ebx,edx    ;save
  745.      cdq        ;get sign of result
  746.      shr    ebx,16    ;get high 16 of quad result
  747.      cmp    dx,bx    ;sign extension the same?
  748.      break_if    ne,'overflow in crossprod'
  749.     endif
  750.     mov    [ebp].y,eax
  751.  
  752.     mov    eax,[edi].x
  753.     imul    [esi].y
  754.     mov    ebx,eax
  755.     mov    ecx,edx
  756.     mov    eax,[edi].y
  757.     imul    [esi].x
  758.     sub    eax,ebx
  759.     sbb    edx,ecx
  760.     shrd    eax,edx,16
  761.     ifndef    NDEBUG    ;check for overflow
  762.      mov    ebx,edx    ;save
  763.      cdq        ;get sign of result
  764.      shr    ebx,16    ;get high 16 of quad result
  765.      cmp    dx,bx    ;sign extension the same?
  766.      break_if    ne,'overflow in crossprod'
  767.     endif
  768.     mov    [ebp].z,eax
  769.  
  770.     mov    eax,ebp    ;return dest in eax
  771.  
  772.     popm    ebx,ecx,edx,ebp
  773.  
  774.     ret
  775.  
  776. abs_eax    macro
  777.     cdq
  778.     xor    eax,edx
  779.     sub    eax,edx
  780.     endm
  781.  
  782. ;computes surface normal from three points. takes ebx=dest, eax,esi,edi=vecs
  783. ;returns eax=dest. Result vector is normalized.
  784. vm_vec_normal:
  785.     call    vm_vec_perp    ;get unnormalized
  786.     push    ecx
  787.     xchg    esi,eax    ;get in esi, save esi
  788.     call    vm_vec_normalize
  789.     xchg    eax,esi
  790.     pop    ecx
  791.     ret
  792.  
  793.  
  794. ;make sure a vector is reasonably sized to go into a cross product
  795. ;trashes eax,ebx,cl,edx
  796. check_vec:    mov    eax,[esi].x
  797.     abs_eax
  798.     mov    ebx,eax
  799.     mov    eax,[esi].y
  800.     abs_eax
  801.     or    ebx,eax
  802.     mov    eax,[esi].z
  803.     abs_eax
  804.     or    ebx,eax
  805.     jz    null_vector
  806.  
  807.     xor    cl,cl    ;init shift count
  808.  
  809.     test    ebx,0fffc0000h    ;too big
  810.     jz    not_too_big
  811. check_4_down:    test    ebx,000f00000h
  812.     jz    check_2_down
  813.     add    cl,4
  814.     sar    ebx,4
  815.     jmp    check_4_down
  816. check_2_down:    test    ebx,0fffc0000h
  817.     jz    not_2_down
  818.     add    cl,2
  819.     sar    ebx,2
  820.     jmp    check_2_down
  821. not_2_down:
  822.     sar    [esi].x,cl
  823.     sar    [esi].y,cl
  824.     sar    [esi].z,cl
  825.     ret
  826.  
  827. ;maybe too small...
  828. not_too_big:    test    ebx,0ffff8000h
  829.     jnz    not_too_small
  830. check_4_up:    test    ebx,0fffff000h
  831.     jnz    check_2_up
  832.     add    cl,4
  833.     sal    ebx,4
  834.     jmp    check_4_up
  835. check_2_up:    test    ebx,0ffff8000h
  836.     jnz    not_2_up
  837.     add    cl,2
  838.     sal    ebx,2
  839.     jmp    check_2_up
  840. not_2_up:
  841.     sal    [esi].x,cl
  842.     sal    [esi].y,cl
  843.     sal    [esi].z,cl
  844.  
  845. not_too_small:    ret
  846.  
  847. null_vector:
  848. ; debug_brk commented out by mk on 05/04/94
  849. ;**    debug_brk    "null vector in check_vec"
  850.     ret
  851.  
  852.  
  853. ;computes surface normal from three points. takes ebx=dest, eax,esi,edi=vecs
  854. ;returns eax=dest. Result vector is NOT normalized, but this routine does
  855. ;make an effort that cross product does not overflow or underflow  
  856. vm_vec_perp:    pushm    esi,edi    ;save for return
  857.  
  858.     push    eax    ;save src0
  859.     
  860.     xchg    esi,edi
  861.     lea    eax,tempv1
  862.     call    vm_vec_sub    ;src2 - src1
  863.  
  864.     mov    esi,edi    ;get src1 in esi
  865.     pop    edi    ;get src0 in edi
  866.     lea    eax,tempv0
  867.     call    vm_vec_sub    ;src1 - src0
  868.  
  869.     mov    esi,eax    ;tempv0 in esi
  870.     lea    edi,tempv1    ;tempv1 in edi
  871.  
  872.     pushm    ebx,ecx,edx
  873.     call    check_vec    ;make sure reasonable value
  874.     xchg    esi,edi
  875.     call    check_vec    ;make sure reasonable value
  876.     xchg    esi,edi
  877.     popm    ebx,ecx,edx
  878.  
  879.     mov    eax,ebx    ;get dest in eax
  880.     call    vm_vec_crossprod
  881.  
  882.     popm    esi,edi    ;restore regs
  883.     ret
  884.  
  885.  
  886. ;compute a rotation matrix from three angles. takes edi=dest matrix, 
  887. ;esi=angles vector.  returns edi=dest matrix. 
  888. vm_angles_2_matrix:
  889.     pushm    eax,edx,ebx,ecx,esi
  890.  
  891. ;get sines & cosines
  892.     mov    ax,[esi].pitch
  893.     call    fix_sincos
  894.     mov    sinp,eax
  895.     mov    cosp,ebx
  896.  
  897.     mov    ax,[esi].bank
  898.     call    fix_sincos
  899.     mov    sinb,eax
  900.     mov    cosb,ebx
  901.  
  902.     mov    ax,[esi].head
  903.     call    fix_sincos
  904.     mov    sinh,eax
  905.     mov    cosh,ebx
  906.  
  907. ;alternate entry point with sines & cosines already computed.  
  908. ;Note all the registers already pushed.
  909. sincos_2_matrix:
  910.  
  911. ;now calculate the 9 elements
  912.  
  913.     mov    eax,sinb
  914.     fixmul    sinh
  915.     mov    ecx,eax    ;save sbsh
  916.     fixmul    sinp
  917.     mov    ebx,eax
  918.     mov    eax,cosb
  919.     fixmul    cosh
  920.     mov    esi,eax    ;save cbch
  921.     add    eax,ebx
  922.     mov    [edi].m1,eax    ;m1=cbch+sbspsh
  923.  
  924.     mov    eax,esi    ;get cbch
  925.     fixmul    sinp
  926.     add    eax,ecx    ;add sbsh
  927.     mov    [edi].m8,eax    ;m8=sbsh+cbchsp
  928.  
  929.  
  930.     mov    eax,cosb
  931.     fixmul    sinh
  932.     mov    ecx,eax    ;save cbsh
  933.     fixmul    sinp
  934.     mov    ebx,eax
  935.     mov    eax,sinb
  936.     fixmul    cosh
  937.     mov    esi,eax    ;save sbch
  938.     sub    ebx,eax
  939.     mov    [edi].m2,ebx    ;m2=cbshsp-sbch
  940.  
  941.     mov    eax,esi    ;get sbch
  942.     fixmul    sinp
  943.     sub    eax,ecx    ;sub from cbsh
  944.     mov    [edi].m7,eax    ;m7=sbchsp-cbsh
  945.  
  946.  
  947.     mov    eax,sinh
  948.     fixmul    cosp
  949.     mov    [edi].m3,eax    ;m3=shcp
  950.  
  951.     mov    eax,sinb
  952.     fixmul    cosp
  953.     mov    [edi].m4,eax    ;m4=sbcp
  954.  
  955.     mov    eax,cosb
  956.     fixmul    cosp
  957.     mov    [edi].m5,eax    ;m5=cbcp
  958.  
  959.     mov    eax,sinp
  960.     neg    eax
  961.     mov    [edi].m6,eax    ;m6=-sp
  962.  
  963.     mov    eax,cosh
  964.     fixmul    cosp
  965.     mov    [edi].m9,eax    ;m9=chcp
  966.  
  967.     popm    eax,edx,ebx,ecx,esi
  968.     ret
  969.  
  970. m2m    macro    dest,src
  971.     mov    eax,src
  972.     mov    dest,eax
  973.     endm
  974.  
  975. m2m_neg    macro    dest,src
  976.     mov    eax,src
  977.     neg    eax
  978.     mov    dest,eax
  979.     endm
  980.  
  981. ;create a rotation matrix from one or two vectors. 
  982. ;requires forward vec, and assumes zero bank if up & right vecs==NULL
  983. ;up/right vector need not be exactly perpendicular to forward vec
  984. ;takes edi=matrix, esi=forward vec, eax=up vec, ebx=right vec. 
  985. ;returns edi=matrix.  trashes eax,ebx,esi
  986. ;Note: this routine loses precision as the forward vector approaches 
  987. ;straigt up or down (I think)
  988. vm_vector_2_matrix:
  989.     pushm    ecx
  990.  
  991.     ifndef    NDEBUG
  992.      or    esi,esi
  993.      break_if    z,"vm_vector_2_matrix: forward vec cannot be NULL!"
  994.     endif
  995.  
  996.     or    eax,eax    ;up vector present?
  997.     jnz    use_up_vec    ;..yep
  998.  
  999.     or    ebx,ebx    ;right vector present?
  1000.     jz    just_forward_vec    ;..nope
  1001. ;use_right_vec
  1002.     push    edi    ;save matrix
  1003.     mov    edi,ebx    ;save right vec
  1004.  
  1005.     vm_copy    zvec,[esi]
  1006.     lea    esi,zvec
  1007.     call    vm_vec_normalize
  1008.     or    ecx,ecx
  1009.     jecxz    bad_vector2
  1010.  
  1011.     lea    esi,xvec
  1012.     vm_copy    [esi],[edi]
  1013.     call    vm_vec_normalize
  1014.     jecxz    bad_vector2
  1015.  
  1016.     lea    eax,yvec    ;dest = y
  1017.     mov    edi,esi    ;src1 = x
  1018.     lea    esi,zvec    ;scr0 = z
  1019.     call    vm_vec_crossprod    ;get y = z cross x
  1020.  
  1021. ;normalize new perpendicular vector
  1022.     mov    esi,eax    ;get new vec (up) in esi
  1023.     call    vm_vec_normalize
  1024.     jecxz    bad_vector2
  1025.  
  1026. ;now recompute right vector, in case it wasn't entirely perpendiclar
  1027.  
  1028.     lea    eax,xvec    ;dest = x
  1029.     lea    edi,zvec
  1030.     call    vm_vec_crossprod    ;x = y cross z
  1031.  
  1032.     pop    edi    ;get matrix back
  1033.  
  1034.     jmp    copy_into_matrix
  1035.  
  1036.  
  1037. ;one of the non-forward vectors caused a problem, so ignore them and
  1038. ;use just the forward vector
  1039. bad_vector2:    pop    edi
  1040.     lea    esi,zvec
  1041.     jmp    just_forward_vec
  1042.  
  1043. ;use forward and up vectors
  1044. use_up_vec:    push    edi    ;save matrix
  1045.     mov    edi,eax    ;save up vec
  1046.  
  1047.     vm_copy    zvec,[esi]
  1048.     lea    esi,zvec
  1049.     call    vm_vec_normalize
  1050.     jecxz    bad_vector2
  1051.  
  1052.     lea    esi,yvec
  1053.     vm_copy    [esi],[edi]
  1054.     call    vm_vec_normalize
  1055.     jecxz    bad_vector2
  1056.  
  1057.     lea    eax,xvec    ;dest = x
  1058.     lea    edi,zvec    ;scr0 = y, scr1 = z
  1059.     call    vm_vec_crossprod    ;get x vector
  1060.  
  1061. ;normalize new perpendicular vector
  1062.     xchg    esi,eax    ;get new vec in esi
  1063.     call    vm_vec_normalize
  1064.     jecxz    bad_vector2    ;bad_vector3
  1065.  
  1066. ;now recompute up vector, in case it wasn't entirely perpendiclar
  1067.  
  1068.     xchg    esi,edi    ;dest = y, src0 = z, src1 = x
  1069.     call    vm_vec_crossprod    ;get x vector
  1070.  
  1071.     pop    edi    ;get matrix back
  1072.  
  1073. copy_into_matrix:    vm_copy    [edi].rvec,xvec
  1074.     vm_copy    [edi].uvec,yvec
  1075.     vm_copy    [edi].fvec,zvec
  1076.  
  1077.     jmp    done_v2m
  1078.  
  1079. bad_vector3:    pop    edi
  1080. bad_vector:    pop    ecx
  1081.     debug_brk    '0-len vec in vec_2_mat'
  1082.     ret
  1083.  
  1084. ;only the forward vector is present
  1085. just_forward_vec:    vm_copy    zvec,[esi]
  1086.     lea    esi,zvec
  1087.     call    vm_vec_normalize
  1088.     jecxz    bad_vector
  1089.  
  1090.     vm_copy    [edi].fvec,[esi]
  1091.  
  1092.     mov    eax,[esi].x
  1093.     or    eax,[esi].z    ;check both x & z == 0
  1094.     jnz    not_up
  1095.  
  1096. ;forward vector is straight up (or down)
  1097.  
  1098.     mov    [edi].m1,f1_0
  1099.     push    edx
  1100.     mov    eax,[esi].y    ;get y componant
  1101.     cdq        ;get y sign
  1102.     mov    eax,-f1_0
  1103.     xor    eax,edx
  1104.     sub    eax,edx    ;make sign correct
  1105.     mov    [edi].m8,eax
  1106.     pop    edx
  1107.     xor    eax,eax
  1108.     mov    [edi].m4,eax
  1109.     mov    [edi].m7,eax
  1110.     mov    [edi].m2,eax
  1111.     mov    [edi].m5,eax
  1112.     jmp    done_v2m
  1113.  
  1114. not_up:
  1115.     m2m    xvec.x,[esi].z
  1116.     mov    xvec.y,0
  1117.     m2m_neg    xvec.z,[esi].x
  1118.     lea    esi,xvec
  1119.     call    vm_vec_normalize
  1120.  
  1121.     vm_copy    [edi].rvec,[esi]
  1122.  
  1123.     push    edi    ;save matrix
  1124.     mov    edi,esi    ;scr1 = x
  1125.     lea    esi,zvec    ;src0 = z
  1126.     lea    eax,yvec    ;dest = y
  1127.     call    vm_vec_crossprod
  1128.     pop    edi
  1129.  
  1130.     vm_copy    [edi].uvec,[yvec]
  1131.  
  1132. done_v2m:    pop    ecx
  1133.     ret
  1134.  
  1135.     if    V2MN_ENABLED
  1136. ;this version requires that the vectors be more-or-less normalized
  1137. vm_vector_2_matrix_norm:
  1138.     pushm    ecx
  1139.  
  1140.     ifndef    NDEBUG
  1141.      or    esi,esi
  1142.      break_if    z,"vm_vector_2_matrix_norm: forward vec cannot be NULL!"
  1143.     endif
  1144.  
  1145.     or    eax,eax    ;up vector present?
  1146.     jnz    _use_up_vec    ;..yep
  1147.  
  1148.     or    ebx,ebx    ;right vector present?
  1149.     jz    _just_forward_vec    ;..nope
  1150. ;use_right_vec
  1151.     push    edi    ;save matrix
  1152.     mov    edi,ebx    ;save right vec
  1153.  
  1154.     vm_copy    zvec,[esi]
  1155.     vm_copy    xvec,[edi]
  1156.  
  1157.     lea    eax,yvec    ;dest = y
  1158.     call    vm_vec_crossprod    ;get y = z cross x
  1159.  
  1160. ;normalize new perpendicular vector
  1161.     xchg    esi,eax    ;get new vec in esi
  1162.     call    vm_vec_normalize
  1163.     jecxz    _bad_vector2    ;bad_vector3
  1164.  
  1165. ;now recompute right vector, in case it wasn't entirely perpendiclar
  1166.  
  1167.     lea    eax,xvec    ;dest = x
  1168.     lea    edi,zvec
  1169.     call    vm_vec_crossprod    ;x = y cross z
  1170.  
  1171.     pop    edi    ;get matrix back
  1172.  
  1173.     jmp    _copy_into_matrix
  1174.  
  1175.  
  1176. ;one of the non-forward vectors caused a problem, so ignore them and
  1177. ;use just the forward vector
  1178. _bad_vector2:    pop    edi
  1179.     lea    esi,zvec
  1180.     jmp    _just_forward_vec
  1181.  
  1182. ;use forward and up vectors
  1183. _use_up_vec:    push    edi    ;save matrix
  1184.     mov    edi,eax    ;save up vec
  1185.  
  1186.     vm_copy    zvec,[esi]
  1187.     vm_copy    yvec,[edi]
  1188.  
  1189.     lea    eax,xvec    ;dest = x
  1190.     lea    esi,yvec    ;scr0 = y
  1191.     lea    edi,zvec    ;scr1 = z
  1192.     call    vm_vec_crossprod    ;get x vector
  1193.  
  1194. ;normalize new perpendicular vector
  1195.     xchg    esi,eax    ;get new vec in esi
  1196.     call    vm_vec_normalize
  1197.     jecxz    _bad_vector2    ;bad_vector3
  1198.  
  1199. ;now recompute up vector, in case it wasn't entirely perpendiclar
  1200.  
  1201.     xchg    esi,edi    ;dest = y, src0 = z, src1 = x
  1202.     call    vm_vec_crossprod    ;get x vector
  1203.  
  1204.     pop    edi    ;get matrix back
  1205.  
  1206. _copy_into_matrix:    vm_copy    [edi].rvec,xvec
  1207.     vm_copy    [edi].uvec,yvec
  1208.     vm_copy    [edi].fvec,zvec
  1209.  
  1210.     jmp    _done_v2m
  1211.  
  1212. _bad_vector3:    pop    edi
  1213. _bad_vector:    pop    ecx
  1214.     debug_brk    '0-len vec in vec_2_mat'
  1215.     ret
  1216.  
  1217. ;only the forward vector is present
  1218. _just_forward_vec:    vm_copy    zvec,[esi]
  1219.     vm_copy    [edi].fvec,[esi]
  1220.  
  1221.     mov    eax,[esi].x
  1222.     or    eax,[esi].z    ;check both x & z == 0
  1223.     jnz    _not_up
  1224.  
  1225. ;forward vector is straight up (or down)
  1226.  
  1227.     mov    [edi].m1,f1_0
  1228.     push    edx
  1229.     mov    eax,[esi].y    ;get y componant
  1230.     cdq        ;get y sign
  1231.     mov    eax,-f1_0
  1232.     xor    eax,edx
  1233.     sub    eax,edx    ;make sign correct
  1234.     mov    [edi].m8,eax
  1235.     pop    edx
  1236.     xor    eax,eax
  1237.     mov    [edi].m4,eax
  1238.     mov    [edi].m7,eax
  1239.     mov    [edi].m2,eax
  1240.     mov    [edi].m5,eax
  1241.     jmp    _done_v2m
  1242.  
  1243. _not_up:
  1244.     m2m    xvec.x,[esi].z
  1245.     mov    xvec.y,0
  1246.     m2m_neg    xvec.z,[esi].x
  1247.     lea    esi,xvec
  1248.     call    vm_vec_normalize
  1249.  
  1250.     vm_copy    [edi].rvec,[esi]
  1251.  
  1252.     push    edi    ;save matrix
  1253.     mov    edi,esi    ;scr1 = x
  1254.     lea    esi,zvec    ;src0 = z
  1255.     lea    eax,yvec    ;dest = y
  1256.     call    vm_vec_crossprod
  1257.     pop    edi
  1258.  
  1259.     vm_copy    [edi].uvec,[yvec]
  1260.  
  1261. _done_v2m:    pop    ecx
  1262.     ret
  1263.  
  1264.     endif    ;V2MN_ENABLED
  1265.  
  1266.  
  1267. ;multiply (dot) two vectors. assumes dest ptr in ebp, src pointers in esi,edi.
  1268. ;trashes ebx,ecx,edx
  1269. vv_mul    macro    dest,x0,y0,z0,x1,y1,z1
  1270.  
  1271.     mov    eax,[esi].x0
  1272.     imul    [edi].x1
  1273.     mov    ebx,eax
  1274.     mov    ecx,edx
  1275.  
  1276.     mov    eax,[esi].y0
  1277.     imul    [edi].y1
  1278.     add    ebx,eax
  1279.     adc    ecx,edx
  1280.  
  1281.     mov    eax,[esi].z0
  1282.     imul    [edi].z1
  1283.     add    ebx,eax
  1284.     adc    ecx,edx
  1285.  
  1286.     shrd    ebx,ecx,16    ;fixup ebx
  1287.     mov    [ebp].dest,ebx
  1288.  
  1289.     endm
  1290.  
  1291. ;rotate a vector by a rotation matrix
  1292. ;eax=dest vector, esi=src vector, edi=matrix. returns eax=dest vector
  1293. vm_vec_rotate:
  1294.     ifndef    NDEBUG
  1295.      cmp    eax,esi
  1296.      break_if    e,'vec_rotate: dest==src'
  1297.     endif
  1298.  
  1299.     pushm    ebx,ecx,edx,ebp
  1300.  
  1301.     mov    ebp,eax    ;dest in ebp
  1302.  
  1303. ;compute x
  1304.     vv_mul    x, x,y,z, m1,m4,m7
  1305.     vv_mul    y, x,y,z, m2,m5,m8
  1306.     vv_mul    z, x,y,z, m3,m6,m9
  1307.  
  1308.     mov    eax,ebp    ;return eax=dest
  1309.     popm    ebx,ecx,edx,ebp
  1310.  
  1311.     ret
  1312.  
  1313.  
  1314. ;transpose a matrix in place.  Takes edi=matrix. returns edi=matrix
  1315. vm_transpose_matrix:
  1316.     push    eax
  1317.  
  1318.     mov    eax,[edi].m2
  1319.     xchg    eax,[edi].m4
  1320.     mov    [edi].m2,eax
  1321.  
  1322.     mov    eax,[edi].m3
  1323.     xchg    eax,[edi].m7
  1324.     mov    [edi].m3,eax
  1325.  
  1326.     mov    eax,[edi].m6
  1327.     xchg    eax,[edi].m8
  1328.     mov    [edi].m6,eax
  1329.  
  1330.     pop    eax
  1331.  
  1332.     ret
  1333.  
  1334.  
  1335.  
  1336. ;copy and transpose a matrix.  Takes edi=dest, esi=src. returns edi=dest
  1337. vm_copy_transpose_matrix:
  1338.     push    eax
  1339.  
  1340.     mov    eax,[esi].m1
  1341.     mov    [edi].m1,eax
  1342.  
  1343.     mov    eax,[esi].m2
  1344.     mov    [edi].m4,eax
  1345.  
  1346.     mov    eax,[esi].m3
  1347.     mov    [edi].m7,eax
  1348.  
  1349.     mov    eax,[esi].m4
  1350.     mov    [edi].m2,eax
  1351.  
  1352.     mov    eax,[esi].m5
  1353.     mov    [edi].m5,eax
  1354.  
  1355.     mov    eax,[esi].m6
  1356.     mov    [edi].m8,eax
  1357.  
  1358.     mov    eax,[esi].m7
  1359.     mov    [edi].m3,eax
  1360.  
  1361.     mov    eax,[esi].m8
  1362.     mov    [edi].m6,eax
  1363.  
  1364.     mov    eax,[esi].m9
  1365.     mov    [edi].m9,eax
  1366.  
  1367.     pop    eax
  1368.  
  1369.     ret
  1370.  
  1371.  
  1372.  
  1373. ;mulitply 2 matrices, fill in dest.  returns eax=ptr to dest
  1374. ;takes eax=dest, esi=src0, edi=scr1
  1375. vm_matrix_x_matrix:
  1376.     ifndef    NDEBUG
  1377.      cmp    eax,esi
  1378.      break_if    e,'matrix_x_matrix: dest==src0'
  1379.      cmp    eax,edi
  1380.      break_if    e,'matrix_x_matrix: dest==src1'
  1381.     endif
  1382.  
  1383.     pushm    ebx,ecx,edx,ebp
  1384.  
  1385.     mov    ebp,eax    ;ebp=dest
  1386.  
  1387. ;;This code would do the same as the nine lines below it, but I'm sure
  1388. ;;Mike would disapprove
  1389. ;;    for    s0,<<m1,m2,m3>,<m4,m5,m6>,<m7,m8,m9>>
  1390. ;;     for    s1,<<m1,m4,m7>,<m2,m5,m8>,<m3,m6,m9>>
  1391. ;;      vv_mul    @ArgI(1,s0)+@ArgI(1,s1), s0, s1
  1392. ;;     endm
  1393. ;;    endm
  1394.  
  1395.     vv_mul    m1, m1,m2,m3, m1,m4,m7
  1396.     vv_mul    m2, m1,m2,m3, m2,m5,m8
  1397.     vv_mul    m3, m1,m2,m3, m3,m6,m9
  1398.  
  1399.     vv_mul    m4, m4,m5,m6, m1,m4,m7
  1400.     vv_mul    m5, m4,m5,m6, m2,m5,m8
  1401.     vv_mul    m6, m4,m5,m6, m3,m6,m9
  1402.  
  1403.     vv_mul    m7, m7,m8,m9, m1,m4,m7
  1404.     vv_mul    m8, m7,m8,m9, m2,m5,m8
  1405.     vv_mul    m9, m7,m8,m9, m3,m6,m9
  1406.  
  1407.     mov    eax,ebp    ;eax=ptr to dest
  1408.     popm    ebx,ecx,edx,ebp
  1409.  
  1410.     ret
  1411.  
  1412. ;computes the delta angle between two vectors
  1413. ;two entry points: normalized and non-normalized vectors
  1414. ;takes esi,edi=vectors, eax=optional forward vector
  1415. ;returns ax=delta angle
  1416. ;if the forward vector is NULL, the absolute values of the delta angle
  1417. ;is returned.  If it is specified, the rotation around that vector from
  1418. ;esi to edi is returned. 
  1419. vm_vec_delta_ang:    push    eax    ;save forward vec
  1420.  
  1421.     push    ecx    ;trashed by normalize
  1422.     call    vm_vec_normalize
  1423.     xchg    esi,edi
  1424.     call    vm_vec_normalize
  1425.     xchg    esi,edi    ;in case forward vec specified
  1426.     pop    ecx
  1427.     jmp    do_vda_dot
  1428.  
  1429. vm_vec_delta_ang_norm:
  1430.     push    eax    ;save forward vec
  1431. do_vda_dot:    call    vm_vec_dotprod
  1432.     call    fix_acos    ;now angle in ax
  1433.     pop    ebx    ;get forward vec
  1434.     or    ebx,ebx    ;null?
  1435.     jz    done_vda    ;..yes
  1436. ;do cross product to find sign of angle
  1437.     push    edx    ;save edx
  1438.     push    eax    ;save angle
  1439.     push    ebx    ;save forward vec
  1440.     lea    eax,tempv0    ;new vec
  1441.     call    vm_vec_crossprod    ;esi,edi still set
  1442.     mov    esi,eax    ;new vector
  1443.     pop    edi    ;forward vec
  1444.     call    vm_vec_dotprod    ;eax=dotprod
  1445.     cdq        ;get sign
  1446.     pop    eax    ;get angle
  1447.     xor    eax,edx
  1448.     sub    eax,edx    ;make sign correct
  1449.     pop    edx    ;restore edx
  1450. done_vda:    ret
  1451.  
  1452.  
  1453. ;compute a rotation matrix from the forward vector and a rotation around
  1454. ;that vector. takes esi=vector, ax=angle, edi=matrix. returns edi=dest matrix. 
  1455. ;trashes esi,eax
  1456. vm_vec_ang_2_matrix:
  1457.     pushm    eax,edx,ebx,ecx,esi
  1458.  
  1459.     call    fix_sincos
  1460.     mov    sinb,eax
  1461.     mov    cosb,ebx
  1462.  
  1463.  
  1464. ;extract heading & pitch from vector
  1465.  
  1466.     mov    eax,[esi].y    ;m6=-sp
  1467.     neg    eax
  1468.     mov    sinp,eax
  1469.     fixmul    eax
  1470.     sub    eax,f1_0
  1471.     neg    eax
  1472.     call    fix_sqrt    ;eax=cp
  1473.     mov    cosp,eax
  1474.     mov    ebx,eax
  1475.  
  1476.     mov    eax,[esi].x    ;sh
  1477.     fixdiv    ebx
  1478.     mov    sinh,eax
  1479.  
  1480.     mov    eax,[esi].z    ;ch
  1481.     fixdiv    ebx
  1482.     mov    cosh,eax
  1483.  
  1484.     jmp    sincos_2_matrix
  1485.  
  1486. ;compute the distance from a point to a plane.  takes the normalized normal
  1487. ;of the plane (ebx), a point on the plane (edi), and the point to check (esi).
  1488. ;returns distance in eax
  1489. ;distance is signed, so negative dist is on the back of the plane
  1490. vm_dist_to_plane:    pushm    esi,edi
  1491.  
  1492.     lea    eax,tempv0
  1493.     call    vm_vec_sub    ;vecs in esi,edi
  1494.  
  1495.     mov    esi,eax    ;vector plane -> point
  1496.     mov    edi,ebx    ;normal
  1497.     call    vm_vec_dotprod
  1498.  
  1499.     popm    esi,edi
  1500.     ret
  1501.  
  1502. ;extract the angles from a matrix.  takes esi=matrix, fills in edi=angvec
  1503. vm_extract_angles_matrix:
  1504.     pushm    eax,ebx,edx,ecx
  1505.  
  1506. ;extract heading & pitch from forward vector
  1507.  
  1508.     mov    eax,[esi].fvec.z    ;ch
  1509.     mov    ebx,[esi].fvec.x    ;sh
  1510.  
  1511.     mov    ecx,ebx    ;check for z==x==0
  1512.     or    ecx,eax
  1513.     jz    zero_head    ;zero, use head=0
  1514.     call    fix_atan2
  1515. zero_head:    mov    [edi].head,ax    ;save heading
  1516.     
  1517.     call    fix_sincos    ;get back sh
  1518.  
  1519.     push    eax    ;save sine
  1520.     abs_eax
  1521.     mov    ecx,eax    ;save abs(sine)
  1522.     mov    eax,ebx
  1523.     abs_eax        ;abs(cos)
  1524.     cmp    eax,ecx    ;which is larger?
  1525.     pop    eax    ;get sine back
  1526.     jg    use_cos
  1527.  
  1528. ;sine is larger, so use it
  1529.     mov    ebx,eax    ;ebx=sine heading
  1530.     mov    eax,[esi].m3    ;cp = shcp / sh
  1531.     jmp    get_cosp
  1532.  
  1533. ;cosine is larger, so use it
  1534. use_cos:
  1535.  
  1536.     mov    eax,[esi].fvec.z    ;get chcp
  1537. get_cosp:    fixdiv    ebx    ;cp = chcp / ch
  1538.  
  1539.  
  1540.     push    eax    ;save cp
  1541.  
  1542.     ;eax = x (cos p)
  1543.     mov    ebx,[esi].fvec.y    ;fvec.y = -sp
  1544.     neg    ebx    ;ebx = y (sin)
  1545.     mov    ecx,ebx    ;check for z==x==0
  1546.     or    ecx,eax
  1547.     jz    zero_pitch    ;bogus vec, set p=0
  1548.     call    fix_atan2
  1549. zero_pitch:    mov    [edi].pitch,ax
  1550.  
  1551.     pop    ecx    ;get cp
  1552.     jecxz    cp_zero
  1553.  
  1554.     mov    eax,[esi].m4    ;m4 = sbcp
  1555.     fixdiv    ecx    ;get sb
  1556.     mov    ebx,eax    ;save sb
  1557.  
  1558.     mov    eax,[esi].m5    ;get cbcp
  1559.     fixdiv    ecx    ;get cb
  1560.     mov    ecx,ebx    ;check for z==x==0
  1561.     or    ecx,eax
  1562.     jz    zero_bank    ;bogus vec, set n=0
  1563.     call    fix_atan2
  1564. zero_bank:    mov    [edi].bank,ax
  1565.  
  1566. m_extract_done:
  1567.     popm    eax,ebx,edx,ecx
  1568.  
  1569.     ret
  1570.  
  1571. ;the cosine of pitch is zero.  we're pitched straight up. say no bank
  1572. cp_zero:    mov    [edi].bank,0    ;no bank
  1573.  
  1574.     popm    eax,ebx,edx,ecx
  1575.     ret
  1576.  
  1577.  
  1578. ;extract the angles from a vector, assuming zero bank. 
  1579. ;takes esi=vec, edi=angvec
  1580. ;note versions for normalized and not normalized vector
  1581. ;unnormalized version TRASHES ESI
  1582. vm_extract_angles_vector:
  1583.     push    edi
  1584.     lea    edi,tempv0
  1585.     call    vm_vec_copy_normalize    ;ecx=mag
  1586.     mov    esi,edi
  1587.     pop    edi
  1588.     jecxz    extract_done
  1589.  
  1590. vm_extract_angles_vector_normalized:
  1591.     pushm    eax,ebx
  1592.  
  1593.     mov    [edi].bank,0    ;always zero bank
  1594.  
  1595.     mov    eax,[esi].y
  1596.     neg    eax
  1597.     call    fix_asin
  1598.     mov    [edi].pitch,ax    ;p = asin(-y)
  1599.  
  1600.     mov    eax,[esi].z
  1601.     mov    ebx,[esi].x
  1602.     or    ebx,eax
  1603.     jz    zero_head2    ;check for up vector
  1604.  
  1605.     mov    ebx,[esi].x    ;get x again
  1606.     call    fix_atan2
  1607. zero_head2:    mov    [edi].head,ax    ;h = atan2(x,z) (or zero)
  1608.  
  1609.  
  1610.     popm    eax,ebx
  1611. extract_done:    ret
  1612.  
  1613.  
  1614. _TEXT    ends
  1615.     end
  1616.