MathgeomGLS

1
{ Angle and Trigonometry Functions }
2

3
function Radians(const ADegrees: Single): Single;
4
begin
5
  Result := _radians_scalar(ADegrees);
6
end;
7

8
function Radians(const ADegrees: TVector2): TVector2;
9
begin
10
  _radians_vector2(@ADegrees, @Result);
11
end;
12

13
function Radians(const ADegrees: TVector3): TVector3;
14
begin
15
  _radians_vector3(@ADegrees, @Result);
16
end;
17

18
function Radians(const ADegrees: TVector4): TVector4;
19
begin
20
  _radians_vector4(@ADegrees, @Result);
21
end;
22

23
function Degrees(const ARadians: Single): Single;
24
begin
25
  Result := _degrees_scalar(ARadians);
26
end;
27

28
function Degrees(const ARadians: TVector2): TVector2;
29
begin
30
  _degrees_vector2(@ARadians, @Result);
31
end;
32

33
function Degrees(const ARadians: TVector3): TVector3;
34
begin
35
  _degrees_vector3(@ARadians, @Result);
36
end;
37

38
function Degrees(const ARadians: TVector4): TVector4;
39
begin
40
  _degrees_vector4(@ARadians, @Result);
41
end;
42

43
{ Exponential Functions }
44

45
function Sqrt(const A: Single): Single;
46
begin
47
  Result := _sqrt_scalar(A);
48
end;
49

50
function Sqrt(const A: TVector2): TVector2;
51
begin
52
  _sqrt_vector2(@A, @Result);
53
end;
54

55
function Sqrt(const A: TVector3): TVector3;
56
begin
57
  _sqrt_vector3(@A, @Result);
58
end;
59

60
function Sqrt(const A: TVector4): TVector4;
61
begin
62
  _sqrt_vector4(@A, @Result);
63
end;
64

65
function InverseSqrt(const A: Single): Single;
66
begin
67
  Result := _inverse_sqrt_scalar(A);
68
end;
69

70
function InverseSqrt(const A: TVector2): TVector2;
71
begin
72
  _inverse_sqrt_vector2(@A, @Result);
73
end;
74

75
function InverseSqrt(const A: TVector3): TVector3;
76
begin
77
  _inverse_sqrt_vector3(@A, @Result);
78
end;
79

80
function InverseSqrt(const A: TVector4): TVector4;
81
begin
82
  _inverse_sqrt_vector4(@A, @Result);
83
end;
84

85
{ Fast approximate Functions }
86

87
function FastSin(const ARadians: Single): Single;
88
var
89
  C: Single;
90
begin
91
  _fast_sincos_scalar(ARadians, @Result, @C);
92
end;
93

94
function FastSin(const ARadians: TVector2): TVector2;
95
var
96
  C: TVector2;
97
begin
98
  _fast_sincos_vector2(@ARadians, @Result, @C);
99
end;
100

101
function FastSin(const ARadians: TVector3): TVector3;
102
var
103
  C: TVector3;
104
begin
105
  _fast_sincos_vector3(@ARadians, @Result, @C);
106
end;
107

108
function FastSin(const ARadians: TVector4): TVector4;
109
var
110
  C: TVector4;
111
begin
112
  _fast_sincos_vector4(@ARadians, @Result, @C);
113
end;
114

115
function FastCos(const ARadians: Single): Single;
116
var
117
  S: Single;
118
begin
119
  _fast_sincos_scalar(ARadians, @S, @Result);
120
end;
121

122
function FastCos(const ARadians: TVector2): TVector2;
123
var
124
  S: TVector2;
125
begin
126
  _fast_sincos_vector2(@ARadians, @S, @Result);
127
end;
128

129
function FastCos(const ARadians: TVector3): TVector3;
130
var
131
  S: TVector3;
132
begin
133
  _fast_sincos_vector3(@ARadians, @S, @Result);
134
end;
135

136
function FastCos(const ARadians: TVector4): TVector4;
137
var
138
  S: TVector4;
139
begin
140
  _fast_sincos_vector4(@ARadians, @S, @Result);
141
end;
142

143
procedure FastSinCos(const ARadians: Single; out ASin, ACos: Single);
144
begin
145
  _fast_sincos_scalar(ARadians, @ASin, @ACos);
146
end;
147

148
procedure FastSinCos(const ARadians: TVector2; out ASin, ACos: TVector2);
149
begin
150
  _fast_sincos_vector2(@ARadians, @ASin, @ACos);
151
end;
152

153
procedure FastSinCos(const ARadians: TVector3; out ASin, ACos: TVector3);
154
begin
155
  _fast_sincos_vector3(@ARadians, @ASin, @ACos);
156
end;
157

158
procedure FastSinCos(const ARadians: TVector4; out ASin, ACos: TVector4);
159
begin
160
  _fast_sincos_vector4(@ARadians, @ASin, @ACos);
161
end;
162

163
function FastExp(const A: Single): Single;
164
begin
165
  Result := _fast_exp_scalar(A);
166
end;
167

168
function FastExp(const A: TVector2): TVector2;
169
begin
170
  _fast_exp_vector2(@A, @Result);
171
end;
172

173
function FastExp(const A: TVector3): TVector3;
174
begin
175
  _fast_exp_vector3(@A, @Result);
176
end;
177

178
function FastExp(const A: TVector4): TVector4;
179
begin
180
  _fast_exp_vector4(@A, @Result);
181
end;
182

183
function FastLn(const A: Single): Single;
184
begin
185
  Result := _fast_ln_scalar(A);
186
end;
187

188
function FastLn(const A: TVector2): TVector2;
189
begin
190
  _fast_ln_vector2(@A, @Result);
191
end;
192

193
function FastLn(const A: TVector3): TVector3;
194
begin
195
  _fast_ln_vector3(@A, @Result);
196
end;
197

198
function FastLn(const A: TVector4): TVector4;
199
begin
200
  _fast_ln_vector4(@A, @Result);
