MathgeomGLS

1
const
2
  {$IFDEF FM_COLUMN_MAJOR}
3
  LIB_FASTMATH = 'FastMathMacOS64CM.obj';
4
  {$ELSE}
5
  LIB_FASTMATH = 'FastMathMacOS64RM.obj';
6
  {$ENDIF}
7

8
{ Angle and Trigonometry Functions }
9

10
function Radians(const ADegrees: Single): Single;
11
begin
12
  Result := ADegrees * (Pi / 180);
13
end;
14

15
function Radians(const ADegrees: TVector2): TVector2; external LIB_FASTMATH name 'radians_vector2';
16
function Radians(const ADegrees: TVector3): TVector3; external LIB_FASTMATH name 'radians_vector3';
17
function Radians(const ADegrees: TVector4): TVector4; external LIB_FASTMATH name 'radians_vector4';
18

19
function Degrees(const ARadians: Single): Single;
20
begin
21
  Result := ARadians * (180 / Pi);
22
end;
23

24
function Degrees(const ARadians: TVector2): TVector2; external LIB_FASTMATH name 'degrees_vector2';
25
function Degrees(const ARadians: TVector3): TVector3; external LIB_FASTMATH name 'degrees_vector3';
26
function Degrees(const ARadians: TVector4): TVector4; external LIB_FASTMATH name 'degrees_vector4';
27

28
{ Exponential Functions }
29

30
function Sqrt(const A: Single): Single; external LIB_FASTMATH name 'sqrt_single';
31
function Sqrt(const A: TVector2): TVector2; external LIB_FASTMATH name 'sqrt_vector2';
32
function Sqrt(const A: TVector3): TVector3; external LIB_FASTMATH name 'sqrt_vector3';
33
function Sqrt(const A: TVector4): TVector4; external LIB_FASTMATH name 'sqrt_vector4';
34

35
function InverseSqrt(const A: Single): Single; external LIB_FASTMATH name 'inverse_sqrt_single';
36
function InverseSqrt(const A: TVector2): TVector2; external LIB_FASTMATH name 'inverse_sqrt_vector2';
37
function InverseSqrt(const A: TVector3): TVector3; external LIB_FASTMATH name 'inverse_sqrt_vector3';
38
function InverseSqrt(const A: TVector4): TVector4; external LIB_FASTMATH name 'inverse_sqrt_vector4';
39

40
{ Fast approximate Functions }
41

42
function FastSin(const ARadians: Single): Single; external LIB_FASTMATH name 'fast_sin_single';
43
function FastSin(const ARadians: TVector2): TVector2; external LIB_FASTMATH name 'fast_sin_vector2';
44
function FastSin(const ARadians: TVector3): TVector3; external LIB_FASTMATH name 'fast_sin_vector3';
45
function FastSin(const ARadians: TVector4): TVector4; external LIB_FASTMATH name 'fast_sin_vector4';
46

47
function FastCos(const ARadians: Single): Single; external LIB_FASTMATH name 'fast_cos_single';
48
function FastCos(const ARadians: TVector2): TVector2; external LIB_FASTMATH name 'fast_cos_vector2';
49
function FastCos(const ARadians: TVector3): TVector3; external LIB_FASTMATH name 'fast_cos_vector3';
50
function FastCos(const ARadians: TVector4): TVector4; external LIB_FASTMATH name 'fast_cos_vector4';
51

52
procedure FastSinCos(const ARadians: Single; out ASin, ACos: Single); external LIB_FASTMATH name 'fast_sin_cos_single';
53
procedure FastSinCos(const ARadians: TVector2; out ASin, ACos: TVector2); external LIB_FASTMATH name 'fast_sin_cos_vector2';
54
procedure FastSinCos(const ARadians: TVector3; out ASin, ACos: TVector3); external LIB_FASTMATH name 'fast_sin_cos_vector3';
55
procedure FastSinCos(const ARadians: TVector4; out ASin, ACos: TVector4); external LIB_FASTMATH name 'fast_sin_cos_vector4';
56

57
function FastExp(const A: Single): Single; external LIB_FASTMATH name 'fast_exp_single';
58
function FastExp(const A: TVector2): TVector2; external LIB_FASTMATH name 'fast_exp_vector2';
59
function FastExp(const A: TVector3): TVector3; external LIB_FASTMATH name 'fast_exp_vector3';
60
function FastExp(const A: TVector4): TVector4; external LIB_FASTMATH name 'fast_exp_vector4';
61

62
function FastLn(const A: Single): Single; external LIB_FASTMATH name 'fast_ln_single';
63
function FastLn(const A: TVector2): TVector2; external LIB_FASTMATH name 'fast_ln_vector2';
64
function FastLn(const A: TVector3): TVector3; external LIB_FASTMATH name 'fast_ln_vector3';
65
function FastLn(const A: TVector4): TVector4; external LIB_FASTMATH name 'fast_ln_vector4';
66

