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