201
end;
202

203
function FastLog2(const A: Single): Single;
204
begin
205
  Result := _fast_log2_scalar(A);
206
end;
207

208
function FastLog2(const A: TVector2): TVector2;
209
begin
210
  _fast_log2_vector2(@A, @Result);
211
end;
212

213
function FastLog2(const A: TVector3): TVector3;
214
begin
215
  _fast_log2_vector3(@A, @Result);
216
end;
217

218
function FastLog2(const A: TVector4): TVector4;
219
begin
220
  _fast_log2_vector4(@A, @Result);
221
end;
222

223
function FastExp2(const A: Single): Single;
224
begin
225
  Result := _fast_exp2_scalar(A);
226
end;
227

228
function FastExp2(const A: TVector2): TVector2;
229
begin
230
  _fast_exp2_vector2(@A, @Result);
231
end;
232

233
function FastExp2(const A: TVector3): TVector3;
234
begin
235
  _fast_exp2_vector3(@A, @Result);
236
end;
237

238
function FastExp2(const A: TVector4): TVector4;
239
begin
240
  _fast_exp2_vector4(@A, @Result);
241
end;
242

243
{ Common Functions }
244

245
function Abs(const A: Single): Single;
246
begin
247
  Result := _abs_scalar(A);
248
end;
249

250
function Abs(const A: TVector2): TVector2;
251
begin
252
  _abs_vector2(@A, @Result);
253
end;
254

255
function Abs(const A: TVector3): TVector3;
256
begin
257
  _abs_vector3(@A, @Result);
258
end;
259

260
function Abs(const A: TVector4): TVector4;
261
begin
262
  _abs_vector4(@A, @Result);
263
end;
264

265
function Sign(const A: Single): Single;
266
begin
267
  Result := _sign_scalar(A);
268
end;
269

270
function Sign(const A: TVector2): TVector2;
271
begin
272
  _sign_vector2(@A, @Result);
273
end;
274

275
function Sign(const A: TVector3): TVector3;
276
begin
277
  _sign_vector3(@A, @Result);
278
end;
279

280
function Sign(const A: TVector4): TVector4;
281
begin
282
  _sign_vector4(@A, @Result);
283
end;
284

285
function Floor(const A: Single): Integer;
286
begin
287
  Result := _floor_scalar(A);
288
end;
289

290
function Floor(const A: TVector2): TIVector2;
291
begin
292
  _floor_vector2(@A, @Result);
293
end;
294

295
function Floor(const A: TVector3): TIVector3;
296
begin
297
  _floor_vector3(@A, @Result);
298
end;
299

300
function Floor(const A: TVector4): TIVector4;
301
begin
302
  _floor_vector4(@A, @Result);
303
end;
304

305
function Trunc(const A: Single): Integer;
306
begin
307
  Result := _trunc_scalar(A);
308
end;
309

310
function Trunc(const A: TVector2): TIVector2;
311
begin
312
  _trunc_vector2(@A, @Result);
313
end;
314

315
function Trunc(const A: TVector3): TIVector3;
316
begin
317
  _trunc_vector3(@A, @Result);
318
end;
319

320
function Trunc(const A: TVector4): TIVector4;
321
begin
322
  _trunc_vector4(@A, @Result);
323
end;
324

325
function Round(const A: Single): Integer;
326
begin
327
  Result := _round_scalar(A);
328
end;
329

330
function Round(const A: TVector2): TIVector2;
331
begin
332
  _round_vector2(@A, @Result);
333
end;
334

335
function Round(const A: TVector3): TIVector3;
336
begin
337
  _round_vector3(@A, @Result);
338
end;
339

340
function Round(const A: TVector4): TIVector4;
341
begin
342
  _round_vector4(@A, @Result);
343
end;
344

345
function Ceil(const A: Single): Integer;
346
begin
347
  Result := _ceil_scalar(A);
348
end;
349

350
function Ceil(const A: TVector2): TIVector2;
351
begin
352
  _ceil_vector2(@A, @Result);
353
end;
354

355
function Ceil(const A: TVector3): TIVector3;
356
begin
357
  _ceil_vector3(@A, @Result);
358
end;
359

360
function Ceil(const A: TVector4): TIVector4;
361
begin
362
  _ceil_vector4(@A, @Result);
363
end;
364

365
function Frac(const A: Single): Single;
366
begin
367
  Result := _frac_scalar(A);
368
end;
369

370
function Frac(const A: TVector2): TVector2;
371
begin
372
  _frac_vector2(@A, @Result);
373
end;
374

375
function Frac(const A: TVector3): TVector3;
376
begin
377
  _frac_vector3(@A, @Result);
378
end;
379

380
function Frac(const A: TVector4): TVector4;
381
begin
382
  _frac_vector4(@A, @Result);
383
end;
384

385
function FMod(const A, B: Single): Single;
386
begin
387
  Result := _fmod_scalar(A, B);
388
end;
389

390
function FMod(const A: TVector2; const B: Single): TVector2;
391
begin
392
  _fmod_vector2_scalar(@A, B, @Result);
393
end;
394

395
function FMod(const A, B: TVector2): TVector2;
396
begin
397
  _fmod_vector2(@A, @B, @Result);
398
end;
399

400
function FMod(const A: TVector3; const B: Single): TVector3;
401
begin
402
  _fmod_vector3_scalar(@A, B, @Result);
403
end;
404

405
function FMod(const A, B: TVector3): TVector3;
406
begin
407
  _fmod_vector3(@A, @B, @Result);
408
end;
409

410
function FMod(const A: TVector4; const B: Single): TVector4;
411
begin
412
  _fmod_vector4_scalar(@A, B, @Result);
413
end;
414

415
function FMod(const A, B: TVector4): TVector4;
416
begin
417
  _fmod_vector4(@A, @B, @Result);
418
end;
419

420
function ModF(const A: Single; out B: Integer): Single;
421
begin
422
  Result := _modf_scalar(A, @B);