67
function FastLog2(const A: Single): Single; external LIB_FASTMATH name 'fast_log2_single';
68
function FastLog2(const A: TVector2): TVector2; external LIB_FASTMATH name 'fast_log2_vector2';
69
function FastLog2(const A: TVector3): TVector3; external LIB_FASTMATH name 'fast_log2_vector3';
70
function FastLog2(const A: TVector4): TVector4; external LIB_FASTMATH name 'fast_log2_vector4';
71

72
function FastExp2(const A: Single): Single; external LIB_FASTMATH name 'fast_exp2_single';
73
function FastExp2(const A: TVector2): TVector2; external LIB_FASTMATH name 'fast_exp2_vector2';
74
function FastExp2(const A: TVector3): TVector3; external LIB_FASTMATH name 'fast_exp2_vector3';
75
function FastExp2(const A: TVector4): TVector4; external LIB_FASTMATH name 'fast_exp2_vector4';
76

77
{ Common Functions }
78

79
function Abs(const A: Single): Single;
80
begin
81
  Result := System.Abs(A);
82
end;
83

84
function Abs(const A: TVector2): TVector2;
85
begin
86
  Result.Init(System.Abs(A.X), System.Abs(A.Y));
87
end;
88

89
function Abs(const A: TVector3): TVector3; external LIB_FASTMATH name 'abs_vector3';
90
function Abs(const A: TVector4): TVector4; external LIB_FASTMATH name 'abs_vector4';
91

92
function Sign(const A: Single): Single; external LIB_FASTMATH name 'sign_single';
93
function Sign(const A: TVector2): TVector2; external LIB_FASTMATH name 'sign_vector2';
94
function Sign(const A: TVector3): TVector3; external LIB_FASTMATH name 'sign_vector3';
95
function Sign(const A: TVector4): TVector4; external LIB_FASTMATH name 'sign_vector4';
96

97
function Floor(const A: Single): Integer; external LIB_FASTMATH name 'floor_single';
98
function Floor(const A: TVector2): TIVector2; external LIB_FASTMATH name 'floor_vector2';
99
function Floor(const A: TVector3): TIVector3; external LIB_FASTMATH name 'floor_vector3';
100
function Floor(const A: TVector4): TIVector4; external LIB_FASTMATH name 'floor_vector4';
101

102
function Trunc(const A: Single): Integer; external LIB_FASTMATH name 'trunc_single';
103
function Trunc(const A: TVector2): TIVector2; external LIB_FASTMATH name 'trunc_vector2';
104
function Trunc(const A: TVector3): TIVector3; external LIB_FASTMATH name 'trunc_vector3';
105
function Trunc(const A: TVector4): TIVector4; external LIB_FASTMATH name 'trunc_vector4';
106

107
function Round(const A: Single): Integer; external LIB_FASTMATH name 'round_single';
108
function Round(const A: TVector2): TIVector2; external LIB_FASTMATH name 'round_vector2';
109
function Round(const A: TVector3): TIVector3; external LIB_FASTMATH name 'round_vector3';
110
function Round(const A: TVector4): TIVector4; external LIB_FASTMATH name 'round_vector4';
111

112
function Ceil(const A: Single): Integer; external LIB_FASTMATH name 'ceil_single';
113
function Ceil(const A: TVector2): TIVector2; external LIB_FASTMATH name 'ceil_vector2';
114
function Ceil(const A: TVector3): TIVector3; external LIB_FASTMATH name 'ceil_vector3';
115
function Ceil(const A: TVector4): TIVector4; external LIB_FASTMATH name 'ceil_vector4';
116

117
function Frac(const A: Single): Single;
118
begin
119
  Result := System.Frac(A);
120
end;
121

122
function Frac(const A: TVector2): TVector2; external LIB_FASTMATH name 'frac_vector2';
123
function Frac(const A: TVector3): TVector3; external LIB_FASTMATH name 'frac_vector3';
124
function Frac(const A: TVector4): TVector4; external LIB_FASTMATH name 'frac_vector4';
125

126
function FMod(const A, B: Single): Single;
127
begin
128
  Result := A - (B * Trunc(A / B));
129
end;
130

131
function FMod(const A: TVector2; const B: Single): TVector2; external LIB_FASTMATH name 'fmod_vector2_single';
132
function FMod(const A, B: TVector2): TVector2; external LIB_FASTMATH name 'fmod_vector2';
133
function FMod(const A: TVector3; const B: Single): TVector3; external LIB_FASTMATH name 'fmod_vector3_single';
134
function FMod(const A, B: TVector3): TVector3; external LIB_FASTMATH name 'fmod_vector3';
135
function FMod(const A: TVector4; const B: Single): TVector4; external LIB_FASTMATH name 'fmod_vector4_single';
136
function FMod(const A, B: TVector4): TVector4; external LIB_FASTMATH name 'fmod_vector4';
137

