raylib-bindings 0.5.2 → 0.5.3

Sign up to get free protection for your applications and to get access to all the features.
data/lib/raymath.rb CHANGED
@@ -41,673 +41,785 @@ module Raylib
41
41
  def self.setup_raymath_symbols
42
42
  entries = [
43
43
 
44
- # Clamp
45
- # @param value [float]
46
- # @param min [float]
47
- # @param max [float]
48
- # @return [float]
44
+ # @!method Clamp(value, min, max)
45
+ # Clamp
46
+ # @param value [float]
47
+ # @param min [float]
48
+ # @param max [float]
49
+ # @return [float]
49
50
  [:Clamp, :Clamp, [:float, :float, :float], :float],
50
51
 
51
- # Lerp
52
- # @param start [float]
53
- # @param end [float]
54
- # @param amount [float]
55
- # @return [float]
52
+ # @!method Lerp(start, end, amount)
53
+ # Lerp
54
+ # @param start [float]
55
+ # @param end [float]
56
+ # @param amount [float]
57
+ # @return [float]
56
58
  [:Lerp, :Lerp, [:float, :float, :float], :float],
57
59
 
58
- # Normalize
59
- # @param value [float]
60
- # @param start [float]
61
- # @param end [float]
62
- # @return [float]
60
+ # @!method Normalize(value, start, end)
61
+ # Normalize
62
+ # @param value [float]
63
+ # @param start [float]
64
+ # @param end [float]
65
+ # @return [float]
63
66
  [:Normalize, :Normalize, [:float, :float, :float], :float],
64
67
 
65
- # Remap
66
- # @param value [float]
67
- # @param inputStart [float]
68
- # @param inputEnd [float]
69
- # @param outputStart [float]
70
- # @param outputEnd [float]
71
- # @return [float]
68
+ # @!method Remap(value, inputStart, inputEnd, outputStart, outputEnd)
69
+ # Remap
70
+ # @param value [float]
71
+ # @param inputStart [float]
72
+ # @param inputEnd [float]
73
+ # @param outputStart [float]
74
+ # @param outputEnd [float]
75
+ # @return [float]
72
76
  [:Remap, :Remap, [:float, :float, :float, :float, :float], :float],
73
77
 
74
- # Wrap
75
- # @param value [float]
76
- # @param min [float]
77
- # @param max [float]
78
- # @return [float]
78
+ # @!method Wrap(value, min, max)
79
+ # Wrap
80
+ # @param value [float]
81
+ # @param min [float]
82
+ # @param max [float]
83
+ # @return [float]
79
84
  [:Wrap, :Wrap, [:float, :float, :float], :float],
80
85
 
81
- # FloatEquals
82
- # @param x [float]
83
- # @param y [float]
84
- # @return [int]
86
+ # @!method FloatEquals(x, y)
87
+ # FloatEquals
88
+ # @param x [float]
89
+ # @param y [float]
90
+ # @return [int]
85
91
  [:FloatEquals, :FloatEquals, [:float, :float], :int],
86
92
 
87
- # Vector2Zero
88
- # @return [Vector2]
93
+ # @!method Vector2Zero()
94
+ # Vector2Zero
95
+ # @return [Vector2]
89
96
  [:Vector2Zero, :Vector2Zero, [], Vector2.by_value],
90
97
 
91
- # Vector2One
92
- # @return [Vector2]
98
+ # @!method Vector2One()
99
+ # Vector2One
100
+ # @return [Vector2]
93
101
  [:Vector2One, :Vector2One, [], Vector2.by_value],
94
102
 
95
- # Vector2Add
96
- # @param v1 [Vector2]
97
- # @param v2 [Vector2]
98
- # @return [Vector2]
103
+ # @!method Vector2Add(v1, v2)
104
+ # Vector2Add
105
+ # @param v1 [Vector2]
106
+ # @param v2 [Vector2]
107
+ # @return [Vector2]
99
108
  [:Vector2Add, :Vector2Add, [Vector2.by_value, Vector2.by_value], Vector2.by_value],
100
109
 
101
- # Vector2AddValue
102
- # @param v [Vector2]
103
- # @param add [float]
104
- # @return [Vector2]
110
+ # @!method Vector2AddValue(v, add)
111
+ # Vector2AddValue
112
+ # @param v [Vector2]
113
+ # @param add [float]
114
+ # @return [Vector2]
105
115
  [:Vector2AddValue, :Vector2AddValue, [Vector2.by_value, :float], Vector2.by_value],
106
116
 
107
- # Vector2Subtract
108
- # @param v1 [Vector2]
109
- # @param v2 [Vector2]
110
- # @return [Vector2]
117
+ # @!method Vector2Subtract(v1, v2)
118
+ # Vector2Subtract
119
+ # @param v1 [Vector2]
120
+ # @param v2 [Vector2]
121
+ # @return [Vector2]
111
122
  [:Vector2Subtract, :Vector2Subtract, [Vector2.by_value, Vector2.by_value], Vector2.by_value],
112
123
 
113
- # Vector2SubtractValue
114
- # @param v [Vector2]
115
- # @param sub [float]
116
- # @return [Vector2]
124
+ # @!method Vector2SubtractValue(v, sub)
125
+ # Vector2SubtractValue
126
+ # @param v [Vector2]
127
+ # @param sub [float]
128
+ # @return [Vector2]
117
129
  [:Vector2SubtractValue, :Vector2SubtractValue, [Vector2.by_value, :float], Vector2.by_value],
118
130
 
119
- # Vector2Length
120
- # @param v [Vector2]
121
- # @return [float]
131
+ # @!method Vector2Length(v)
132
+ # Vector2Length
133
+ # @param v [Vector2]
134
+ # @return [float]
122
135
  [:Vector2Length, :Vector2Length, [Vector2.by_value], :float],
123
136
 
124
- # Vector2LengthSqr
125
- # @param v [Vector2]
126
- # @return [float]
137
+ # @!method Vector2LengthSqr(v)
138
+ # Vector2LengthSqr
139
+ # @param v [Vector2]
140
+ # @return [float]
127
141
  [:Vector2LengthSqr, :Vector2LengthSqr, [Vector2.by_value], :float],
128
142
 
129
- # Vector2DotProduct
130
- # @param v1 [Vector2]
131
- # @param v2 [Vector2]
132
- # @return [float]
143
+ # @!method Vector2DotProduct(v1, v2)
144
+ # Vector2DotProduct
145
+ # @param v1 [Vector2]
146
+ # @param v2 [Vector2]
147
+ # @return [float]
133
148
  [:Vector2DotProduct, :Vector2DotProduct, [Vector2.by_value, Vector2.by_value], :float],
134
149
 
135
- # Vector2Distance
136
- # @param v1 [Vector2]
137
- # @param v2 [Vector2]
138
- # @return [float]
150
+ # @!method Vector2Distance(v1, v2)
151
+ # Vector2Distance
152
+ # @param v1 [Vector2]
153
+ # @param v2 [Vector2]
154
+ # @return [float]
139
155
  [:Vector2Distance, :Vector2Distance, [Vector2.by_value, Vector2.by_value], :float],
140
156
 
141
- # Vector2DistanceSqr
142
- # @param v1 [Vector2]
143
- # @param v2 [Vector2]
144
- # @return [float]
157
+ # @!method Vector2DistanceSqr(v1, v2)
158
+ # Vector2DistanceSqr
159
+ # @param v1 [Vector2]
160
+ # @param v2 [Vector2]
161
+ # @return [float]
145
162
  [:Vector2DistanceSqr, :Vector2DistanceSqr, [Vector2.by_value, Vector2.by_value], :float],
146
163
 
147
- # Vector2Angle
148
- # @param v1 [Vector2]
149
- # @param v2 [Vector2]
150
- # @return [float]
164
+ # @!method Vector2Angle(v1, v2)
165
+ # Vector2Angle
166
+ # @param v1 [Vector2]
167
+ # @param v2 [Vector2]
168
+ # @return [float]
151
169
  [:Vector2Angle, :Vector2Angle, [Vector2.by_value, Vector2.by_value], :float],
152
170
 
153
- # Vector2LineAngle
154
- # @param start [Vector2]
155
- # @param end [Vector2]
156
- # @return [float]
171
+ # @!method Vector2LineAngle(start, end)
172
+ # Vector2LineAngle
173
+ # @param start [Vector2]
174
+ # @param end [Vector2]
175
+ # @return [float]
157
176
  [:Vector2LineAngle, :Vector2LineAngle, [Vector2.by_value, Vector2.by_value], :float],
158
177
 
159
- # Vector2Scale
160
- # @param v [Vector2]
161
- # @param scale [float]
162
- # @return [Vector2]
178
+ # @!method Vector2Scale(v, scale)
179
+ # Vector2Scale
180
+ # @param v [Vector2]
181
+ # @param scale [float]
182
+ # @return [Vector2]
163
183
  [:Vector2Scale, :Vector2Scale, [Vector2.by_value, :float], Vector2.by_value],
164
184
 
165
- # Vector2Multiply
166
- # @param v1 [Vector2]
167
- # @param v2 [Vector2]
168
- # @return [Vector2]
185
+ # @!method Vector2Multiply(v1, v2)
186
+ # Vector2Multiply
187
+ # @param v1 [Vector2]
188
+ # @param v2 [Vector2]
189
+ # @return [Vector2]
169
190
  [:Vector2Multiply, :Vector2Multiply, [Vector2.by_value, Vector2.by_value], Vector2.by_value],
170
191
 
171
- # Vector2Negate
172
- # @param v [Vector2]
173
- # @return [Vector2]
192
+ # @!method Vector2Negate(v)
193
+ # Vector2Negate
194
+ # @param v [Vector2]
195
+ # @return [Vector2]
174
196
  [:Vector2Negate, :Vector2Negate, [Vector2.by_value], Vector2.by_value],
175
197
 
176
- # Vector2Divide
177
- # @param v1 [Vector2]
178
- # @param v2 [Vector2]
179
- # @return [Vector2]
198
+ # @!method Vector2Divide(v1, v2)
199
+ # Vector2Divide
200
+ # @param v1 [Vector2]
201
+ # @param v2 [Vector2]
202
+ # @return [Vector2]
180
203
  [:Vector2Divide, :Vector2Divide, [Vector2.by_value, Vector2.by_value], Vector2.by_value],
181
204
 
182
- # Vector2Normalize
183
- # @param v [Vector2]
184
- # @return [Vector2]
205
+ # @!method Vector2Normalize(v)
206
+ # Vector2Normalize
207
+ # @param v [Vector2]
208
+ # @return [Vector2]
185
209
  [:Vector2Normalize, :Vector2Normalize, [Vector2.by_value], Vector2.by_value],
186
210
 
187
- # Vector2Transform
188
- # @param v [Vector2]
189
- # @param mat [Matrix]
190
- # @return [Vector2]
211
+ # @!method Vector2Transform(v, mat)
212
+ # Vector2Transform
213
+ # @param v [Vector2]
214
+ # @param mat [Matrix]
215
+ # @return [Vector2]
191
216
  [:Vector2Transform, :Vector2Transform, [Vector2.by_value, Matrix.by_value], Vector2.by_value],
192
217
 
193
- # Vector2Lerp
194
- # @param v1 [Vector2]
195
- # @param v2 [Vector2]
196
- # @param amount [float]
197
- # @return [Vector2]
218
+ # @!method Vector2Lerp(v1, v2, amount)
219
+ # Vector2Lerp
220
+ # @param v1 [Vector2]
221
+ # @param v2 [Vector2]
222
+ # @param amount [float]
223
+ # @return [Vector2]
198
224
  [:Vector2Lerp, :Vector2Lerp, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],
199
225
 
200
- # Vector2Reflect
201
- # @param v [Vector2]
202
- # @param normal [Vector2]
203
- # @return [Vector2]
226
+ # @!method Vector2Reflect(v, normal)
227
+ # Vector2Reflect
228
+ # @param v [Vector2]
229
+ # @param normal [Vector2]
230
+ # @return [Vector2]
204
231
  [:Vector2Reflect, :Vector2Reflect, [Vector2.by_value, Vector2.by_value], Vector2.by_value],
205
232
 
206
- # Vector2Rotate
207
- # @param v [Vector2]
208
- # @param angle [float]
209
- # @return [Vector2]
233
+ # @!method Vector2Rotate(v, angle)
234
+ # Vector2Rotate
235
+ # @param v [Vector2]
236
+ # @param angle [float]
237
+ # @return [Vector2]
210
238
  [:Vector2Rotate, :Vector2Rotate, [Vector2.by_value, :float], Vector2.by_value],
211
239
 
212
- # Vector2MoveTowards
213
- # @param v [Vector2]
214
- # @param target [Vector2]
215
- # @param maxDistance [float]
216
- # @return [Vector2]
240
+ # @!method Vector2MoveTowards(v, target, maxDistance)
241
+ # Vector2MoveTowards
242
+ # @param v [Vector2]
243
+ # @param target [Vector2]
244
+ # @param maxDistance [float]
245
+ # @return [Vector2]
217
246
  [:Vector2MoveTowards, :Vector2MoveTowards, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],
218
247
 
219
- # Vector2Invert
220
- # @param v [Vector2]
221
- # @return [Vector2]
248
+ # @!method Vector2Invert(v)
249
+ # Vector2Invert
250
+ # @param v [Vector2]
251
+ # @return [Vector2]
222
252
  [:Vector2Invert, :Vector2Invert, [Vector2.by_value], Vector2.by_value],
223
253
 
224
- # Vector2Clamp
225
- # @param v [Vector2]
226
- # @param min [Vector2]
227
- # @param max [Vector2]
228
- # @return [Vector2]
254
+ # @!method Vector2Clamp(v, min, max)
255
+ # Vector2Clamp
256
+ # @param v [Vector2]
257
+ # @param min [Vector2]
258
+ # @param max [Vector2]
259
+ # @return [Vector2]
229
260
  [:Vector2Clamp, :Vector2Clamp, [Vector2.by_value, Vector2.by_value, Vector2.by_value], Vector2.by_value],
230
261
 
231
- # Vector2ClampValue
232
- # @param v [Vector2]
233
- # @param min [float]
234
- # @param max [float]
235
- # @return [Vector2]
262
+ # @!method Vector2ClampValue(v, min, max)
263
+ # Vector2ClampValue
264
+ # @param v [Vector2]
265
+ # @param min [float]
266
+ # @param max [float]
267
+ # @return [Vector2]
236
268
  [:Vector2ClampValue, :Vector2ClampValue, [Vector2.by_value, :float, :float], Vector2.by_value],
237
269
 
238
- # Vector2Equals
239
- # @param p [Vector2]
240
- # @param q [Vector2]
241
- # @return [int]
270
+ # @!method Vector2Equals(p, q)
271
+ # Vector2Equals
272
+ # @param p [Vector2]
273
+ # @param q [Vector2]
274
+ # @return [int]
242
275
  [:Vector2Equals, :Vector2Equals, [Vector2.by_value, Vector2.by_value], :int],
243
276
 
244
- # Vector3Zero
245
- # @return [Vector3]
277
+ # @!method Vector3Zero()
278
+ # Vector3Zero
279
+ # @return [Vector3]
246
280
  [:Vector3Zero, :Vector3Zero, [], Vector3.by_value],
247
281
 
248
- # Vector3One
249
- # @return [Vector3]
282
+ # @!method Vector3One()
283
+ # Vector3One
284
+ # @return [Vector3]
250
285
  [:Vector3One, :Vector3One, [], Vector3.by_value],
251
286
 
252
- # Vector3Add
253
- # @param v1 [Vector3]
254
- # @param v2 [Vector3]
255
- # @return [Vector3]
287
+ # @!method Vector3Add(v1, v2)
288
+ # Vector3Add
289
+ # @param v1 [Vector3]
290
+ # @param v2 [Vector3]
291
+ # @return [Vector3]
256
292
  [:Vector3Add, :Vector3Add, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
257
293
 
258
- # Vector3AddValue
259
- # @param v [Vector3]
260
- # @param add [float]
261
- # @return [Vector3]
294
+ # @!method Vector3AddValue(v, add)
295
+ # Vector3AddValue
296
+ # @param v [Vector3]
297
+ # @param add [float]
298
+ # @return [Vector3]
262
299
  [:Vector3AddValue, :Vector3AddValue, [Vector3.by_value, :float], Vector3.by_value],
263
300
 
264
- # Vector3Subtract
265
- # @param v1 [Vector3]
266
- # @param v2 [Vector3]
267
- # @return [Vector3]
301
+ # @!method Vector3Subtract(v1, v2)
302
+ # Vector3Subtract
303
+ # @param v1 [Vector3]
304
+ # @param v2 [Vector3]
305
+ # @return [Vector3]
268
306
  [:Vector3Subtract, :Vector3Subtract, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
269
307
 
270
- # Vector3SubtractValue
271
- # @param v [Vector3]
272
- # @param sub [float]
273
- # @return [Vector3]
308
+ # @!method Vector3SubtractValue(v, sub)
309
+ # Vector3SubtractValue
310
+ # @param v [Vector3]
311
+ # @param sub [float]
312
+ # @return [Vector3]
274
313
  [:Vector3SubtractValue, :Vector3SubtractValue, [Vector3.by_value, :float], Vector3.by_value],
275
314
 
276
- # Vector3Scale
277
- # @param v [Vector3]
278
- # @param scalar [float]
279
- # @return [Vector3]
315
+ # @!method Vector3Scale(v, scalar)
316
+ # Vector3Scale
317
+ # @param v [Vector3]
318
+ # @param scalar [float]
319
+ # @return [Vector3]
280
320
  [:Vector3Scale, :Vector3Scale, [Vector3.by_value, :float], Vector3.by_value],
281
321
 
282
- # Vector3Multiply
283
- # @param v1 [Vector3]
284
- # @param v2 [Vector3]
285
- # @return [Vector3]
322
+ # @!method Vector3Multiply(v1, v2)
323
+ # Vector3Multiply
324
+ # @param v1 [Vector3]
325
+ # @param v2 [Vector3]
326
+ # @return [Vector3]
286
327
  [:Vector3Multiply, :Vector3Multiply, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
287
328
 
288
- # Vector3CrossProduct
289
- # @param v1 [Vector3]
290
- # @param v2 [Vector3]
291
- # @return [Vector3]
329
+ # @!method Vector3CrossProduct(v1, v2)
330
+ # Vector3CrossProduct
331
+ # @param v1 [Vector3]
332
+ # @param v2 [Vector3]
333
+ # @return [Vector3]
292
334
  [:Vector3CrossProduct, :Vector3CrossProduct, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
293
335
 
294
- # Vector3Perpendicular
295
- # @param v [Vector3]
296
- # @return [Vector3]
336
+ # @!method Vector3Perpendicular(v)
337
+ # Vector3Perpendicular
338
+ # @param v [Vector3]
339
+ # @return [Vector3]
297
340
  [:Vector3Perpendicular, :Vector3Perpendicular, [Vector3.by_value], Vector3.by_value],
298
341
 
299
- # Vector3Length
300
- # @param v [const Vector3]
301
- # @return [float]
342
+ # @!method Vector3Length(v)
343
+ # Vector3Length
344
+ # @param v [const Vector3]
345
+ # @return [float]
302
346
  [:Vector3Length, :Vector3Length, [Vector3.by_value], :float],
303
347
 
304
- # Vector3LengthSqr
305
- # @param v [const Vector3]
306
- # @return [float]
348
+ # @!method Vector3LengthSqr(v)
349
+ # Vector3LengthSqr
350
+ # @param v [const Vector3]
351
+ # @return [float]
307
352
  [:Vector3LengthSqr, :Vector3LengthSqr, [Vector3.by_value], :float],
308
353
 
309
- # Vector3DotProduct
310
- # @param v1 [Vector3]
311
- # @param v2 [Vector3]
312
- # @return [float]
354
+ # @!method Vector3DotProduct(v1, v2)
355
+ # Vector3DotProduct
356
+ # @param v1 [Vector3]
357
+ # @param v2 [Vector3]
358
+ # @return [float]
313
359
  [:Vector3DotProduct, :Vector3DotProduct, [Vector3.by_value, Vector3.by_value], :float],
314
360
 
315
- # Vector3Distance
316
- # @param v1 [Vector3]
317
- # @param v2 [Vector3]
318
- # @return [float]
361
+ # @!method Vector3Distance(v1, v2)
362
+ # Vector3Distance
363
+ # @param v1 [Vector3]
364
+ # @param v2 [Vector3]
365
+ # @return [float]
319
366
  [:Vector3Distance, :Vector3Distance, [Vector3.by_value, Vector3.by_value], :float],
320
367
 
321
- # Vector3DistanceSqr
322
- # @param v1 [Vector3]
323
- # @param v2 [Vector3]
324
- # @return [float]
368
+ # @!method Vector3DistanceSqr(v1, v2)
369
+ # Vector3DistanceSqr
370
+ # @param v1 [Vector3]
371
+ # @param v2 [Vector3]
372
+ # @return [float]
325
373
  [:Vector3DistanceSqr, :Vector3DistanceSqr, [Vector3.by_value, Vector3.by_value], :float],
326
374
 
327
- # Vector3Angle
328
- # @param v1 [Vector3]
329
- # @param v2 [Vector3]
330
- # @return [float]
375
+ # @!method Vector3Angle(v1, v2)
376
+ # Vector3Angle
377
+ # @param v1 [Vector3]
378
+ # @param v2 [Vector3]
379
+ # @return [float]
331
380
  [:Vector3Angle, :Vector3Angle, [Vector3.by_value, Vector3.by_value], :float],
332
381
 
333
- # Vector3Negate
334
- # @param v [Vector3]
335
- # @return [Vector3]
382
+ # @!method Vector3Negate(v)
383
+ # Vector3Negate
384
+ # @param v [Vector3]
385
+ # @return [Vector3]
336
386
  [:Vector3Negate, :Vector3Negate, [Vector3.by_value], Vector3.by_value],
337
387
 
338
- # Vector3Divide
339
- # @param v1 [Vector3]
340
- # @param v2 [Vector3]
341
- # @return [Vector3]
388
+ # @!method Vector3Divide(v1, v2)
389
+ # Vector3Divide
390
+ # @param v1 [Vector3]
391
+ # @param v2 [Vector3]
392
+ # @return [Vector3]
342
393
  [:Vector3Divide, :Vector3Divide, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
343
394
 
344
- # Vector3Normalize
345
- # @param v [Vector3]
346
- # @return [Vector3]
395
+ # @!method Vector3Normalize(v)
396
+ # Vector3Normalize
397
+ # @param v [Vector3]
398
+ # @return [Vector3]
347
399
  [:Vector3Normalize, :Vector3Normalize, [Vector3.by_value], Vector3.by_value],
348
400
 
349
- # Vector3OrthoNormalize
350
- # @param v1 [Vector3 *]
351
- # @param v2 [Vector3 *]
352
- # @return [void]
401
+ # @!method Vector3OrthoNormalize(v1, v2)
402
+ # Vector3OrthoNormalize
403
+ # @param v1 [Vector3 *]
404
+ # @param v2 [Vector3 *]
405
+ # @return [void]
353
406
  [:Vector3OrthoNormalize, :Vector3OrthoNormalize, [:pointer, :pointer], :void],
354
407
 
355
- # Vector3Transform
356
- # @param v [Vector3]
357
- # @param mat [Matrix]
358
- # @return [Vector3]
408
+ # @!method Vector3Transform(v, mat)
409
+ # Vector3Transform
410
+ # @param v [Vector3]
411
+ # @param mat [Matrix]
412
+ # @return [Vector3]
359
413
  [:Vector3Transform, :Vector3Transform, [Vector3.by_value, Matrix.by_value], Vector3.by_value],
360
414
 
361
- # Vector3RotateByQuaternion
362
- # @param v [Vector3]
363
- # @param q [Quaternion]
364
- # @return [Vector3]
415
+ # @!method Vector3RotateByQuaternion(v, q)
416
+ # Vector3RotateByQuaternion
417
+ # @param v [Vector3]
418
+ # @param q [Quaternion]
419
+ # @return [Vector3]
365
420
  [:Vector3RotateByQuaternion, :Vector3RotateByQuaternion, [Vector3.by_value, Quaternion.by_value], Vector3.by_value],
366
421
 
367
- # Vector3RotateByAxisAngle
368
- # @param v [Vector3]
369
- # @param axis [Vector3]
370
- # @param angle [float]
371
- # @return [Vector3]
422
+ # @!method Vector3RotateByAxisAngle(v, axis, angle)
423
+ # Vector3RotateByAxisAngle
424
+ # @param v [Vector3]
425
+ # @param axis [Vector3]
426
+ # @param angle [float]
427
+ # @return [Vector3]
372
428
  [:Vector3RotateByAxisAngle, :Vector3RotateByAxisAngle, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],
373
429
 
374
- # Vector3Lerp
375
- # @param v1 [Vector3]
376
- # @param v2 [Vector3]
377
- # @param amount [float]
378
- # @return [Vector3]
430
+ # @!method Vector3Lerp(v1, v2, amount)
431
+ # Vector3Lerp
432
+ # @param v1 [Vector3]
433
+ # @param v2 [Vector3]
434
+ # @param amount [float]
435
+ # @return [Vector3]
379
436
  [:Vector3Lerp, :Vector3Lerp, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],
380
437
 
381
- # Vector3Reflect
382
- # @param v [Vector3]
383
- # @param normal [Vector3]
384
- # @return [Vector3]
438
+ # @!method Vector3Reflect(v, normal)
439
+ # Vector3Reflect
440
+ # @param v [Vector3]
441
+ # @param normal [Vector3]
442
+ # @return [Vector3]
385
443
  [:Vector3Reflect, :Vector3Reflect, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
386
444
 
387
- # Vector3Min
388
- # @param v1 [Vector3]
389
- # @param v2 [Vector3]
390
- # @return [Vector3]
445
+ # @!method Vector3Min(v1, v2)
446
+ # Vector3Min
447
+ # @param v1 [Vector3]
448
+ # @param v2 [Vector3]
449
+ # @return [Vector3]
391
450
  [:Vector3Min, :Vector3Min, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
392
451
 
393
- # Vector3Max
394
- # @param v1 [Vector3]
395
- # @param v2 [Vector3]
396
- # @return [Vector3]
452
+ # @!method Vector3Max(v1, v2)
453
+ # Vector3Max
454
+ # @param v1 [Vector3]
455
+ # @param v2 [Vector3]
456
+ # @return [Vector3]
397
457
  [:Vector3Max, :Vector3Max, [Vector3.by_value, Vector3.by_value], Vector3.by_value],
398
458
 
399
- # Vector3Barycenter
400
- # @param p [Vector3]
401
- # @param a [Vector3]
402
- # @param b [Vector3]
403
- # @param c [Vector3]
404
- # @return [Vector3]
459
+ # @!method Vector3Barycenter(p, a, b, c)
460
+ # Vector3Barycenter
461
+ # @param p [Vector3]
462
+ # @param a [Vector3]
463
+ # @param b [Vector3]
464
+ # @param c [Vector3]
465
+ # @return [Vector3]
405
466
  [:Vector3Barycenter, :Vector3Barycenter, [Vector3.by_value, Vector3.by_value, Vector3.by_value, Vector3.by_value], Vector3.by_value],
406
467
 
407
- # Vector3Unproject
408
- # @param source [Vector3]
409
- # @param projection [Matrix]
410
- # @param view [Matrix]
411
- # @return [Vector3]
468
+ # @!method Vector3Unproject(source, projection, view)
469
+ # Vector3Unproject
470
+ # @param source [Vector3]
471
+ # @param projection [Matrix]
472
+ # @param view [Matrix]
473
+ # @return [Vector3]
412
474
  [:Vector3Unproject, :Vector3Unproject, [Vector3.by_value, Matrix.by_value, Matrix.by_value], Vector3.by_value],
413
475
 
414
- # Vector3ToFloatV
415
- # @param v [Vector3]
416
- # @return [float3]
476
+ # @!method Vector3ToFloatV(v)
477
+ # Vector3ToFloatV
478
+ # @param v [Vector3]
479
+ # @return [float3]
417
480
  [:Vector3ToFloatV, :Vector3ToFloatV, [Vector3.by_value], Float3.by_value],
418
481
 
419
- # Vector3Invert
420
- # @param v [Vector3]
421
- # @return [Vector3]
482
+ # @!method Vector3Invert(v)
483
+ # Vector3Invert
484
+ # @param v [Vector3]
485
+ # @return [Vector3]
422
486
  [:Vector3Invert, :Vector3Invert, [Vector3.by_value], Vector3.by_value],
423
487
 
424
- # Vector3Clamp
425
- # @param v [Vector3]
426
- # @param min [Vector3]
427
- # @param max [Vector3]
428
- # @return [Vector3]
488
+ # @!method Vector3Clamp(v, min, max)
489
+ # Vector3Clamp
490
+ # @param v [Vector3]
491
+ # @param min [Vector3]
492
+ # @param max [Vector3]
493
+ # @return [Vector3]
429
494
  [:Vector3Clamp, :Vector3Clamp, [Vector3.by_value, Vector3.by_value, Vector3.by_value], Vector3.by_value],
430
495
 
431
- # Vector3ClampValue
432
- # @param v [Vector3]
433
- # @param min [float]
434
- # @param max [float]
435
- # @return [Vector3]
496
+ # @!method Vector3ClampValue(v, min, max)
497
+ # Vector3ClampValue
498
+ # @param v [Vector3]
499
+ # @param min [float]
500
+ # @param max [float]
501
+ # @return [Vector3]
436
502
  [:Vector3ClampValue, :Vector3ClampValue, [Vector3.by_value, :float, :float], Vector3.by_value],
437
503
 
438
- # Vector3Equals
439
- # @param p [Vector3]
440
- # @param q [Vector3]
441
- # @return [int]
504
+ # @!method Vector3Equals(p, q)
505
+ # Vector3Equals
506
+ # @param p [Vector3]
507
+ # @param q [Vector3]
508
+ # @return [int]
442
509
  [:Vector3Equals, :Vector3Equals, [Vector3.by_value, Vector3.by_value], :int],
443
510
 
444
- # Vector3Refract
445
- # @param v [Vector3]
446
- # @param n [Vector3]
447
- # @param r [float]
448
- # @return [Vector3]
511
+ # @!method Vector3Refract(v, n, r)
512
+ # Vector3Refract
513
+ # @param v [Vector3]
514
+ # @param n [Vector3]
515
+ # @param r [float]
516
+ # @return [Vector3]
449
517
  [:Vector3Refract, :Vector3Refract, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],
450
518
 
451
- # MatrixDeterminant
452
- # @param mat [Matrix]
453
- # @return [float]
519
+ # @!method MatrixDeterminant(mat)
520
+ # MatrixDeterminant
521
+ # @param mat [Matrix]
522
+ # @return [float]
454
523
  [:MatrixDeterminant, :MatrixDeterminant, [Matrix.by_value], :float],
455
524
 
456
- # MatrixTrace
457
- # @param mat [Matrix]
458
- # @return [float]
525
+ # @!method MatrixTrace(mat)
526
+ # MatrixTrace
527
+ # @param mat [Matrix]
528
+ # @return [float]
459
529
  [:MatrixTrace, :MatrixTrace, [Matrix.by_value], :float],
460
530
 
461
- # MatrixTranspose
462
- # @param mat [Matrix]
463
- # @return [Matrix]
531
+ # @!method MatrixTranspose(mat)
532
+ # MatrixTranspose
533
+ # @param mat [Matrix]
534
+ # @return [Matrix]
464
535
  [:MatrixTranspose, :MatrixTranspose, [Matrix.by_value], Matrix.by_value],
465
536
 
466
- # MatrixInvert
467
- # @param mat [Matrix]
468
- # @return [Matrix]
537
+ # @!method MatrixInvert(mat)
538
+ # MatrixInvert
539
+ # @param mat [Matrix]
540
+ # @return [Matrix]
469
541
  [:MatrixInvert, :MatrixInvert, [Matrix.by_value], Matrix.by_value],
470
542
 
471
- # MatrixIdentity
472
- # @return [Matrix]
543
+ # @!method MatrixIdentity()
544
+ # MatrixIdentity
545
+ # @return [Matrix]
473
546
  [:MatrixIdentity, :MatrixIdentity, [], Matrix.by_value],
474
547
 
475
- # MatrixAdd
476
- # @param left [Matrix]
477
- # @param right [Matrix]
478
- # @return [Matrix]
548
+ # @!method MatrixAdd(left, right)
549
+ # MatrixAdd
550
+ # @param left [Matrix]
551
+ # @param right [Matrix]
552
+ # @return [Matrix]
479
553
  [:MatrixAdd, :MatrixAdd, [Matrix.by_value, Matrix.by_value], Matrix.by_value],
480
554
 
481
- # MatrixSubtract
482
- # @param left [Matrix]
483
- # @param right [Matrix]
484
- # @return [Matrix]
555
+ # @!method MatrixSubtract(left, right)
556
+ # MatrixSubtract
557
+ # @param left [Matrix]
558
+ # @param right [Matrix]
559
+ # @return [Matrix]
485
560
  [:MatrixSubtract, :MatrixSubtract, [Matrix.by_value, Matrix.by_value], Matrix.by_value],
486
561
 
487
- # MatrixMultiply
488
- # @param left [Matrix]
489
- # @param right [Matrix]
490
- # @return [Matrix]
562
+ # @!method MatrixMultiply(left, right)
563
+ # MatrixMultiply
564
+ # @param left [Matrix]
565
+ # @param right [Matrix]
566
+ # @return [Matrix]
491
567
  [:MatrixMultiply, :MatrixMultiply, [Matrix.by_value, Matrix.by_value], Matrix.by_value],
492
568
 
493
- # MatrixTranslate
494
- # @param x [float]
495
- # @param y [float]
496
- # @param z [float]
497
- # @return [Matrix]
569
+ # @!method MatrixTranslate(x, y, z)
570
+ # MatrixTranslate
571
+ # @param x [float]
572
+ # @param y [float]
573
+ # @param z [float]
574
+ # @return [Matrix]
498
575
  [:MatrixTranslate, :MatrixTranslate, [:float, :float, :float], Matrix.by_value],
499
576
 
500
- # MatrixRotate
501
- # @param axis [Vector3]
502
- # @param angle [float]
503
- # @return [Matrix]
577
+ # @!method MatrixRotate(axis, angle)
578
+ # MatrixRotate
579
+ # @param axis [Vector3]
580
+ # @param angle [float]
581
+ # @return [Matrix]
504
582
  [:MatrixRotate, :MatrixRotate, [Vector3.by_value, :float], Matrix.by_value],
505
583
 
506
- # MatrixRotateX
507
- # @param angle [float]
508
- # @return [Matrix]
584
+ # @!method MatrixRotateX(angle)
585
+ # MatrixRotateX
586
+ # @param angle [float]
587
+ # @return [Matrix]
509
588
  [:MatrixRotateX, :MatrixRotateX, [:float], Matrix.by_value],
510
589
 
511
- # MatrixRotateY
512
- # @param angle [float]
513
- # @return [Matrix]
590
+ # @!method MatrixRotateY(angle)
591
+ # MatrixRotateY
592
+ # @param angle [float]
593
+ # @return [Matrix]
514
594
  [:MatrixRotateY, :MatrixRotateY, [:float], Matrix.by_value],
515
595
 
516
- # MatrixRotateZ
517
- # @param angle [float]
518
- # @return [Matrix]
596
+ # @!method MatrixRotateZ(angle)
597
+ # MatrixRotateZ
598
+ # @param angle [float]
599
+ # @return [Matrix]
519
600
  [:MatrixRotateZ, :MatrixRotateZ, [:float], Matrix.by_value],
520
601
 
521
- # MatrixRotateXYZ
522
- # @param angle [Vector3]
523
- # @return [Matrix]
602
+ # @!method MatrixRotateXYZ(angle)
603
+ # MatrixRotateXYZ
604
+ # @param angle [Vector3]
605
+ # @return [Matrix]
524
606
  [:MatrixRotateXYZ, :MatrixRotateXYZ, [Vector3.by_value], Matrix.by_value],
525
607
 
526
- # MatrixRotateZYX
527
- # @param angle [Vector3]
528
- # @return [Matrix]
608
+ # @!method MatrixRotateZYX(angle)
609
+ # MatrixRotateZYX
610
+ # @param angle [Vector3]
611
+ # @return [Matrix]
529
612
  [:MatrixRotateZYX, :MatrixRotateZYX, [Vector3.by_value], Matrix.by_value],
530
613
 
531
- # MatrixScale
532
- # @param x [float]
533
- # @param y [float]
534
- # @param z [float]
535
- # @return [Matrix]
614
+ # @!method MatrixScale(x, y, z)
615
+ # MatrixScale
616
+ # @param x [float]
617
+ # @param y [float]
618
+ # @param z [float]
619
+ # @return [Matrix]
536
620
  [:MatrixScale, :MatrixScale, [:float, :float, :float], Matrix.by_value],
537
621
 
538
- # MatrixFrustum
539
- # @param left [double]
540
- # @param right [double]
541
- # @param bottom [double]
542
- # @param top [double]
543
- # @param near [double]
544
- # @param far [double]
545
- # @return [Matrix]
622
+ # @!method MatrixFrustum(left, right, bottom, top, near, far)
623
+ # MatrixFrustum
624
+ # @param left [double]
625
+ # @param right [double]
626
+ # @param bottom [double]
627
+ # @param top [double]
628
+ # @param near [double]
629
+ # @param far [double]
630
+ # @return [Matrix]
546
631
  [:MatrixFrustum, :MatrixFrustum, [:double, :double, :double, :double, :double, :double], Matrix.by_value],
547
632
 
548
- # MatrixPerspective
549
- # @param fovy [double]
550
- # @param aspect [double]
551
- # @param near [double]
552
- # @param far [double]
553
- # @return [Matrix]
633
+ # @!method MatrixPerspective(fovy, aspect, near, far)
634
+ # MatrixPerspective
635
+ # @param fovy [double]
636
+ # @param aspect [double]
637
+ # @param near [double]
638
+ # @param far [double]
639
+ # @return [Matrix]
554
640
  [:MatrixPerspective, :MatrixPerspective, [:double, :double, :double, :double], Matrix.by_value],
555
641
 
556
- # MatrixOrtho
557
- # @param left [double]
558
- # @param right [double]
559
- # @param bottom [double]
560
- # @param top [double]
561
- # @param near [double]
562
- # @param far [double]
563
- # @return [Matrix]
642
+ # @!method MatrixOrtho(left, right, bottom, top, near, far)
643
+ # MatrixOrtho
644
+ # @param left [double]
645
+ # @param right [double]
646
+ # @param bottom [double]
647
+ # @param top [double]
648
+ # @param near [double]
649
+ # @param far [double]
650
+ # @return [Matrix]
564
651
  [:MatrixOrtho, :MatrixOrtho, [:double, :double, :double, :double, :double, :double], Matrix.by_value],
565
652
 
566
- # MatrixLookAt
567
- # @param eye [Vector3]
568
- # @param target [Vector3]
569
- # @param up [Vector3]
570
- # @return [Matrix]
653
+ # @!method MatrixLookAt(eye, target, up)
654
+ # MatrixLookAt
655
+ # @param eye [Vector3]
656
+ # @param target [Vector3]
657
+ # @param up [Vector3]
658
+ # @return [Matrix]
571
659
  [:MatrixLookAt, :MatrixLookAt, [Vector3.by_value, Vector3.by_value, Vector3.by_value], Matrix.by_value],
572
660
 
573
- # MatrixToFloatV
574
- # @param mat [Matrix]
575
- # @return [float16]
661
+ # @!method MatrixToFloatV(mat)
662
+ # MatrixToFloatV
663
+ # @param mat [Matrix]
664
+ # @return [float16]
576
665
  [:MatrixToFloatV, :MatrixToFloatV, [Matrix.by_value], Float16.by_value],
577
666
 
578
- # QuaternionAdd
579
- # @param q1 [Quaternion]
580
- # @param q2 [Quaternion]
581
- # @return [Quaternion]
667
+ # @!method QuaternionAdd(q1, q2)
668
+ # QuaternionAdd
669
+ # @param q1 [Quaternion]
670
+ # @param q2 [Quaternion]
671
+ # @return [Quaternion]
582
672
  [:QuaternionAdd, :QuaternionAdd, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],
583
673
 
584
- # QuaternionAddValue
585
- # @param q [Quaternion]
586
- # @param add [float]
587
- # @return [Quaternion]
674
+ # @!method QuaternionAddValue(q, add)
675
+ # QuaternionAddValue
676
+ # @param q [Quaternion]
677
+ # @param add [float]
678
+ # @return [Quaternion]
588
679
  [:QuaternionAddValue, :QuaternionAddValue, [Quaternion.by_value, :float], Quaternion.by_value],
589
680
 
590
- # QuaternionSubtract
591
- # @param q1 [Quaternion]
592
- # @param q2 [Quaternion]
593
- # @return [Quaternion]
681
+ # @!method QuaternionSubtract(q1, q2)
682
+ # QuaternionSubtract
683
+ # @param q1 [Quaternion]
684
+ # @param q2 [Quaternion]
685
+ # @return [Quaternion]
594
686
  [:QuaternionSubtract, :QuaternionSubtract, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],
595
687
 
596
- # QuaternionSubtractValue
597
- # @param q [Quaternion]
598
- # @param sub [float]
599
- # @return [Quaternion]
688
+ # @!method QuaternionSubtractValue(q, sub)
689
+ # QuaternionSubtractValue
690
+ # @param q [Quaternion]
691
+ # @param sub [float]
692
+ # @return [Quaternion]
600
693
  [:QuaternionSubtractValue, :QuaternionSubtractValue, [Quaternion.by_value, :float], Quaternion.by_value],
601
694
 
602
- # QuaternionIdentity
603
- # @return [Quaternion]
695
+ # @!method QuaternionIdentity()
696
+ # QuaternionIdentity
697
+ # @return [Quaternion]
604
698
  [:QuaternionIdentity, :QuaternionIdentity, [], Quaternion.by_value],
605
699
 
606
- # QuaternionLength
607
- # @param q [Quaternion]
608
- # @return [float]
700
+ # @!method QuaternionLength(q)
701
+ # QuaternionLength
702
+ # @param q [Quaternion]
703
+ # @return [float]
609
704
  [:QuaternionLength, :QuaternionLength, [Quaternion.by_value], :float],
610
705
 
611
- # QuaternionNormalize
612
- # @param q [Quaternion]
613
- # @return [Quaternion]
706
+ # @!method QuaternionNormalize(q)
707
+ # QuaternionNormalize
708
+ # @param q [Quaternion]
709
+ # @return [Quaternion]
614
710
  [:QuaternionNormalize, :QuaternionNormalize, [Quaternion.by_value], Quaternion.by_value],
615
711
 
616
- # QuaternionInvert
617
- # @param q [Quaternion]
618
- # @return [Quaternion]
712
+ # @!method QuaternionInvert(q)
713
+ # QuaternionInvert
714
+ # @param q [Quaternion]
715
+ # @return [Quaternion]
619
716
  [:QuaternionInvert, :QuaternionInvert, [Quaternion.by_value], Quaternion.by_value],
620
717
 
621
- # QuaternionMultiply
622
- # @param q1 [Quaternion]
623
- # @param q2 [Quaternion]
624
- # @return [Quaternion]
718
+ # @!method QuaternionMultiply(q1, q2)
719
+ # QuaternionMultiply
720
+ # @param q1 [Quaternion]
721
+ # @param q2 [Quaternion]
722
+ # @return [Quaternion]
625
723
  [:QuaternionMultiply, :QuaternionMultiply, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],
626
724
 
627
- # QuaternionScale
628
- # @param q [Quaternion]
629
- # @param mul [float]
630
- # @return [Quaternion]
725
+ # @!method QuaternionScale(q, mul)
726
+ # QuaternionScale
727
+ # @param q [Quaternion]
728
+ # @param mul [float]
729
+ # @return [Quaternion]
631
730
  [:QuaternionScale, :QuaternionScale, [Quaternion.by_value, :float], Quaternion.by_value],
632
731
 
633
- # QuaternionDivide
634
- # @param q1 [Quaternion]
635
- # @param q2 [Quaternion]
636
- # @return [Quaternion]
732
+ # @!method QuaternionDivide(q1, q2)
733
+ # QuaternionDivide
734
+ # @param q1 [Quaternion]
735
+ # @param q2 [Quaternion]
736
+ # @return [Quaternion]
637
737
  [:QuaternionDivide, :QuaternionDivide, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],
638
738
 
639
- # QuaternionLerp
640
- # @param q1 [Quaternion]
641
- # @param q2 [Quaternion]
642
- # @param amount [float]
643
- # @return [Quaternion]
739
+ # @!method QuaternionLerp(q1, q2, amount)
740
+ # QuaternionLerp
741
+ # @param q1 [Quaternion]
742
+ # @param q2 [Quaternion]
743
+ # @param amount [float]
744
+ # @return [Quaternion]
644
745
  [:QuaternionLerp, :QuaternionLerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value],
645
746
 
646
- # QuaternionNlerp
647
- # @param q1 [Quaternion]
648
- # @param q2 [Quaternion]
649
- # @param amount [float]
650
- # @return [Quaternion]
747
+ # @!method QuaternionNlerp(q1, q2, amount)
748
+ # QuaternionNlerp
749
+ # @param q1 [Quaternion]
750
+ # @param q2 [Quaternion]
751
+ # @param amount [float]
752
+ # @return [Quaternion]
651
753
  [:QuaternionNlerp, :QuaternionNlerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value],
652
754
 
653
- # QuaternionSlerp
654
- # @param q1 [Quaternion]
655
- # @param q2 [Quaternion]
656
- # @param amount [float]
657
- # @return [Quaternion]
755
+ # @!method QuaternionSlerp(q1, q2, amount)
756
+ # QuaternionSlerp
757
+ # @param q1 [Quaternion]
758
+ # @param q2 [Quaternion]
759
+ # @param amount [float]
760
+ # @return [Quaternion]
658
761
  [:QuaternionSlerp, :QuaternionSlerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value],
659
762
 
660
- # QuaternionFromVector3ToVector3
661
- # @param from [Vector3]
662
- # @param to [Vector3]
663
- # @return [Quaternion]
763
+ # @!method QuaternionFromVector3ToVector3(from, to)
764
+ # QuaternionFromVector3ToVector3
765
+ # @param from [Vector3]
766
+ # @param to [Vector3]
767
+ # @return [Quaternion]
664
768
  [:QuaternionFromVector3ToVector3, :QuaternionFromVector3ToVector3, [Vector3.by_value, Vector3.by_value], Quaternion.by_value],
665
769
 
666
- # QuaternionFromMatrix
667
- # @param mat [Matrix]
668
- # @return [Quaternion]
770
+ # @!method QuaternionFromMatrix(mat)
771
+ # QuaternionFromMatrix
772
+ # @param mat [Matrix]
773
+ # @return [Quaternion]
669
774
  [:QuaternionFromMatrix, :QuaternionFromMatrix, [Matrix.by_value], Quaternion.by_value],
670
775
 
671
- # QuaternionToMatrix
672
- # @param q [Quaternion]
673
- # @return [Matrix]
776
+ # @!method QuaternionToMatrix(q)
777
+ # QuaternionToMatrix
778
+ # @param q [Quaternion]
779
+ # @return [Matrix]
674
780
  [:QuaternionToMatrix, :QuaternionToMatrix, [Quaternion.by_value], Matrix.by_value],
675
781
 
676
- # QuaternionFromAxisAngle
677
- # @param axis [Vector3]
678
- # @param angle [float]
679
- # @return [Quaternion]
782
+ # @!method QuaternionFromAxisAngle(axis, angle)
783
+ # QuaternionFromAxisAngle
784
+ # @param axis [Vector3]
785
+ # @param angle [float]
786
+ # @return [Quaternion]
680
787
  [:QuaternionFromAxisAngle, :QuaternionFromAxisAngle, [Vector3.by_value, :float], Quaternion.by_value],
681
788
 
682
- # QuaternionToAxisAngle
683
- # @param q [Quaternion]
684
- # @param outAxis [Vector3 *]
685
- # @param outAngle [float *]
686
- # @return [void]
789
+ # @!method QuaternionToAxisAngle(q, outAxis, outAngle)
790
+ # QuaternionToAxisAngle
791
+ # @param q [Quaternion]
792
+ # @param outAxis [Vector3 *]
793
+ # @param outAngle [float *]
794
+ # @return [void]
687
795
  [:QuaternionToAxisAngle, :QuaternionToAxisAngle, [Quaternion.by_value, :pointer, :pointer], :void],
688
796
 
689
- # QuaternionFromEuler
690
- # @param pitch [float]
691
- # @param yaw [float]
692
- # @param roll [float]
693
- # @return [Quaternion]
797
+ # @!method QuaternionFromEuler(pitch, yaw, roll)
798
+ # QuaternionFromEuler
799
+ # @param pitch [float]
800
+ # @param yaw [float]
801
+ # @param roll [float]
802
+ # @return [Quaternion]
694
803
  [:QuaternionFromEuler, :QuaternionFromEuler, [:float, :float, :float], Quaternion.by_value],
695
804
 
696
- # QuaternionToEuler
697
- # @param q [Quaternion]
698
- # @return [Vector3]
805
+ # @!method QuaternionToEuler(q)
806
+ # QuaternionToEuler
807
+ # @param q [Quaternion]
808
+ # @return [Vector3]
699
809
  [:QuaternionToEuler, :QuaternionToEuler, [Quaternion.by_value], Vector3.by_value],
700
810
 
701
- # QuaternionTransform
702
- # @param q [Quaternion]
703
- # @param mat [Matrix]
704
- # @return [Quaternion]
811
+ # @!method QuaternionTransform(q, mat)
812
+ # QuaternionTransform
813
+ # @param q [Quaternion]
814
+ # @param mat [Matrix]
815
+ # @return [Quaternion]
705
816
  [:QuaternionTransform, :QuaternionTransform, [Quaternion.by_value, Matrix.by_value], Quaternion.by_value],
706
817
 
707
- # QuaternionEquals
708
- # @param p [Quaternion]
709
- # @param q [Quaternion]
710
- # @return [int]
818
+ # @!method QuaternionEquals(p, q)
819
+ # QuaternionEquals
820
+ # @param p [Quaternion]
821
+ # @param q [Quaternion]
822
+ # @return [int]
711
823
  [:QuaternionEquals, :QuaternionEquals, [Quaternion.by_value, Quaternion.by_value], :int],
712
824
  ]
713
825
  entries.each do |entry|