423
end;
424

425
function ModF(const A: TVector2; out B: TIVector2): TVector2;
426
begin
427
  _modf_vector2(@A, @B, @Result);
428
end;
429

430
function ModF(const A: TVector3; out B: TIVector3): TVector3;
431
begin
432
  _modf_vector3(@A, @B, @Result);
433
end;
434

435
function ModF(const A: TVector4; out B: TIVector4): TVector4;
436
begin
437
  _modf_vector4(@A, @B, @Result);
438
end;
439

440
function Min(const A: TVector2; const B: Single): TVector2;
441
begin
442
  _min_vector2_scalar(@A, B, @Result);
443
end;
444

445
function Min(const A, B: TVector2): TVector2;
446
begin
447
  _min_vector2(@A, @B, @Result);
448
end;
449

450
function Min(const A: TVector3; const B: Single): TVector3;
451
begin
452
  _min_vector3_scalar(@A, B, @Result);
453
end;
454

455
function Min(const A, B: TVector3): TVector3;
456
begin
457
  _min_vector3(@A, @B, @Result);
458
end;
459

460
function Min(const A: TVector4; const B: Single): TVector4;
461
begin
462
  _min_vector4_scalar(@A, B, @Result);
463
end;
464

465
function Min(const A, B: TVector4): TVector4;
466
begin
467
  _min_vector4(@A, @B, @Result);
468
end;
469

470
function Max(const A: TVector2; const B: Single): TVector2;
471
begin
472
  _max_vector2_scalar(@A, B, @Result);
473
end;
474

475
function Max(const A, B: TVector2): TVector2;
476
begin
477
  _max_vector2(@A, @B, @Result);
478
end;
479

480
function Max(const A: TVector3; const B: Single): TVector3;
481
begin
482
  _max_vector3_scalar(@A, B, @Result);
483
end;
484

485
function Max(const A, B: TVector3): TVector3;
486
begin
487
  _max_vector3(@A, @B, @Result);
488
end;
489

490
function Max(const A: TVector4; const B: Single): TVector4;
491
begin
492
  _max_vector4_scalar(@A, B, @Result);
493
end;
494

495
function Max(const A, B: TVector4): TVector4;
496
begin
497
  _max_vector4(@A, @B, @Result);
498
end;
499

500
function EnsureRange(const A, AMin, AMax: Single): Single;
501
begin
502
  Result := _ensure_range_scalar(A, AMin, AMax);
503
end;
504

505
function EnsureRange(const A: TVector2; const AMin, AMax: Single): TVector2;
506
begin
507
  _ensure_range_vector2_scalar(@A, AMin, AMax, @Result);
508
end;
509

510
function EnsureRange(const A, AMin, AMax: TVector2): TVector2;
511
begin
512
  _ensure_range_vector2(@A, @AMin, @AMax, @Result);
513
end;
514

515
function EnsureRange(const A: TVector3; const AMin, AMax: Single): TVector3;
516
begin
517
  _ensure_range_vector3_scalar(@A, AMin, AMax, @Result);
518
end;
519

520
function EnsureRange(const A, AMin, AMax: TVector3): TVector3;
521
begin
522
  _ensure_range_vector3(@A, @AMin, @AMax, @Result);
523
end;
524

525
function EnsureRange(const A: TVector4; const AMin, AMax: Single): TVector4;
526
begin
527
  _ensure_range_vector4_scalar(@A, AMin, AMax, @Result);
528
end;
529

530
function EnsureRange(const A, AMin, AMax: TVector4): TVector4;
531
begin
532
  _ensure_range_vector4(@A, @AMin, @AMax, @Result);
533
end;
534

535
function Mix(const A, B: TVector2; const T: Single): TVector2;
536
begin
537
  _mix_vector2_scalar(@A, @B, T, @Result);
538
end;
539

540
function Mix(const A, B, T: TVector2): TVector2;
541
begin
542
  _mix_vector2(@A, @B, @T, @Result);
543
end;
544

545
function Mix(const A, B: TVector3; const T: Single): TVector3;
546
begin
547
  _mix_vector3_scalar(@A, @B, T, @Result);
548
end;
549

550
function Mix(const A, B, T: TVector3): TVector3;
551
begin
552
  _mix_vector3(@A, @B, @T, @Result);
553
end;
554

555
function Mix(const A, B: TVector4; const T: Single): TVector4;
556
begin
557
  _mix_vector4_scalar(@A, @B, T, @Result);
558
end;
559

560
function Mix(const A, B, T: TVector4): TVector4;
561
begin
562
  _mix_vector4(@A, @B, @T, @Result);
563
end;
564

565
function Step(const AEdge: Single; const A: TVector2): TVector2;
566
begin
567
  _step_scalar_vector2(AEdge, @A, @Result);
568
end;
569

570
function Step(const AEdge, A: TVector2): TVector2;
571
begin
572
  _step_vector2(@AEdge, @A, @Result);
573
end;
574

575
function Step(const AEdge: Single; const A: TVector3): TVector3;
576
begin
577
  _step_scalar_vector3(AEdge, @A, @Result);
578
end;
579

580
function Step(const AEdge, A: TVector3): TVector3;
581
begin
582
  _step_vector3(@AEdge, @A, @Result);
583
end;
584

585
function Step(const AEdge: Single; const A: TVector4): TVector4;
586
begin
587
  _step_scalar_vector4(AEdge, @A, @Result);
588
end;
589

590
function Step(const AEdge, A: TVector4): TVector4;
591
begin
592
  _step_vector4(@AEdge, @A, @Result);
593
end;
594

595
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector2): TVector2;
596
begin
597
  Result.Init(SmoothStep(AEdge0, AEdge1, A.X), SmoothStep(AEdge0, AEdge1, A.Y));
598
end;
599

600
function SmoothStep(const AEdge0, AEdge1, A: TVector2): TVector2;
601
begin
602
  Result.Init(SmoothStep(AEdge0.X, AEdge1.X, A.X), SmoothStep(AEdge0.Y, AEdge1.Y, A.Y));