138
function ModF(const A: Single; out B: Integer): Single;
139
begin
140
  B := Trunc(A);
141
  Result := Frac(A);
142
end;
143

144
function ModF(const A: TVector2; out B: TIVector2): TVector2; external LIB_FASTMATH name 'modf_vector2';
145
function ModF(const A: TVector3; out B: TIVector3): TVector3; external LIB_FASTMATH name 'modf_vector3';
146
function ModF(const A: TVector4; out B: TIVector4): TVector4; external LIB_FASTMATH name 'modf_vector4';
147

148
function Min(const A: TVector2; const B: Single): TVector2; external LIB_FASTMATH name 'min_vector2_single';
149
function Min(const A, B: TVector2): TVector2; external LIB_FASTMATH name 'min_vector2';
150
function Min(const A: TVector3; const B: Single): TVector3; external LIB_FASTMATH name 'min_vector3_single';
151
function Min(const A, B: TVector3): TVector3; external LIB_FASTMATH name 'min_vector3';
152
function Min(const A: TVector4; const B: Single): TVector4; external LIB_FASTMATH name 'min_vector4_single';
153
function Min(const A, B: TVector4): TVector4; external LIB_FASTMATH name 'min_vector4';
154

155
function Max(const A: TVector2; const B: Single): TVector2; external LIB_FASTMATH name 'max_vector2_single';
156
function Max(const A, B: TVector2): TVector2; external LIB_FASTMATH name 'max_vector2';
157
function Max(const A: TVector3; const B: Single): TVector3; external LIB_FASTMATH name 'max_vector3_single';
158
function Max(const A, B: TVector3): TVector3; external LIB_FASTMATH name 'max_vector3';
159
function Max(const A: TVector4; const B: Single): TVector4; external LIB_FASTMATH name 'max_vector4_single';
160
function Max(const A, B: TVector4): TVector4; external LIB_FASTMATH name 'max_vector4';
161

162
function EnsureRange(const A, AMin, AMax: Single): Single; external LIB_FASTMATH name 'ensure_range_single';
163
function EnsureRange(const A: TVector2; const AMin, AMax: Single): TVector2; external LIB_FASTMATH name 'ensure_range_vector2_single';
164
function EnsureRange(const A, AMin, AMax: TVector2): TVector2; external LIB_FASTMATH name 'ensure_range_vector2';
165
function EnsureRange(const A: TVector3; const AMin, AMax: Single): TVector3; external LIB_FASTMATH name 'ensure_range_vector3_single';
166
function EnsureRange(const A, AMin, AMax: TVector3): TVector3; external LIB_FASTMATH name 'ensure_range_vector3';
167
function EnsureRange(const A: TVector4; const AMin, AMax: Single): TVector4; external LIB_FASTMATH name 'ensure_range_vector4_single';
168
function EnsureRange(const A, AMin, AMax: TVector4): TVector4; external LIB_FASTMATH name 'ensure_range_vector4';
169

170
function Mix(const A, B: TVector2; const T: Single): TVector2;
171
begin
172
  Result.Init(Mix(A.X, B.X, T), Mix(A.Y, B.Y, T));
173
end;
174

175
function Mix(const A, B, T: TVector2): TVector2;
176
begin
177
  Result.Init(Mix(A.X, B.X, T.X), Mix(A.Y, B.Y, T.Y));
178
end;
179

180
function Mix(const A, B: TVector3; const T: Single): TVector3; external LIB_FASTMATH name 'mix_vector3_single';
181
function Mix(const A, B, T: TVector3): TVector3; external LIB_FASTMATH name 'mix_vector3';
182
function Mix(const A, B: TVector4; const T: Single): TVector4; external LIB_FASTMATH name 'mix_vector4_single';
183
function Mix(const A, B, T: TVector4): TVector4; external LIB_FASTMATH name 'mix_vector4';
184

185
function Step(const AEdge: Single; const A: TVector2): TVector2; external LIB_FASTMATH name 'step_single_vector2';
186
function Step(const AEdge, A: TVector2): TVector2; external LIB_FASTMATH name 'step_vector2';
187
function Step(const AEdge: Single; const A: TVector3): TVector3; external LIB_FASTMATH name 'step_single_vector3';
188
function Step(const AEdge, A: TVector3): TVector3; external LIB_FASTMATH name 'step_vector3';
189
function Step(const AEdge: Single; const A: TVector4): TVector4; external LIB_FASTMATH name 'step_single_vector4';
190
function Step(const AEdge, A: TVector4): TVector4; external LIB_FASTMATH name 'step_vector4';
191