603
end;
604

605
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector3): TVector3;
606
begin
607
  Result.Init(SmoothStep(AEdge0, AEdge1, A.X), SmoothStep(AEdge0, AEdge1, A.Y), SmoothStep(AEdge0, AEdge1, A.Z));
608
end;
609

610
function SmoothStep(const AEdge0, AEdge1, A: TVector3): TVector3;
611
begin
612
  Result.Init(SmoothStep(AEdge0.X, AEdge1.X, A.X), SmoothStep(AEdge0.Y, AEdge1.Y, A.Y), SmoothStep(AEdge0.Z, AEdge1.Z, A.Z));
613
end;
614

615
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector4): TVector4;
616
begin
617
  Result.Init(SmoothStep(AEdge0, AEdge1, A.X), SmoothStep(AEdge0, AEdge1, A.Y), SmoothStep(AEdge0, AEdge1, A.Z), SmoothStep(AEdge0, AEdge1, A.W));
618
end;
619

620
{function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector2): TVector2;
621
begin
622
  _smoothstep_scalar_vector2(AEdge0, AEdge1, @A, @Result);
623
end;
624

625
function SmoothStep(const AEdge0, AEdge1, A: TVector2): TVector2;
626
begin
627
  _smoothstep_vector2(@AEdge0, @AEdge1, @A, @Result);
628
end;
629

630
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector3): TVector3;
631
begin
632
  _smoothstep_scalar_vector3(AEdge0, AEdge1, @A, @Result);
633
end;
634

635
function SmoothStep(const AEdge0, AEdge1, A: TVector3): TVector3;
636
begin
637
  _smoothstep_vector3(@AEdge0, @AEdge1, @A, @Result);
638
end;
639

640
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector4): TVector4;
641
begin
642
  _smoothstep_scalar_vector4(AEdge0, AEdge1, @A, @Result);
643
end;}
644

645
function SmoothStep(const AEdge0, AEdge1, A: TVector4): TVector4;
646
begin
647
  _smoothstep_vector4(@AEdge0, @AEdge1, @A, @Result);
648
end;
649

650
function FMA(const A, B, C: TVector2): TVector2;
651
begin
652
  _fma_vector2(@A, @B, @C, @Result);
653
end;
654

655
function FMA(const A, B, C: TVector3): TVector3;
656
begin
657
  _fma_vector3(@A, @B, @C, @Result);
658
end;
659

660
function FMA(const A, B, C: TVector4): TVector4;
661
begin
662
  _fma_vector4(@A, @B, @C, @Result);
663
end;
664

665
{ Matrix functions }
666

667
function OuterProduct(const C, R: TVector2): TMatrix2;
668
begin
669
  {$IFDEF FM_COLUMN_MAJOR}
670
  _outer_product_matrix2(@R, @C, @Result);
671
  {$ELSE}
672
  _outer_product_matrix2(@C, @R, @Result);
673
  {$ENDIF}
674
end;
675

676
function OuterProduct(const C, R: TVector3): TMatrix3;
677
begin
678
  {$IFDEF FM_COLUMN_MAJOR}
679
  _outer_product_matrix3(@R, @C, @Result);
680
  {$ELSE}
681
  _outer_product_matrix3(@C, @R, @Result);
682
  {$ENDIF}
683
end;
684

685
function OuterProduct(const C, R: TVector4): TMatrix4;
686
begin
687
  {$IFDEF FM_COLUMN_MAJOR}
688
  _outer_product_matrix4(@R, @C, @Result);
689
  {$ELSE}
690
  _outer_product_matrix4(@C, @R, @Result);
691
  {$ENDIF}
692
end;
693

694
{ TVector2 }
695

696
class operator TVector2.Add(const A: TVector2; const B: Single): TVector2;
697
begin
698
  _vector2_add_scalar(@A, B, @Result);
699
end;
700

701
class operator TVector2.Add(const A: Single; const B: TVector2): TVector2;
702
begin
703
  _scalar_add_vector2(A, @B, @Result);
704
end;
705

706
class operator TVector2.Add(const A, B: TVector2): TVector2;
707
begin
708
  _vector2_add_vector2(@A, @B, @Result);
709
end;
710

711
function TVector2.Distance(const AOther: TVector2): Single;
712
begin
713
  Result := _vector2_distance(@Self, @AOther);
714
end;
715

716
function TVector2.DistanceSquared(const AOther: TVector2): Single;
717
begin
718
  Result := _vector2_distance_squared(@Self, @AOther);
719
end;
720

721
class operator TVector2.Divide(const A: TVector2; const B: Single): TVector2;
722
begin
723
  _vector2_div_scalar(@A, B, @Result);
724
end;
725

726
class operator TVector2.Divide(const A: Single; const B: TVector2): TVector2;
727
begin
728
  _scalar_div_vector2(A, @B, @Result);
729
end;
730

731
class operator TVector2.Divide(const A, B: TVector2): TVector2;
732
begin
733
  _vector2_div_vector2(@A, @B, @Result);
734
end;
735

736
function TVector2.Dot(const AOther: TVector2): Single;
737
begin
738
  Result := _vector2_dot(@Self, @AOther);
739
end;
740

741
function TVector2.FaceForward(const I, NRef: TVector2): TVector2;
742
begin
743
  _vector2_faceforward(@Self, @I, @NRef, @Result);
744
end;
745

746
function TVector2.GetLength: Single;
747
begin
748
  Result := _vector2_length(@Self);
749
end;
750

751
function TVector2.GetLengthSquared: Single;
752
begin
753
  Result := _vector2_dot(@Self, @Self);
754
end;
755

756
class operator TVector2.Multiply(const A: TVector2; const B: Single): TVector2;
757
begin
758
  _vector2_mul_scalar(@A, B, @Result);
759
end;
760

761
class operator TVector2.Multiply(const A: Single; const B: TVector2): TVector2;
762
begin
763
  _scalar_mul_vector2(A, @B, @Result);
764
end;
765

766
class operator TVector2.Multiply(const A, B: TVector2): TVector2;
767
begin
768
  _vector2_mul_vector2(@A, @B, @Result);
769
end;
770

771
function TVector2.NormalizeFast: TVector2;
772
begin
773
  _vector2_normalize_fast(@Self, @Result);
774
end;
775

776
function TVector2.Reflect(const N: TVector2): TVector2;
777
begin
778
  _vector2_reflect(@Self, @N, @Result);
779
end;
780

781
function TVector2.Refract(const N: TVector2; const Eta: Single): TVector2;
782
begin
783
  _vector2_refract(@Self, @N, Eta, @Result);
784
end;
785

786
procedure TVector2.SetNormalizedFast;
787
begin
788
  _vector2_normalize_fast(@Self, @Self);
789
end;
790

791
class operator TVector2.Subtract(const A: TVector2; const B: Single): TVector2;
792
begin
793
  _vector2_sub_scalar(@A, B, @Result);
794
end;
795

796
class operator TVector2.Subtract(const A: Single; const B: TVector2): TVector2;
797
begin
798
  _scalar_sub_vector2(A, @B, @Result);
799
end;
800

801
class operator TVector2.Subtract(const A, B: TVector2): TVector2;
802
begin
803
  _vector2_sub_vector2(@A, @B, @Result);
804
end;
805

806
{ TVector3 }
807

808
class operator TVector3.Add(const A: TVector3; const B: Single): TVector3;
809
begin
810
  _vector3_add_scalar(@A, B, @Result);
811
end;
812

813
class operator TVector3.Add(const A: Single; const B: TVector3): TVector3;
814
begin
815
  _scalar_add_vector3(A, @B, @Result);
816
end;
817

818
class operator TVector3.Add(const A, B: TVector3): TVector3;
819
begin
820
  _vector3_add_vector3(@A, @B, @Result);
821
end;
822

823
function TVector3.Distance(const AOther: TVector3): Single;
824
begin
825
  Result := _vector3_distance(@Self, @AOther);
826
end;
827

828
function TVector3.DistanceSquared(const AOther: TVector3): Single;
829
begin
830
  Result := _vector3_distance_squared(@Self, @AOther);
831
end;
832

833
function TVector3.Cross(const AOther: TVector3): TVector3;
834
begin
835
  _vector3_cross(@Self, @AOther, @Result);
836
end;
837

838
class operator TVector3.Divide(const A: TVector3; const B: Single): TVector3;
839
begin
840
  _vector3_div_scalar(@A, B, @Result);
841
end;
842

843
class operator TVector3.Divide(const A: Single; const B: TVector3): TVector3;
844
begin
845
  _scalar_div_vector3(A, @B, @Result);
846
end;
847

848
class operator TVector3.Divide(const A, B: TVector3): TVector3;
849
begin
850
  _vector3_div_vector3(@A, @B, @Result);
851
end;
852

853
function TVector3.Dot(const AOther: TVector3): Single;
854
begin
855
  Result := _vector3_dot(@Self, @AOther);
856
end;
857

858
function TVector3.FaceForward(const I, NRef: TVector3): TVector3;
859
begin
860
  _vector3_faceforward(@Self, @I, @NRef, @Result);
861
end;
862

863
function TVector3.GetLength: Single;
864
begin
865
  Result := _vector3_length(@Self);
866
end;
867

868
function TVector3.GetLengthSquared: Single;
869
begin
870
  Result := _vector3_dot(@Self, @Self);
871
end;
872

873
class operator TVector3.Multiply(const A: TVector3; const B: Single): TVector3;
874
begin
875
  _vector3_mul_scalar(@A, B, @Result);
876
end;
877

878
class operator TVector3.Multiply(const A: Single; const B: TVector3): TVector3;
879
begin
880
  _scalar_mul_vector3(A, @B, @Result);
881
end;
882

883
class operator TVector3.Multiply(const A, B: TVector3): TVector3;
884
begin
885
  _vector3_mul_vector3(@A, @B, @Result);
886
end;
887

888
class operator TVector3.Negative(const A: TVector3): TVector3;
889
begin
890
  _neg_vector3(@A, @Result);
891
end;
892

893
function TVector3.NormalizeFast: TVector3;
894
begin
895
  _vector3_normalize_fast(@Self, @Result);
896
end;
897

898
function TVector3.Reflect(const N: TVector3): TVector3;
899
begin
900
  _vector3_reflect(@Self, @N, @Result);
901
end;
902

903
function TVector3.Refract(const N: TVector3; const Eta: Single): TVector3;
904
begin
905
  _vector3_refract(@Self, @N, Eta, @Result);
906
end;
907

908
procedure TVector3.SetNormalizedFast;
909
begin
910
  _vector3_normalize_fast(@Self, @Self);
911
end;
912

913
class operator TVector3.Subtract(const A: TVector3; const B: Single): TVector3;
914
begin
915
  _vector3_sub_scalar(@A, B, @Result);
916
end;
917

918
class operator TVector3.Subtract(const A: Single; const B: TVector3): TVector3;
919
begin
920
  _scalar_sub_vector3(A, @B, @Result);
921
end;
922

923
class operator TVector3.Subtract(const A, B: TVector3): TVector3;
924
begin
925
  _vector3_sub_vector3(@A, @B, @Result);
926
end;
927

928
{ TVector4 }
929

930
class operator TVector4.Add(const A: TVector4; const B: Single): TVector4;
931
begin
932
  _vector4_add_scalar(@A, B, @Result);
933
end;
934

935
class operator TVector4.Add(const A: Single; const B: TVector4): TVector4;
936
begin
937
  _scalar_add_vector4(A, @B, @Result);
938
end;
939

940
class operator TVector4.Add(const A, B: TVector4): TVector4;
941
begin
942
  _vector4_add_vector4(@A, @B, @Result);