192
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector2): TVector2;
193
begin
194
  Result.Init(SmoothStep(AEdge0, AEdge1, A.X), SmoothStep(AEdge0, AEdge1, A.Y));
195
end;
196

197
function SmoothStep(const AEdge0, AEdge1, A: TVector2): TVector2;
198
begin
199
  Result.Init(SmoothStep(AEdge0.X, AEdge1.X, A.X), SmoothStep(AEdge0.Y, AEdge1.Y, A.Y));
200
end;
201

202
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector3): TVector3; external LIB_FASTMATH name 'smooth_step_single_vector3';
203
function SmoothStep(const AEdge0, AEdge1, A: TVector3): TVector3; external LIB_FASTMATH name 'smooth_step_vector3';
204
function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector4): TVector4; external LIB_FASTMATH name 'smooth_step_single_vector4';
205
function SmoothStep(const AEdge0, AEdge1, A: TVector4): TVector4; external LIB_FASTMATH name 'smooth_step_vector4';
206

207
function FMA(const A, B, C: TVector2): TVector2; external LIB_FASTMATH name 'fma_vector2';
208
function FMA(const A, B, C: TVector3): TVector3; external LIB_FASTMATH name 'fma_vector3';
209
function FMA(const A, B, C: TVector4): TVector4; external LIB_FASTMATH name 'fma_vector4';
210

211
{ Matrix functions }
212

213
function OuterProduct(const C, R: TVector2): TMatrix2; external LIB_FASTMATH name 'outer_product_matrix2';
214
function OuterProduct(const C, R: TVector3): TMatrix3; external LIB_FASTMATH name 'outer_product_matrix3';
215
function OuterProduct(const C, R: TVector4): TMatrix4; external LIB_FASTMATH name 'outer_product_matrix4';
216

217
{ TVector2 }
218

219
class operator TVector2.Add(const A: TVector2; const B: Single): TVector2;
220
begin
221
  Result.X := A.X + B;
222
  Result.Y := A.Y + B;
223
end;
224

225
class operator TVector2.Add(const A: Single; const B: TVector2): TVector2;
226
begin
227
  Result.X := A + B.X;
228
  Result.Y := A + B.Y;
229
end;
230

231
class operator TVector2.Add(const A, B: TVector2): TVector2;
232
begin
233
  Result.X := A.X + B.X;
234
  Result.Y := A.Y + B.Y;
235
end;
236

237
function TVector2.Distance(const AOther: TVector2): Single;
238
begin
239
  Result := (Self - AOther).Length;
240
end;
241

242
function TVector2.DistanceSquared(const AOther: TVector2): Single;
243
begin
244
  Result := (Self - AOther).LengthSquared;
245
end;
246

247
class operator TVector2.Divide(const A: TVector2; const B: Single): TVector2; external LIB_FASTMATH name 'vector2_div_single';
248
class operator TVector2.Divide(const A: Single; const B: TVector2): TVector2; external LIB_FASTMATH name 'single_div_vector2';
249
class operator TVector2.Divide(const A, B: TVector2): TVector2; external LIB_FASTMATH name 'vector2_div_vector2';
250

251
function TVector2.Dot(const AOther: TVector2): Single;
252
begin
253
  Result := (X * AOther.X) + (Y * AOther.Y);
254
end;
255

256
function TVector2.FaceForward(const I, NRef: TVector2): TVector2;
257
begin
258
  if (NRef.Dot(I) < 0) then
259
    Result := Self
260
  else
261
    Result := -Self;
262
end;
263

264
function TVector2.GetLength: Single;
265
begin
266
  Result := Sqrt((X * X) + (Y * Y));
267
end;
268

269
function TVector2.GetLengthSquared: Single;
270
begin
271
  Result := (X * X) + (Y * Y);
272
end;
273

274
class operator TVector2.Multiply(const A: TVector2; const B: Single): TVector2;
275
begin
276
  Result.X := A.X * B;
277
  Result.Y := A.Y * B;
278
end;
279

280
class operator TVector2.Multiply(const A: Single; const B: TVector2): TVector2;
281
begin
282
  Result.X := A * B.X;
283
  Result.Y := A * B.Y;
284
end;
285

286
class operator TVector2.Multiply(const A, B: TVector2): TVector2;
287
begin
288
  Result.X := A.X * B.X;
289
  Result.Y := A.Y * B.Y;
290
end;
291

292
function TVector2.NormalizeFast: TVector2; external LIB_FASTMATH name 'vector2_normalize_fast';
293

294
function TVector2.Reflect(const N: TVector2): TVector2;
295
begin
296
  Result := Self - ((2 * N.Dot(Self)) * N);
297
end;
298