943
end;
944

945
function TVector4.Distance(const AOther: TVector4): Single;
946
begin
947
  Result := _vector4_distance(@Self, @AOther);
948
end;
949

950
function TVector4.DistanceSquared(const AOther: TVector4): Single;
951
begin
952
  Result := _vector4_distance_squared(@Self, @AOther);
953
end;
954

955
class operator TVector4.Divide(const A: TVector4; const B: Single): TVector4;
956
begin
957
  _vector4_div_scalar(@A, B, @Result);
958
end;
959

960
class operator TVector4.Divide(const A: Single; const B: TVector4): TVector4;
961
begin
962
  _scalar_div_vector4(A, @B, @Result);
963
end;
964

965
class operator TVector4.Divide(const A, B: TVector4): TVector4;
966
begin
967
  _vector4_div_vector4(@A, @B, @Result);
968
end;
969

970
function TVector4.Dot(const AOther: TVector4): Single;
971
begin
972
  Result := _vector4_dot(@Self, @AOther);
973
end;
974

975
function TVector4.FaceForward(const I, NRef: TVector4): TVector4;
976
begin
977
  _vector4_faceforward(@Self, @I, @NRef, @Result);
978
end;
979

980
function TVector4.GetLength: Single;
981
begin
982
  Result := _vector4_length(@Self);
983
end;
984

985
function TVector4.GetLengthSquared: Single;
986
begin
987
  Result := _vector4_dot(@Self, @Self);
988
end;
989

990
class operator TVector4.Multiply(const A: TVector4; const B: Single): TVector4;
991
begin
992
  _vector4_mul_scalar(@A, B, @Result);
993
end;
994

995
class operator TVector4.Multiply(const A: Single; const B: TVector4): TVector4;
996
begin
997
  _scalar_mul_vector4(A, @B, @Result);
998
end;
999

1000
class operator TVector4.Multiply(const A, B: TVector4): TVector4;
1001
begin
1002
  _vector4_mul_vector4(@A, @B, @Result);
1003
end;
1004

1005
class operator TVector4.Negative(const A: TVector4): TVector4;
1006
begin
1007
  _neg_vector4(@A, @Result);
1008
end;
1009

1010
function TVector4.NormalizeFast: TVector4;
1011
begin
1012
  _vector4_normalize_fast(@Self, @Result);
1013
end;
1014

1015
function TVector4.Reflect(const N: TVector4): TVector4;
1016
begin
1017
  _vector4_reflect(@Self, @N, @Result);
1018
end;
1019

1020
function TVector4.Refract(const N: TVector4; const Eta: Single): TVector4;
1021
begin
1022
  _vector4_refract(@Self, @N, Eta, @Result);
1023
end;
1024

1025
procedure TVector4.SetNormalizedFast;
1026
begin
1027
  _vector4_normalize_fast(@Self, @Self);
1028
end;
1029

1030
class operator TVector4.Subtract(const A: TVector4; const B: Single): TVector4;
1031
begin
1032
  _vector4_sub_scalar(@A, B, @Result);
1033
end;
1034

1035
class operator TVector4.Subtract(const A: Single; const B: TVector4): TVector4;
1036
begin
1037
  _scalar_sub_vector4(A, @B, @Result);
1038
end;
1039

1040
class operator TVector4.Subtract(const A, B: TVector4): TVector4;
1041
begin
1042
  _vector4_sub_vector4(@A, @B, @Result);
1043
end;
1044

1045
{ TQuaternion }
1046

1047
{ Most implementations here are the same as for TVector4 }
1048

1049
class operator TQuaternion.Add(const A, B: TQuaternion): TQuaternion;
1050
begin
1051
  _vector4_add_vector4(@A, @B, @Result);
1052
end;
1053

1054
function TQuaternion.GetLength: Single;
1055
begin
1056
  Result := _vector4_length(@Self);
1057
end;
1058

1059
function TQuaternion.GetLengthSquared: Single;
1060
begin
1061
  Result := _vector4_dot(@Self, @Self);
1062
end;
1063

1064
class operator TQuaternion.Multiply(const A: TQuaternion; const B: Single): TQuaternion;
1065
begin
1066
  _vector4_mul_scalar(@A, B, @Result);
1067
end;
1068

1069
class operator TQuaternion.Multiply(const A: Single; const B: TQuaternion): TQuaternion;
1070
begin
1071
  _scalar_mul_vector4(A, @B, @Result);
1072
end;
1073

1074
class operator TQuaternion.Multiply(const A, B: TQuaternion): TQuaternion;
1075
begin
1076
  Result.X := (A.W * B.X) + (A.X * B.W) + (A.Y * B.Z) - (A.Z * B.Y);
1077
  Result.Y := (A.W * B.Y) + (A.Y * B.W) + (A.Z * B.X) - (A.X * B.Z);
1078
  Result.Z := (A.W * B.Z) + (A.Z * B.W) + (A.X * B.Y) - (A.Y * B.X);
1079
  Result.W := (A.W * B.W) - (A.X * B.X) - (A.Y * B.Y) - (A.Z * B.Z);
1080
end;
1081

1082
function TQuaternion.NormalizeFast: TQuaternion;
1083
begin
1084
  _vector4_normalize_fast(@Self, @Result);
1085
end;
1086

1087
procedure TQuaternion.SetNormalizedFast;
1088
begin
1089
  _vector4_normalize_fast(@Self, @Self);
1090
end;
1091

1092
{ TMatrix 2 }
1093

1094
class operator TMatrix2.Add(const A: TMatrix2; const B: Single): TMatrix2;
1095
begin
1096
  _matrix2_add_scalar(@A, B, @Result);
1097
end;
1098

1099
class operator TMatrix2.Add(const A: Single; const B: TMatrix2): TMatrix2;
1100
begin
1101
  _scalar_add_matrix2(A, @B, @Result);
1102
end;
1103