299
function TVector2.Refract(const N: TVector2; const Eta: Single): TVector2;
300
var
301
  D, K: Single;
302
begin
303
  D := N.Dot(Self);
304
  K := 1 - Eta * Eta * (1 - D * D);
305
  if (K < 0) then
306
    Result.Init
307
  else
308
    Result := (Eta * Self) - ((Eta * D + Sqrt(K)) * N);
309
end;
310

311
procedure TVector2.SetNormalizedFast; external LIB_FASTMATH name 'vector2_set_normalized_fast';
312

313
class operator TVector2.Subtract(const A: TVector2; const B: Single): TVector2;
314
begin
315
  Result.X := A.X - B;
316
  Result.Y := A.Y - B;
317
end;
318

319
class operator TVector2.Subtract(const A: Single; const B: TVector2): TVector2;
320
begin
321
  Result.X := A - B.X;
322
  Result.Y := A - B.Y;
323
end;
324

325
class operator TVector2.Subtract(const A, B: TVector2): TVector2;
326
begin
327
  Result.X := A.X - B.X;
328
  Result.Y := A.Y - B.Y;
329
end;
330

331
{ TVector3 }
332

333
class operator TVector3.Add(const A: TVector3; const B: Single): TVector3; external LIB_FASTMATH name 'vector3_add_single';
334
class operator TVector3.Add(const A: Single; const B: TVector3): TVector3; external LIB_FASTMATH name 'single_add_vector3';
335
class operator TVector3.Add(const A, B: TVector3): TVector3; external LIB_FASTMATH name 'vector3_add_vector3';
336

337
function TVector3.Distance(const AOther: TVector3): Single; external LIB_FASTMATH name 'vector3_distance';
338
function TVector3.DistanceSquared(const AOther: TVector3): Single; external LIB_FASTMATH name 'vector3_distance_squared';
339

340
class operator TVector3.Divide(const A: TVector3; const B: Single): TVector3; external LIB_FASTMATH name 'vector3_div_single';
341
class operator TVector3.Divide(const A: Single; const B: TVector3): TVector3; external LIB_FASTMATH name 'single_div_vector3';
342
class operator TVector3.Divide(const A, B: TVector3): TVector3; external LIB_FASTMATH name 'vector3_div_vector3';
343

344
function TVector3.Cross(const AOther: TVector3): TVector3;
345
begin
346
  Result.X := (Y * AOther.Z) - (AOther.Y * Z);
347
  Result.Y := (Z * AOther.X) - (AOther.Z * X);
348
  Result.Z := (X * AOther.Y) - (AOther.X * Y);
349
end;
350

351
function TVector3.Dot(const AOther: TVector3): Single;
352
begin
353
  Result := (X * AOther.X) + (Y * AOther.Y) + (Z * AOther.Z);
354
end;
355

356
function TVector3.FaceForward(const I, NRef: TVector3): TVector3;
357
begin
358
  if (NRef.Dot(I) < 0) then
359
    Result := Self
360
  else
361
    Result := -Self;
362
end;
363

364
function TVector3.GetLength: Single; external LIB_FASTMATH name 'vector3_get_length';
365
function TVector3.GetLengthSquared: Single; external LIB_FASTMATH name 'vector3_get_length_squared';
366

367
class operator TVector3.Multiply(const A: TVector3; const B: Single): TVector3; external LIB_FASTMATH name 'vector3_mul_single';
368
class operator TVector3.Multiply(const A: Single; const B: TVector3): TVector3; external LIB_FASTMATH name 'single_mul_vector3';
369
class operator TVector3.Multiply(const A, B: TVector3): TVector3; external LIB_FASTMATH name 'vector3_mul_vector3';
370

371
class operator TVector3.Negative(const A: TVector3): TVector3;
372
begin
373
  Result.X := -A.X;
374
  Result.Y := -A.Y;
375
  Result.Z := -A.Z;
376
end;
377

378
function TVector3.NormalizeFast: TVector3; external LIB_FASTMATH name 'vector3_normalize_fast';
379
procedure TVector3.SetNormalizedFast; external LIB_FASTMATH name 'vector3_set_normalized_fast';
380

381
function TVector3.Reflect(const N: TVector3): TVector3; external LIB_FASTMATH name 'vector3_reflect';
382
function TVector3.Refract(const N: TVector3; const Eta: Single): TVector3; external LIB_FASTMATH name 'vector3_refract';
383

384
class operator TVector3.Subtract(const A: TVector3; const B: Single): TVector3; external LIB_FASTMATH name 'vector3_sub_single';
385
class operator TVector3.Subtract(const A: Single; const B: TVector3): TVector3; external LIB_FASTMATH name 'single_sub_vector3';
386
class operator TVector3.Subtract(const A, B: TVector3): TVector3; external LIB_FASTMATH name 'vector3_sub_vector3';
387