1104
class operator TMatrix2.Add(const A, B: TMatrix2): TMatrix2;
1105
begin
1106
  _matrix2_add_matrix2(@A, @B, @Result);
1107
end;
1108

1109
function TMatrix2.CompMult(const AOther: TMatrix2): TMatrix2;
1110
begin
1111
  _matrix2_comp_mult(@Self, @AOther, @Result);
1112
end;
1113

1114
class operator TMatrix2.Divide(const A: Single; const B: TMatrix2): TMatrix2;
1115
begin
1116
  _scalar_div_matrix2(A, @B, @Result);
1117
end;
1118

1119
class operator TMatrix2.Divide(const A: TMatrix2; const B: Single): TMatrix2;
1120
begin
1121
  _matrix2_div_scalar(@A, B, @Result);
1122
end;
1123

1124
class operator TMatrix2.Multiply(const A: TMatrix2; const B: Single): TMatrix2;
1125
begin
1126
  _matrix2_mul_scalar(@A, B, @Result);
1127
end;
1128

1129
class operator TMatrix2.Multiply(const A: Single; const B: TMatrix2): TMatrix2;
1130
begin
1131
  _scalar_mul_matrix2(A, @B, @Result);
1132
end;
1133

1134
class operator TMatrix2.Multiply(const A: TVector2; const B: TMatrix2): TVector2;
1135
begin
1136
  _vector2_mul_matrix2(@A, @B, @Result);
1137
end;
1138

1139
class operator TMatrix2.Multiply(const A: TMatrix2; const B: TVector2): TVector2;
1140
begin
1141
  _matrix2_mul_vector2(@A, @B, @Result);
1142
end;
1143

1144
class operator TMatrix2.Multiply(const A, B: TMatrix2): TMatrix2;
1145
begin
1146
  _matrix2_mul_matrix2(@A, @B, @Result);
1147
end;
1148

1149
class operator TMatrix2.Negative(const A: TMatrix2): TMatrix2;
1150
begin
1151
  _neg_matrix2(@A, @Result);
1152
end;
1153

1154
procedure TMatrix2.SetTransposed;
1155
begin
1156
  _matrix2_transpose(@Self, @Self);
1157
end;
1158

1159
class operator TMatrix2.Subtract(const A: TMatrix2; const B: Single): TMatrix2;
1160
begin
1161
  _matrix2_sub_scalar(@A, B, @Result);
1162
end;
1163

1164
class operator TMatrix2.Subtract(const A: Single; const B: TMatrix2): TMatrix2;
1165
begin
1166
  _scalar_sub_matrix2(A, @B, @Result);
1167
end;
1168

1169
class operator TMatrix2.Subtract(const A, B: TMatrix2): TMatrix2;
1170
begin
1171
  _matrix2_sub_matrix2(@A, @B, @Result);
1172
end;
1173

1174
function TMatrix2.Transpose: TMatrix2;
1175
begin
1176
  _matrix2_transpose(@Self, @Result);
1177
end;
1178

1179
{ TMatrix3 }
1180

1181
class operator TMatrix3.Add(const A: TMatrix3; const B: Single): TMatrix3;
1182
begin
1183
  _matrix3_add_scalar(@A, B, @Result);
1184
end;
1185

1186
class operator TMatrix3.Add(const A: Single; const B: TMatrix3): TMatrix3;
1187
begin
1188
  _scalar_add_matrix3(A, @B, @Result);
1189
end;
1190

1191
class operator TMatrix3.Add(const A, B: TMatrix3): TMatrix3;
1192
begin
1193
  _matrix3_add_matrix3(@A, @B, @Result);
1194
end;
1195

1196
function TMatrix3.CompMult(const AOther: TMatrix3): TMatrix3;
1197
begin
1198
  _matrix3_comp_mult(@Self, @AOther, @Result);
1199
end;
1200

1201
class operator TMatrix3.Divide(const A: TMatrix3; const B: Single): TMatrix3;
1202
begin
1203
  _matrix3_div_scalar(@A, B, @Result);
1204
end;
1205

1206
class operator TMatrix3.Divide(const A: Single; const B: TMatrix3): TMatrix3;
1207
begin
1208
  _scalar_div_matrix3(A, @B, @Result);
1209
end;
1210

1211
class operator TMatrix3.Multiply(const A: TMatrix3; const B: Single): TMatrix3;
1212
begin
1213
  _matrix3_mul_scalar(@A, B, @Result);
1214
end;
1215

1216
class operator TMatrix3.Multiply(const A: Single; const B: TMatrix3): TMatrix3;
1217
begin
1218
  _scalar_mul_matrix3(A, @B, @Result);
1219
end;
1220

1221
class operator TMatrix3.Multiply(const A: TVector3; const B: TMatrix3): Tvector3;
1222
begin
1223
  {$IFDEF FM_COLUMN_MAJOR}
1224
  _matrix3_mul_vector3(@B, @A, @Result);
1225
  {$ELSE}
1226
  _vector3_mul_matrix3(@A, @B, @Result);
1227
  {$ENDIF}
1228
end;
1229

1230
class operator TMatrix3.Multiply(const A: TMatrix3; const B: Tvector3): Tvector3;
1231
begin
1232
  {$IFDEF FM_COLUMN_MAJOR}
1233
  _vector3_mul_matrix3(@B, @A, @Result);
1234
  {$ELSE}
1235
  _matrix3_mul_vector3(@A, @B, @Result);
1236
  {$ENDIF}
1237
end;
1238

1239
class operator TMatrix3.Multiply(const A, B: TMatrix3): TMatrix3;
1240
begin
1241
  {$IFDEF FM_COLUMN_MAJOR}
1242
  _matrix3_mul_matrix3(@B, @A, @Result);
1243
  {$ELSE}
1244
  _matrix3_mul_matrix3(@A, @B, @Result);
1245
  {$ENDIF}
1246
end;
1247

1248
class operator TMatrix3.Negative(const A: TMatrix3): TMatrix3;
1249
begin
1250
  _neg_matrix3(@A, @Result);
1251
end;
1252

1253
procedure TMatrix3.SetTransposed;
1254
begin
1255
  _matrix3_transpose(@Self, @Self);
1256
end;
1257

1258
class operator TMatrix3.Subtract(const A: TMatrix3; const B: Single): TMatrix3;
1259
begin
1260
  _matrix3_sub_scalar(@A, B, @Result);
1261
end;
1262

1263
class operator TMatrix3.Subtract(const A: Single; const B: TMatrix3): TMatrix3;
1264
begin
1265
  _scalar_sub_matrix3(A, @B, @Result);
1266
end;
1267

1268
class operator TMatrix3.Subtract(const A, B: TMatrix3): TMatrix3;
1269
begin
1270
  _matrix3_sub_matrix3(@A, @B, @Result);
1271
end;
1272

1273
function TMatrix3.Transpose: TMatrix3;
1274
begin
1275
  Result.M[0,0] := M[0,0];
1276
  Result.M[0,1] := M[1,0];
1277
  Result.M[0,2] := M[2,0];
1278

1279
  Result.M[1,0] := M[0,1];
1280
  Result.M[1,1] := M[1,1];
1281
  Result.M[1,2] := M[2,1];
1282

1283
  Result.M[2,0] := M[0,2];
1284
  Result.M[2,1] := M[1,2];
1285
  Result.M[2,2] := M[2,2];
1286
end;
1287
{function TMatrix3.Transpose: TMatrix3;
1288
begin
1289
  _matrix3_transpose(@Self, @Result);
1290
end;}
1291

1292
{ TMatrix4 }
1293

1294
class operator TMatrix4.Add(const A: TMatrix4; const B: Single): TMatrix4;
1295
begin
1296
  _matrix4_add_scalar(@A, B, @Result);
1297
end;
1298

1299
class operator TMatrix4.Add(const A: Single; const B: TMatrix4): TMatrix4;
1300
begin
1301
  _scalar_add_matrix4(A, @B, @Result);
1302
end;
1303

1304
class operator TMatrix4.Add(const A, B: TMatrix4): TMatrix4;
1305
begin
1306
  _matrix4_add_matrix4(@A, @B, @Result);
1307
end;
1308

1309
function TMatrix4.CompMult(const AOther: TMatrix4): TMatrix4;
1310
begin
1311
  _matrix4_comp_mult(@Self, @AOther, @Result);
1312
end;
1313

1314
class operator TMatrix4.Divide(const A: TMatrix4; const B: Single): TMatrix4;
1315
begin
1316
  _matrix4_div_scalar(@A, B, @Result);
1317
end;
1318

1319
class operator TMatrix4.Divide(const A: Single; const B: TMatrix4): TMatrix4;
1320
begin
1321
  _scalar_div_matrix4(A, @B, @Result);
1322
end;
1323

1324
function TMatrix4.Inverse: TMatrix4;
1325
begin
1326
  _matrix4_inverse(@Self, @Result);
1327
end;
1328

1329
class operator TMatrix4.Multiply(const A: TMatrix4; const B: Single): TMatrix4;
1330
begin
1331
  _matrix4_mul_scalar(@A, B, @Result);
1332
end;
1333

1334
class operator TMatrix4.Multiply(const A: Single; const B: TMatrix4): TMatrix4;
1335
begin
1336
  _scalar_mul_matrix4(A, @B, @Result);
1337
end;
1338

1339
class operator TMatrix4.Multiply(const A: TVector4; const B: TMatrix4): TVector4;
1340
begin
1341
  {$IFDEF FM_COLUMN_MAJOR}
1342
  _matrix4_mul_vector4(@B, @A, @Result);
1343
  {$ELSE}
1344
  _vector4_mul_matrix4(@A, @B, @Result);
1345
  {$ENDIF}
1346
end;
1347

1348
class operator TMatrix4.Multiply(const A: TMatrix4; const B: TVector4): TVector4;
1349
begin
1350
  {$IFDEF FM_COLUMN_MAJOR}
1351
  _vector4_mul_matrix4(@B, @A, @Result);
1352
  {$ELSE}
1353
  _matrix4_mul_vector4(@A, @B, @Result);
1354
  {$ENDIF}
1355
end;
1356

1357
class operator TMatrix4.Multiply(const A, B: TMatrix4): TMatrix4;
1358
begin
1359
  {$IFDEF FM_COLUMN_MAJOR}
1360
  _matrix4_mul_matrix4(@B, @A, @Result);
1361
  {$ELSE}
1362
  _matrix4_mul_matrix4(@A, @B, @Result);
1363
  {$ENDIF}
1364
end;
1365

1366
class operator TMatrix4.Negative(const A: TMatrix4): TMatrix4;
1367
begin
1368
  _neg_matrix4(@A, @Result);
1369
end;
1370

1371
procedure TMatrix4.SetInversed;
1372
begin
1373
  _matrix4_inverse(@Self, @Self);
1374
end;
1375

1376
procedure TMatrix4.SetTransposed;
1377
begin
1378
  _matrix4_transpose(@Self, @Self);
1379
end;
1380

1381
class operator TMatrix4.Subtract(const A: TMatrix4; const B: Single): TMatrix4;
1382
begin
1383
  _matrix4_sub_scalar(@A, B, @Result);
1384
end;
1385

1386
class operator TMatrix4.Subtract(const A: Single; const B: TMatrix4): TMatrix4;
1387
begin
1388
  _scalar_sub_matrix4(A, @B, @Result);
1389
end;
1390

1391
class operator TMatrix4.Subtract(const A, B: TMatrix4): TMatrix4;
1392
begin
1393
  _matrix4_sub_matrix4(@A, @B, @Result);
1394
end;
1395

1396
function TMatrix4.Transpose: TMatrix4;
1397
begin
1398
  _matrix4_transpose(@Self, @Result);
1399
end;
1400