388
{ TVector4 }
389

390
class operator TVector4.Add(const A: TVector4; const B: Single): TVector4; external LIB_FASTMATH name 'vector4_add_single';
391
class operator TVector4.Add(const A: Single; const B: TVector4): TVector4; external LIB_FASTMATH name 'single_add_vector4';
392
class operator TVector4.Add(const A, B: TVector4): TVector4; external LIB_FASTMATH name 'vector4_add_vector4';
393

394
function TVector4.Distance(const AOther: TVector4): Single; external LIB_FASTMATH name 'vector4_distance';
395
function TVector4.DistanceSquared(const AOther: TVector4): Single; external LIB_FASTMATH name 'vector4_distance_squared';
396

397
class operator TVector4.Divide(const A: TVector4; const B: Single): TVector4; external LIB_FASTMATH name 'vector4_div_single';
398
class operator TVector4.Divide(const A: Single; const B: TVector4): TVector4; external LIB_FASTMATH name 'single_div_vector4';
399
class operator TVector4.Divide(const A, B: TVector4): TVector4; external LIB_FASTMATH name 'vector4_div_vector4';
400

401
function TVector4.Dot(const AOther: TVector4): Single;
402
begin
403
  Result := (X * AOther.X) + (Y * AOther.Y) + (Z * AOther.Z) + (W * AOther.W);
404
end;
405

406
function TVector4.FaceForward(const I, NRef: TVector4): TVector4; external LIB_FASTMATH name 'vector4_face_forward';
407

408
function TVector4.GetLength: Single; external LIB_FASTMATH name 'vector4_get_length';
409
function TVector4.GetLengthSquared: Single; external LIB_FASTMATH name 'vector4_get_length_squared';
410

411
class operator TVector4.Multiply(const A: TVector4; const B: Single): TVector4; external LIB_FASTMATH name 'vector4_mul_single';
412
class operator TVector4.Multiply(const A: Single; const B: TVector4): TVector4; external LIB_FASTMATH name 'single_mul_vector4';
413
class operator TVector4.Multiply(const A, B: TVector4): TVector4; external LIB_FASTMATH name 'vector4_mul_vector4';
414

415
class operator TVector4.Negative(const A: TVector4): TVector4; external LIB_FASTMATH name 'vector4_negative';
416

417
function TVector4.NormalizeFast: TVector4; external LIB_FASTMATH name 'vector4_normalize_fast';
418
procedure TVector4.SetNormalizedFast; external LIB_FASTMATH name 'vector4_set_normalized_fast';
419

420
function TVector4.Reflect(const N: TVector4): TVector4; external LIB_FASTMATH name 'vector4_reflect';
421
function TVector4.Refract(const N: TVector4; const Eta: Single): TVector4; external LIB_FASTMATH name 'vector4_refract';
422

423
class operator TVector4.Subtract(const A: TVector4; const B: Single): TVector4; external LIB_FASTMATH name 'vector4_sub_single';
424
class operator TVector4.Subtract(const A: Single; const B: TVector4): TVector4; external LIB_FASTMATH name 'single_sub_vector4';
425
class operator TVector4.Subtract(const A, B: TVector4): TVector4; external LIB_FASTMATH name 'vector4_sub_vector4';
426

427
{ TQuaternion }
428

429
class operator TQuaternion.Add(const A, B: TQuaternion): TQuaternion; external LIB_FASTMATH name 'vector4_add_vector4';
430

431
function TQuaternion.GetLength: Single; external LIB_FASTMATH name 'vector4_get_length';
432

433
function TQuaternion.GetLengthSquared: Single;
434
begin
435
  Result := (X * X) + (Y * Y) + (Z * Z) + (W * W);
436
end;
437

438
class operator TQuaternion.Multiply(const A: TQuaternion; const B: Single): TQuaternion; external LIB_FASTMATH name 'vector4_mul_single';
439
class operator TQuaternion.Multiply(const A: Single; const B: TQuaternion): TQuaternion; external LIB_FASTMATH name 'single_mul_vector4';
440

441
class operator TQuaternion.Multiply(const A, B: TQuaternion): TQuaternion;
442
begin
443
  Result.X := (A.W * B.X) + (A.X * B.W) + (A.Y * B.Z) - (A.Z * B.Y);
444
  Result.Y := (A.W * B.Y) + (A.Y * B.W) + (A.Z * B.X) - (A.X * B.Z);
445
  Result.Z := (A.W * B.Z) + (A.Z * B.W) + (A.X * B.Y) - (A.Y * B.X);
446
  Result.W := (A.W * B.W) - (A.X * B.X) - (A.Y * B.Y) - (A.Z * B.Z);
447
end;
448

449
function TQuaternion.NormalizeFast: TQuaternion; external LIB_FASTMATH name 'vector4_normalize_fast';
450
procedure TQuaternion.SetNormalizedFast; external LIB_FASTMATH name 'vector4_set_normalized_fast';
451

452
{ TMatrix 2 }
453

454
class operator TMatrix2.Add(const A: TMatrix2; const B: Single): TMatrix2; external LIB_FASTMATH name 'vector4_add_single';
455
class operator TMatrix2.Add(const A: Single; const B: TMatrix2): TMatrix2; external LIB_FASTMATH name 'single_add_vector4';
456
class operator TMatrix2.Add(const A, B: TMatrix2): TMatrix2; external LIB_FASTMATH name 'vector4_add_vector4';
457

458
function TMatrix2.CompMult(const AOther: TMatrix2): TMatrix2; external LIB_FASTMATH name 'vector4_mul_vector4';
459

460
class operator TMatrix2.Divide(const A: Single; const B: TMatrix2): TMatrix2; external LIB_FASTMATH name 'single_div_vector4';
461
class operator TMatrix2.Divide(const A: TMatrix2; const B: Single): TMatrix2; external LIB_FASTMATH name 'vector4_div_single';
462

463
class operator TMatrix2.Multiply(const A: Single; const B: TMatrix2): TMatrix2; external LIB_FASTMATH name 'single_mul_vector4';
464
class operator TMatrix2.Multiply(const A: TMatrix2; const B: Single): TMatrix2; external LIB_FASTMATH name 'vector4_mul_single';
465

466
class operator TMatrix2.Multiply(const A: TVector2; const B: TMatrix2): TVector2;
467
begin
468
  Result.X := (A.X * B.M[0,0]) + (A.Y * B.M[0,1]);
469
  Result.Y := (A.X * B.M[1,0]) + (A.Y * B.M[1,1]);
470
end;
471

472
class operator TMatrix2.Multiply(const A: TMatrix2; const B: TVector2): TVector2;
473
begin
474
  Result.X := (A.M[0,0] * B.X) + (A.M[1,0] * B.Y);
475
  Result.Y := (A.M[0,1] * B.X) + (A.M[1,1] * B.Y);
476
end;
477

478
class operator TMatrix2.Multiply(const A, B: TMatrix2): TMatrix2;
479
begin
480
  Result.M[0,0] := (A.M[0,0] * B.M[0,0]) + (A.M[1,0] * B.M[0,1]);
481
  Result.M[0,1] := (A.M[0,1] * B.M[0,0]) + (A.M[1,1] * B.M[0,1]);
482
  Result.M[1,0] := (A.M[0,0] * B.M[1,0]) + (A.M[1,0] * B.M[1,1]);
483
  Result.M[1,1] := (A.M[0,1] * B.M[1,0]) + (A.M[1,1] * B.M[1,1]);
484
end;
485

486
class operator TMatrix2.Negative(const A: TMatrix2): TMatrix2; external LIB_FASTMATH name 'vector4_negative';
487

488
function TMatrix2.Transpose: TMatrix2;
489
begin
490
  Result.M[0,0] := M[0,0];
491
  Result.M[0,1] := M[1,0];
492

493
  Result.M[1,0] := M[0,1];
494
  Result.M[1,1] := M[1,1];
495
end;
496

497
procedure TMatrix2.SetTransposed;
498
begin
499
  Self := Transpose;
500
end;
501

502
class operator TMatrix2.Subtract(const A: TMatrix2; const B: Single): TMatrix2; external LIB_FASTMATH name 'vector4_sub_single';
503
class operator TMatrix2.Subtract(const A: Single; const B: TMatrix2): TMatrix2; external LIB_FASTMATH name 'single_sub_vector4';
504
class operator TMatrix2.Subtract(const A, B: TMatrix2): TMatrix2; external LIB_FASTMATH name 'vector4_sub_vector4';
505

506
{ TMatrix3 }
507

508
class operator TMatrix3.Add(const A: TMatrix3; const B: Single): TMatrix3; external LIB_FASTMATH name 'matrix3_add_single';
509
class operator TMatrix3.Add(const A: Single; const B: TMatrix3): TMatrix3; external LIB_FASTMATH name 'single_add_matrix3';
510
class operator TMatrix3.Add(const A, B: TMatrix3): TMatrix3; external LIB_FASTMATH name 'matrix3_add_matrix3';
511

512
function TMatrix3.CompMult(const AOther: TMatrix3): TMatrix3; external LIB_FASTMATH name 'matrix3_comp_mult';
513

514
class operator TMatrix3.Divide(const A: Single; const B: TMatrix3): TMatrix3; external LIB_FASTMATH name 'single_div_matrix3';
515
class operator TMatrix3.Divide(const A: TMatrix3; const B: Single): TMatrix3; external LIB_FASTMATH name 'matrix3_div_single';
516

517
class operator TMatrix3.Multiply(const A: Single; const B: TMatrix3): TMatrix3; external LIB_FASTMATH name 'single_mul_matrix3';
518
class operator TMatrix3.Multiply(const A: TMatrix3; const B: Single): TMatrix3; external LIB_FASTMATH name 'matrix3_mul_single';
519
class operator TMatrix3.Multiply(const A: TMatrix3; const B: TVector3): TVector3; external LIB_FASTMATH name 'matrix3_mul_vector3';
520
class operator TMatrix3.Multiply(const A: TVector3; const B: TMatrix3): TVector3; external LIB_FASTMATH name 'vector3_mul_matrix3';
521
class operator TMatrix3.Multiply(const A, B: TMatrix3): TMatrix3; external LIB_FASTMATH name 'matrix3_mul_matrix3';
522

523
class operator TMatrix3.Negative(const A: TMatrix3): TMatrix3; external LIB_FASTMATH name 'matrix3_negative';
524

525
procedure TMatrix3.SetTransposed; external LIB_FASTMATH name 'matrix3_set_transposed';
526

527
class operator TMatrix3.Subtract(const A: TMatrix3; const B: Single): TMatrix3; external LIB_FASTMATH name 'matrix3_sub_single';
528
class operator TMatrix3.Subtract(const A: Single; const B: TMatrix3): TMatrix3; external LIB_FASTMATH name 'single_sub_matrix3';
529
class operator TMatrix3.Subtract(const A, B: TMatrix3): TMatrix3; external LIB_FASTMATH name 'matrix3_sub_matrix3';
530

531
function TMatrix3.Transpose: TMatrix3; external LIB_FASTMATH name 'matrix3_transpose';
532

533
{ TMatrix 4 }
534

535
class operator TMatrix4.Add(const A: TMatrix4; const B: Single): TMatrix4; external LIB_FASTMATH name 'matrix4_add_single';
536
class operator TMatrix4.Add(const A: Single; const B: TMatrix4): TMatrix4; external LIB_FASTMATH name 'single_add_matrix4';
537
class operator TMatrix4.Add(const A, B: TMatrix4): TMatrix4; external LIB_FASTMATH name 'matrix4_add_matrix4';
538

539
function TMatrix4.CompMult(const AOther: TMatrix4): TMatrix4; external LIB_FASTMATH name 'matrix4_comp_mult';
540

541
class operator TMatrix4.Divide(const A: TMatrix4; const B: Single): TMatrix4; external LIB_FASTMATH name 'matrix4_div_single';
542
class operator TMatrix4.Divide(const A: Single; const B: TMatrix4): TMatrix4; external LIB_FASTMATH name 'single_div_matrix4';
543

544
function TMatrix4.Inverse: TMatrix4; external LIB_FASTMATH name 'matrix4_inverse';
545
procedure TMatrix4.SetInversed; external LIB_FASTMATH name 'matrix4_set_inversed';
546

547
class operator TMatrix4.Multiply(const A: TMatrix4; const B: Single): TMatrix4; external LIB_FASTMATH name 'matrix4_mul_single';
548
class operator TMatrix4.Multiply(const A: Single; const B: TMatrix4): TMatrix4; external LIB_FASTMATH name 'single_mul_matrix4';
549
class operator TMatrix4.Multiply(const A: TMatrix4; const B: TVector4): TVector4; external LIB_FASTMATH name 'matrix4_mul_vector4';
550
class operator TMatrix4.Multiply(const A: TVector4; const B: TMatrix4): TVector4; external LIB_FASTMATH name 'vector4_mul_matrix4';
551
class operator TMatrix4.Multiply(const A, B: TMatrix4): TMatrix4; external LIB_FASTMATH name 'matrix4_mul_matrix4';
552

553
class operator TMatrix4.Negative(const A: TMatrix4): TMatrix4; external LIB_FASTMATH name 'matrix4_negative';
554

555
class operator TMatrix4.Subtract(const A: TMatrix4; const B: Single): TMatrix4; external LIB_FASTMATH name 'matrix4_sub_single';
556
class operator TMatrix4.Subtract(const A: Single; const B: TMatrix4): TMatrix4; external LIB_FASTMATH name 'single_sub_matrix4';
557
class operator TMatrix4.Subtract(const A, B: TMatrix4): TMatrix4; external LIB_FASTMATH name 'matrix4_sub_matrix4';
558

559
function TMatrix4.Transpose: TMatrix4; external LIB_FASTMATH name 'matrix4_transpose';
560
procedure TMatrix4.SetTransposed; external LIB_FASTMATH name 'matrix4_set_transposed';
561

562