rmath3d 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. checksums.yaml +4 -4
  2. data/ChangeLog +5 -0
  3. data/README.md +4 -1
  4. data/ext/rmath3d/rmath3d.c +628 -551
  5. metadata +3 -3
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: cb1e762ea46c80e060d6efdcaf6db861e6ad2ffc
4
- data.tar.gz: c4cbac65664fd3c54d08ca66dd9e207a9f3384b0
3
+ metadata.gz: 49898e4a80e600f039ecd7ec04511872b3ae42d2
4
+ data.tar.gz: fcc1b6d2a979747fc86519d30560e824dbf1b88c
5
5
  SHA512:
6
- metadata.gz: bf14364015645a9631a9e57c6c54279a93090f2bb8ed7470bfd75795e04cfdb2ca519aceaaeaf9f10d19caf5909b1e7a71645cd4237bd563236dc788c93b8081
7
- data.tar.gz: 158e3a7d837715897afadf073c644aa10fa7dbd3b9fc735bdf6c1d5bbd029f6637fb82e0731d9806109bc9c7122f39d7ac8113fe84a01a681956e5854f52f8bd
6
+ metadata.gz: 5ddcc540d1be103a66966c51d839ad3c2af5775b5d0ad2dbe9f1c729964ec60a5cd411fd692fb76e6731a482f778f09e9f77dc9a6913ce7f20e4663c32422067
7
+ data.tar.gz: ad561643d3081d05ae0821ecafb762be751d07b5675330f7df913a37bac12c827964217dff897b4524be833a68c2545852ba138dd34414d4b4523d8d0f802835
data/ChangeLog CHANGED
@@ -1,3 +1,8 @@
1
+ 2015-05-02 vaiorabbit <http://twitter.com/vaiorabbit>
2
+
3
+ * Ruby 1.9.3 and prior versions are no longer supported. Ref.: https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/
4
+ * rmath3d.c: Data_Get_Struct -> TypedData_Get_Struct, etc.
5
+
1
6
  2015-04-12 vaiorabbit <http://twitter.com/vaiorabbit>
2
7
 
3
8
  * RVec2.c|h, RMtx2.c|h: Added.
data/README.md CHANGED
@@ -4,7 +4,7 @@
4
4
 
5
5
  rmath3d is a math module for 3D game programming and computer graphics.
6
6
 
7
- * Last Update: Apr 12, 2015
7
+ * Last Update: Mar 02, 2015
8
8
  * Since: Jul 20, 2008
9
9
 
10
10
  ## Features ##
@@ -35,6 +35,9 @@ Notice: This library provides native extension. You must setup develop environme
35
35
  * I used: DevKit-mingw64-32-4.7.2-20130224-1151-sfx.exe
36
36
  * Unpack the archive -> "> ruby dk.rb init" -> edit config.yml (just add your ruby foldier) -> "> ruby dk.rb install"
37
37
  * Ref.: http://blog.mattwynne.net/2010/10/12/installing-ruby-gems-with-native-extensions-on-windows/
38
+ * ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-darwin14]
39
+ * Ruby 1.9.3 and prior versions are no longer supported.
40
+ * Ref.: https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/
38
41
 
39
42
  ## Building rmath3d.{so|bundle} ##
40
43
 
data/ext/rmath3d/rmath3d.c CHANGED
@@ -33,15 +33,6 @@ VALUE rb_cRMtx4;
33
33
  #endif
34
34
  #endif /* RMATH_EXPORT */
35
35
 
36
- /* for Ruby 1.8 (C API has no RFLOAT_VALUE macro.) */
37
- #ifndef RFLOAT_VALUE
38
- #define RFLOAT_VALUE(v) (RFLOAT(v)->value)
39
- #endif
40
- /* for Ruby 1.8 (C API has no DOUBLE2NUM macro) */
41
- #ifndef DOUBLE2NUM
42
- #define DOUBLE2NUM(dbl) rb_float_new(dbl)
43
- #endif
44
-
45
36
  #define IsRVec2(v) rb_obj_is_kind_of( (v), rb_cRVec2 )
46
37
  #define IsRVec3(v) rb_obj_is_kind_of( (v), rb_cRVec3 )
47
38
  #define IsRVec4(v) rb_obj_is_kind_of( (v), rb_cRVec4 )
@@ -50,6 +41,77 @@ VALUE rb_cRMtx4;
50
41
  #define IsRMtx3(v) rb_obj_is_kind_of( (v), rb_cRMtx3 )
51
42
  #define IsRMtx4(v) rb_obj_is_kind_of( (v), rb_cRMtx4 )
52
43
 
44
+ static void RVec2_free( void* ptr );
45
+ static size_t RVec2_memsize( const void* ptr );
46
+
47
+ static void RVec3_free( void* ptr );
48
+ static size_t RVec3_memsize( const void* ptr );
49
+
50
+ static void RVec4_free( void* ptr );
51
+ static size_t RVec4_memsize( const void* ptr );
52
+
53
+ static void RQuat_free( void* ptr );
54
+ static size_t RQuat_memsize( const void* ptr );
55
+
56
+ static void RMtx2_free( void* ptr );
57
+ static size_t RMtx2_memsize( const void* ptr );
58
+
59
+ static void RMtx3_free( void* ptr );
60
+ static size_t RMtx3_memsize( const void* ptr );
61
+
62
+ static void RMtx4_free( void* ptr );
63
+ static size_t RMtx4_memsize( const void* ptr );
64
+
65
+ static const rb_data_type_t RVec2_type = {
66
+ "RVec2",
67
+ {0, RVec2_free, RVec2_memsize,},
68
+ 0, 0,
69
+ RUBY_TYPED_FREE_IMMEDIATELY,
70
+ };
71
+
72
+ static const rb_data_type_t RVec3_type = {
73
+ "RVec3",
74
+ {0, RVec3_free, RVec3_memsize,},
75
+ 0, 0,
76
+ RUBY_TYPED_FREE_IMMEDIATELY,
77
+ };
78
+
79
+ static const rb_data_type_t RVec4_type = {
80
+ "RVec4",
81
+ {0, RVec4_free, RVec4_memsize,},
82
+ 0, 0,
83
+ RUBY_TYPED_FREE_IMMEDIATELY,
84
+ };
85
+
86
+ static const rb_data_type_t RQuat_type = {
87
+ "RQuat",
88
+ {0, RQuat_free, RQuat_memsize,},
89
+ 0, 0,
90
+ RUBY_TYPED_FREE_IMMEDIATELY,
91
+ };
92
+
93
+ static const rb_data_type_t RMtx2_type = {
94
+ "RMtx2",
95
+ {0, RMtx2_free, RMtx2_memsize,},
96
+ 0, 0,
97
+ RUBY_TYPED_FREE_IMMEDIATELY,
98
+ };
99
+
100
+ static const rb_data_type_t RMtx3_type = {
101
+ "RMtx3",
102
+ {0, RMtx3_free, RMtx3_memsize,},
103
+ 0, 0,
104
+ RUBY_TYPED_FREE_IMMEDIATELY,
105
+ };
106
+
107
+ static const rb_data_type_t RMtx4_type = {
108
+ "RMtx4",
109
+ {0, RMtx4_free, RMtx4_memsize,},
110
+ 0, 0,
111
+ RUBY_TYPED_FREE_IMMEDIATELY,
112
+ };
113
+
114
+
53
115
  #ifdef RMATH_SINGLE_PRECISION
54
116
  # define RMATH_FVAL_FMT "%#.6g"
55
117
  #else
@@ -72,7 +134,7 @@ static VALUE RVec4_from_source( RVec4* src );
72
134
  ********************************************************************************/
73
135
 
74
136
  /*
75
- * Document-class: RMath::RMtx2
137
+ * Document-class: RMath3D::RMtx2
76
138
  * provies 2x2 matrix arithmetic.
77
139
  *
78
140
  * <b>Notice</b>
@@ -82,28 +144,30 @@ static VALUE RVec4_from_source( RVec4* src );
82
144
  static void
83
145
  RMtx2_free( void* ptr )
84
146
  {
85
- xfree( ptr );
147
+ xfree( ptr );
148
+ }
149
+
150
+ static size_t
151
+ RMtx2_memsize( const void* ptr )
152
+ {
153
+ const struct RMtx2* data = ptr;
154
+ return data ? sizeof(*data) : 0;
86
155
  }
87
156
 
88
157
  static VALUE
89
158
  RMtx2_from_source( RMtx2* src )
90
159
  {
91
- RMtx2* v = ALLOC( RMtx2 );
92
-
160
+ RMtx2* v = ZALLOC( struct RMtx2 );
93
161
  RMtx2Copy( v, src );
94
-
95
- return Data_Wrap_Struct( rb_cRMtx2, NULL, RMtx2_free, v );
162
+ return TypedData_Wrap_Struct( rb_cRMtx2, &RMtx2_type, v );
96
163
  }
97
164
 
98
165
 
99
166
  static VALUE
100
167
  RMtx2_allocate( VALUE klass )
101
168
  {
102
- RMtx2* v = ALLOC( RMtx2 );
103
-
104
- memset( v, 0, sizeof(RMtx2) );
105
-
106
- return Data_Wrap_Struct( klass, NULL, RMtx2_free, v );
169
+ RMtx2* v = ZALLOC( RMtx2 );
170
+ return TypedData_Wrap_Struct( klass, &RMtx2_type, v );
107
171
  }
108
172
 
109
173
 
@@ -120,7 +184,8 @@ static VALUE
120
184
  RMtx2_initialize( int argc, VALUE* argv, VALUE self )
121
185
  {
122
186
  RMtx2* v = NULL;
123
- Data_Get_Struct( self, RMtx2, v );
187
+
188
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, v );
124
189
 
125
190
  switch( argc )
126
191
  {
@@ -155,7 +220,7 @@ RMtx2_initialize( int argc, VALUE* argv, VALUE self )
155
220
  {
156
221
  /* Copy Constructor */
157
222
  RMtx2* other;
158
- Data_Get_Struct( arg , RMtx2, other );
223
+ TypedData_Get_Struct( arg, RMtx2, &RMtx2_type, other );
159
224
  RMtx2Copy( v, other );
160
225
  return self;
161
226
  }
@@ -236,7 +301,7 @@ RMtx2_to_s( VALUE self )
236
301
  int row, col, n;
237
302
  rmReal val;
238
303
 
239
- Data_Get_Struct( self, RMtx2, v );
304
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, v );
240
305
 
241
306
  p = dest;
242
307
  for ( row = 0; row < 2; ++row )
@@ -280,7 +345,7 @@ RMtx2_to_a( VALUE self )
280
345
  int row, col;
281
346
  RMtx2* v = NULL;
282
347
  VALUE dbl[4];
283
- Data_Get_Struct( self, RMtx2, v );
348
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, v );
284
349
 
285
350
  /* column-major */
286
351
  for ( col = 0; col < 2; ++col )
@@ -288,7 +353,7 @@ RMtx2_to_a( VALUE self )
288
353
  for ( row = 0; row < 2; ++row )
289
354
  {
290
355
  int i = 2*col + row;
291
- dbl[i] = DOUBLE2NUM(RMtx2GetElement(v,row,col));
356
+ dbl[i] = DBL2NUM(RMtx2GetElement(v,row,col));
292
357
  }
293
358
  }
294
359
 
@@ -304,7 +369,7 @@ static VALUE
304
369
  RMtx2_coerce( VALUE self, VALUE other )
305
370
  {
306
371
  RMtx2* v = NULL;
307
- Data_Get_Struct( self, RMtx2, v );
372
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, v );
308
373
 
309
374
  switch( TYPE(other) )
310
375
  {
@@ -351,7 +416,7 @@ RMtx2_setElements( int argc, VALUE* argv, VALUE self )
351
416
  }
352
417
  #endif
353
418
 
354
- Data_Get_Struct( self, RMtx2, m );
419
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
355
420
  for ( row = 0; row < 2; ++row )
356
421
  {
357
422
  for ( col = 0; col < 2; ++col )
@@ -376,7 +441,7 @@ RMtx2_setElement( VALUE self, VALUE r, VALUE c, VALUE f )
376
441
  int row, col;
377
442
  rmReal flt;
378
443
 
379
- Data_Get_Struct( self, RMtx2, m );
444
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
380
445
  row = FIX2INT(r);
381
446
  col = FIX2INT(c);
382
447
  flt = NUM2DBL(f);
@@ -398,12 +463,12 @@ RMtx2_getElement( VALUE self, VALUE r, VALUE c )
398
463
  int row, col;
399
464
  rmReal flt;
400
465
 
401
- Data_Get_Struct( self, RMtx2, m );
466
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
402
467
  row = FIX2INT(r);
403
468
  col = FIX2INT(c);
404
469
  flt = RMtx2GetElement( m, row, col );
405
470
 
406
- return DOUBLE2NUM( flt );
471
+ return DBL2NUM( flt );
407
472
  }
408
473
 
409
474
  /* Returns the element at row 0 and column 0.
@@ -413,9 +478,9 @@ RMtx2_get_e00( VALUE self )
413
478
  {
414
479
  RMtx2* m;
415
480
 
416
- Data_Get_Struct( self, RMtx2, m );
481
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
417
482
 
418
- return DOUBLE2NUM( RMtx2GetElement( m, 0, 0 ) );
483
+ return DBL2NUM( RMtx2GetElement( m, 0, 0 ) );
419
484
  }
420
485
 
421
486
  /* Returns the element at row 0 and column 1.
@@ -425,9 +490,9 @@ RMtx2_get_e01( VALUE self )
425
490
  {
426
491
  RMtx2* m;
427
492
 
428
- Data_Get_Struct( self, RMtx2, m );
493
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
429
494
 
430
- return DOUBLE2NUM( RMtx2GetElement( m, 0, 1 ) );
495
+ return DBL2NUM( RMtx2GetElement( m, 0, 1 ) );
431
496
  }
432
497
 
433
498
  /* Returns the element at row 1 and column 0.
@@ -437,9 +502,9 @@ RMtx2_get_e10( VALUE self )
437
502
  {
438
503
  RMtx2* m;
439
504
 
440
- Data_Get_Struct( self, RMtx2, m );
505
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
441
506
 
442
- return DOUBLE2NUM( RMtx2GetElement( m, 1, 0 ) );
507
+ return DBL2NUM( RMtx2GetElement( m, 1, 0 ) );
443
508
  }
444
509
 
445
510
  /* Returns the element at row 1 and column 1.
@@ -449,9 +514,9 @@ RMtx2_get_e11( VALUE self )
449
514
  {
450
515
  RMtx2* m;
451
516
 
452
- Data_Get_Struct( self, RMtx2, m );
517
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
453
518
 
454
- return DOUBLE2NUM( RMtx2GetElement( m, 1, 1 ) );
519
+ return DBL2NUM( RMtx2GetElement( m, 1, 1 ) );
455
520
  }
456
521
 
457
522
  /* Replaces the element at row 0 and column 0 by +value+.
@@ -461,7 +526,7 @@ RMtx2_set_e00( VALUE self, VALUE f )
461
526
  {
462
527
  RMtx2* m;
463
528
 
464
- Data_Get_Struct( self, RMtx2, m );
529
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
465
530
 
466
531
  RMtx2SetElement( m, 0, 0, NUM2DBL(f) );
467
532
 
@@ -475,7 +540,7 @@ RMtx2_set_e01( VALUE self, VALUE f )
475
540
  {
476
541
  RMtx2* m;
477
542
 
478
- Data_Get_Struct( self, RMtx2, m );
543
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
479
544
 
480
545
  RMtx2SetElement( m, 0, 1, NUM2DBL(f) );
481
546
 
@@ -489,7 +554,7 @@ RMtx2_set_e10( VALUE self, VALUE f )
489
554
  {
490
555
  RMtx2* m;
491
556
 
492
- Data_Get_Struct( self, RMtx2, m );
557
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
493
558
 
494
559
  RMtx2SetElement( m, 1, 0, NUM2DBL(f) );
495
560
 
@@ -503,7 +568,7 @@ RMtx2_set_e11( VALUE self, VALUE f )
503
568
  {
504
569
  RMtx2* m;
505
570
 
506
- Data_Get_Struct( self, RMtx2, m );
571
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
507
572
 
508
573
  RMtx2SetElement( m, 1, 1, NUM2DBL(f) );
509
574
 
@@ -523,7 +588,7 @@ RMtx2_getRow( VALUE self, VALUE row )
523
588
  int at;
524
589
  RVec2 out;
525
590
 
526
- Data_Get_Struct( self, RMtx2, m );
591
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
527
592
  at = FIX2INT(row);
528
593
  RMtx2GetRow( &out, m, at );
529
594
 
@@ -542,7 +607,7 @@ RMtx2_getColumn( VALUE self, VALUE column )
542
607
  int at;
543
608
  RVec2 out;
544
609
 
545
- Data_Get_Struct( self, RMtx2, m );
610
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
546
611
  at = FIX2INT(column);
547
612
  RMtx2GetColumn( &out, m, at );
548
613
 
@@ -562,8 +627,8 @@ RMtx2_setRow( VALUE self, VALUE v, VALUE row )
562
627
  RVec2* in;
563
628
  int at;
564
629
 
565
- Data_Get_Struct( self, RMtx2, m );
566
- Data_Get_Struct( v, RVec2, in );
630
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
631
+ TypedData_Get_Struct( v, RVec2, &RVec2_type, in );
567
632
  at = FIX2INT(row);
568
633
  RMtx2SetRow( m, in, at );
569
634
 
@@ -583,8 +648,8 @@ RMtx2_setColumn( VALUE self, VALUE v, VALUE column )
583
648
  RVec2* in;
584
649
  int at;
585
650
 
586
- Data_Get_Struct( self, RMtx2, m );
587
- Data_Get_Struct( v, RVec2, in );
651
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
652
+ TypedData_Get_Struct( v, RVec2, &RVec2_type, in );
588
653
  at = FIX2INT(column);
589
654
  RMtx2SetColumn( m, in, at );
590
655
 
@@ -603,7 +668,7 @@ RMtx2_setZero( VALUE self )
603
668
  {
604
669
  RMtx2* m = NULL;
605
670
 
606
- Data_Get_Struct( self, RMtx2, m );
671
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
607
672
  RMtx2Zero( m );
608
673
 
609
674
  return self;
@@ -619,7 +684,7 @@ RMtx2_setIdentity( VALUE self )
619
684
  {
620
685
  RMtx2* m = NULL;
621
686
 
622
- Data_Get_Struct( self, RMtx2, m );
687
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
623
688
  RMtx2Identity( m );
624
689
 
625
690
  return self;
@@ -636,10 +701,10 @@ RMtx2_getDeterminant( VALUE self )
636
701
  RMtx2* m = NULL;
637
702
  rmReal f;
638
703
 
639
- Data_Get_Struct( self, RMtx2, m );
704
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
640
705
  f = RMtx2Determinant( m );
641
706
 
642
- return DOUBLE2NUM( f );
707
+ return DBL2NUM( f );
643
708
  }
644
709
 
645
710
  /*
@@ -653,7 +718,7 @@ RMtx2_transpose( VALUE self )
653
718
  RMtx2* m = NULL;
654
719
  RMtx2 out;
655
720
 
656
- Data_Get_Struct( self, RMtx2, m );
721
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
657
722
  RMtx2Transpose( &out, m );
658
723
 
659
724
  return RMtx2_from_source( &out );
@@ -669,7 +734,7 @@ RMtx2_transpose_intrusive( VALUE self )
669
734
  {
670
735
  RMtx2* m = NULL;
671
736
 
672
- Data_Get_Struct( self, RMtx2, m );
737
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
673
738
  RMtx2Transpose( m, m );
674
739
 
675
740
  return self;
@@ -686,7 +751,7 @@ RMtx2_inverse( VALUE self )
686
751
  RMtx2* m = NULL;
687
752
  RMtx2 out;
688
753
 
689
- Data_Get_Struct( self, RMtx2, m );
754
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
690
755
  RMtx2Inverse( &out, m );
691
756
 
692
757
  return RMtx2_from_source( &out );
@@ -702,7 +767,7 @@ RMtx2_invert( VALUE self )
702
767
  {
703
768
  RMtx2* m = NULL;
704
769
 
705
- Data_Get_Struct( self, RMtx2, m );
770
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
706
771
  RMtx2Inverse( m, m );
707
772
 
708
773
  return self;
@@ -719,7 +784,7 @@ RMtx2_rotation( VALUE self, VALUE radian )
719
784
  RMtx2* m = NULL;
720
785
  rmReal angle_radian;
721
786
 
722
- Data_Get_Struct( self, RMtx2, m );
787
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
723
788
  angle_radian = NUM2DBL(radian);
724
789
  RMtx2Rotation( m, angle_radian );
725
790
 
@@ -737,7 +802,7 @@ RMtx2_scaling( VALUE self, VALUE x, VALUE y )
737
802
  RMtx2* m = NULL;
738
803
  rmReal sx, sy;
739
804
 
740
- Data_Get_Struct( self, RMtx2, m );
805
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
741
806
  sx = NUM2DBL(x);
742
807
  sy = NUM2DBL(y);
743
808
  RMtx2Scaling( m, sx, sy );
@@ -767,7 +832,7 @@ RMtx2_op_unary_minus( VALUE self )
767
832
  RMtx2* m = NULL;
768
833
  RMtx2 out;
769
834
 
770
- Data_Get_Struct( self, RMtx2, m );
835
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m );
771
836
  RMtx2Scale( &out, m, (rmReal)(-1) );
772
837
 
773
838
  return RMtx2_from_source( &out );
@@ -796,8 +861,8 @@ RMtx2_op_binary_plus( VALUE self, VALUE other )
796
861
  }
797
862
  #endif
798
863
 
799
- Data_Get_Struct( self, RMtx2, m1 );
800
- Data_Get_Struct( other, RMtx2, m2 );
864
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m1 );
865
+ TypedData_Get_Struct( other, RMtx2, &RMtx2_type, m2 );
801
866
  RMtx2Add( &result, m1, m2 );
802
867
 
803
868
  return RMtx2_from_source( &result );
@@ -826,8 +891,8 @@ RMtx2_op_binary_minus( VALUE self, VALUE other )
826
891
  }
827
892
  #endif
828
893
 
829
- Data_Get_Struct( self, RMtx2, m1 );
830
- Data_Get_Struct( other, RMtx2, m2 );
894
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m1 );
895
+ TypedData_Get_Struct( other, RMtx2, &RMtx2_type, m2 );
831
896
  RMtx2Sub( &result, m1, m2 );
832
897
 
833
898
  return RMtx2_from_source( &result );
@@ -846,11 +911,11 @@ RMtx2_op_binary_mult( VALUE self, VALUE other )
846
911
  rmReal f;
847
912
  RMtx2 result;
848
913
 
849
- Data_Get_Struct( self, RMtx2, m1 );
914
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m1 );
850
915
 
851
916
  if ( IsRMtx2(other) )
852
917
  {
853
- Data_Get_Struct( other, RMtx2, m2 );
918
+ TypedData_Get_Struct( other, RMtx2, &RMtx2_type, m2 );
854
919
  RMtx2Mul( &result, m1, m2 );
855
920
  }
856
921
  else
@@ -884,8 +949,8 @@ RMtx2_op_binary_eq( VALUE self, VALUE other )
884
949
  }
885
950
  #endif
886
951
 
887
- Data_Get_Struct( self, RMtx2, m1 );
888
- Data_Get_Struct( other, RMtx2, m2 );
952
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m1 );
953
+ TypedData_Get_Struct( other, RMtx2, &RMtx2_type, m2 );
889
954
 
890
955
  if ( !RMtx2Equal(m1,m2) )
891
956
  return Qfalse;
@@ -915,8 +980,8 @@ RMtx2_op_assign_plus( VALUE self, VALUE other )
915
980
  }
916
981
  #endif
917
982
 
918
- Data_Get_Struct( self, RMtx2, m1 );
919
- Data_Get_Struct( other, RMtx2, m2 );
983
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m1 );
984
+ TypedData_Get_Struct( other, RMtx2, &RMtx2_type, m2 );
920
985
  RMtx2Add( m1, m1, m2 );
921
986
 
922
987
  return self;
@@ -944,8 +1009,8 @@ RMtx2_op_assign_minus( VALUE self, VALUE other )
944
1009
  }
945
1010
  #endif
946
1011
 
947
- Data_Get_Struct( self, RMtx2, m1 );
948
- Data_Get_Struct( other, RMtx2, m2 );
1012
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m1 );
1013
+ TypedData_Get_Struct( other, RMtx2, &RMtx2_type, m2 );
949
1014
  RMtx2Sub( m1, m1, m2 );
950
1015
 
951
1016
  return self;
@@ -963,11 +1028,11 @@ RMtx2_op_assign_mult( VALUE self, VALUE other )
963
1028
  RMtx2* m2 = NULL;
964
1029
  rmReal f;
965
1030
 
966
- Data_Get_Struct( self, RMtx2, m1 );
1031
+ TypedData_Get_Struct( self, RMtx2, &RMtx2_type, m1 );
967
1032
 
968
1033
  if ( IsRMtx2(other) )
969
1034
  {
970
- Data_Get_Struct( other, RMtx2, m2 );
1035
+ TypedData_Get_Struct( other, RMtx2, &RMtx2_type, m2 );
971
1036
  RMtx2Mul( m1, m1, m2 );
972
1037
  }
973
1038
  else
@@ -987,7 +1052,7 @@ RMtx2_op_assign_mult( VALUE self, VALUE other )
987
1052
  ********************************************************************************/
988
1053
 
989
1054
  /*
990
- * Document-class: RMath::RMtx3
1055
+ * Document-class: RMath3D::RMtx3
991
1056
  * provies 3x3 matrix arithmetic.
992
1057
  *
993
1058
  * <b>Notice</b>
@@ -1000,25 +1065,27 @@ RMtx3_free( void* ptr )
1000
1065
  xfree( ptr );
1001
1066
  }
1002
1067
 
1068
+ static size_t
1069
+ RMtx3_memsize( const void* ptr )
1070
+ {
1071
+ const struct RMtx3* data = ptr;
1072
+ return data ? sizeof(*data) : 0;
1073
+ }
1074
+
1003
1075
  static VALUE
1004
1076
  RMtx3_from_source( RMtx3* src )
1005
1077
  {
1006
- RMtx3* v = ALLOC( RMtx3 );
1007
-
1078
+ RMtx3* v = ZALLOC( struct RMtx3 );
1008
1079
  RMtx3Copy( v, src );
1009
-
1010
- return Data_Wrap_Struct( rb_cRMtx3, NULL, RMtx3_free, v );
1080
+ return TypedData_Wrap_Struct( rb_cRMtx3, &RMtx3_type, v );
1011
1081
  }
1012
1082
 
1013
1083
 
1014
1084
  static VALUE
1015
1085
  RMtx3_allocate( VALUE klass )
1016
1086
  {
1017
- RMtx3* v = ALLOC( RMtx3 );
1018
-
1019
- memset( v, 0, sizeof(RMtx3) );
1020
-
1021
- return Data_Wrap_Struct( klass, NULL, RMtx3_free, v );
1087
+ RMtx3* v = ZALLOC( RMtx3 );
1088
+ return TypedData_Wrap_Struct( klass, &RMtx3_type, v );
1022
1089
  }
1023
1090
 
1024
1091
 
@@ -1035,7 +1102,7 @@ static VALUE
1035
1102
  RMtx3_initialize( int argc, VALUE* argv, VALUE self )
1036
1103
  {
1037
1104
  RMtx3* v = NULL;
1038
- Data_Get_Struct( self, RMtx3, v );
1105
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, v );
1039
1106
 
1040
1107
  switch( argc )
1041
1108
  {
@@ -1071,7 +1138,7 @@ RMtx3_initialize( int argc, VALUE* argv, VALUE self )
1071
1138
  {
1072
1139
  /* Copy Constructor */
1073
1140
  RMtx3* other;
1074
- Data_Get_Struct( arg , RMtx3, other );
1141
+ TypedData_Get_Struct( arg , RMtx3, &RMtx3_type, other );
1075
1142
  RMtx3Copy( v, other );
1076
1143
  return self;
1077
1144
  }
@@ -1152,7 +1219,7 @@ RMtx3_to_s( VALUE self )
1152
1219
  int row, col, n;
1153
1220
  rmReal val;
1154
1221
 
1155
- Data_Get_Struct( self, RMtx3, v );
1222
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, v );
1156
1223
 
1157
1224
  p = dest;
1158
1225
  for ( row = 0; row < 3; ++row )
@@ -1196,7 +1263,7 @@ RMtx3_to_a( VALUE self )
1196
1263
  int row, col;
1197
1264
  RMtx3* v = NULL;
1198
1265
  VALUE dbl[9];
1199
- Data_Get_Struct( self, RMtx3, v );
1266
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, v );
1200
1267
 
1201
1268
  /* column-major */
1202
1269
  for ( col = 0; col < 3; ++col )
@@ -1204,7 +1271,7 @@ RMtx3_to_a( VALUE self )
1204
1271
  for ( row = 0; row < 3; ++row )
1205
1272
  {
1206
1273
  int i = 3*col + row;
1207
- dbl[i] = DOUBLE2NUM(RMtx3GetElement(v,row,col));
1274
+ dbl[i] = DBL2NUM(RMtx3GetElement(v,row,col));
1208
1275
  }
1209
1276
  }
1210
1277
 
@@ -1220,7 +1287,7 @@ static VALUE
1220
1287
  RMtx3_coerce( VALUE self, VALUE other )
1221
1288
  {
1222
1289
  RMtx3* v = NULL;
1223
- Data_Get_Struct( self, RMtx3, v );
1290
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, v );
1224
1291
 
1225
1292
  switch( TYPE(other) )
1226
1293
  {
@@ -1267,7 +1334,7 @@ RMtx3_setElements( int argc, VALUE* argv, VALUE self )
1267
1334
  }
1268
1335
  #endif
1269
1336
 
1270
- Data_Get_Struct( self, RMtx3, m );
1337
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1271
1338
  for ( row = 0; row < 3; ++row )
1272
1339
  {
1273
1340
  for ( col = 0; col < 3; ++col )
@@ -1292,7 +1359,7 @@ RMtx3_setElement( VALUE self, VALUE r, VALUE c, VALUE f )
1292
1359
  int row, col;
1293
1360
  rmReal flt;
1294
1361
 
1295
- Data_Get_Struct( self, RMtx3, m );
1362
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1296
1363
  row = FIX2INT(r);
1297
1364
  col = FIX2INT(c);
1298
1365
  flt = NUM2DBL(f);
@@ -1314,12 +1381,12 @@ RMtx3_getElement( VALUE self, VALUE r, VALUE c )
1314
1381
  int row, col;
1315
1382
  rmReal flt;
1316
1383
 
1317
- Data_Get_Struct( self, RMtx3, m );
1384
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1318
1385
  row = FIX2INT(r);
1319
1386
  col = FIX2INT(c);
1320
1387
  flt = RMtx3GetElement( m, row, col );
1321
1388
 
1322
- return DOUBLE2NUM( flt );
1389
+ return DBL2NUM( flt );
1323
1390
  }
1324
1391
 
1325
1392
  /* Returns the element at row 0 and column 0.
@@ -1329,9 +1396,9 @@ RMtx3_get_e00( VALUE self )
1329
1396
  {
1330
1397
  RMtx3* m;
1331
1398
 
1332
- Data_Get_Struct( self, RMtx3, m );
1399
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1333
1400
 
1334
- return DOUBLE2NUM( RMtx3GetElement( m, 0, 0 ) );
1401
+ return DBL2NUM( RMtx3GetElement( m, 0, 0 ) );
1335
1402
  }
1336
1403
 
1337
1404
  /* Returns the element at row 0 and column 1.
@@ -1341,9 +1408,9 @@ RMtx3_get_e01( VALUE self )
1341
1408
  {
1342
1409
  RMtx3* m;
1343
1410
 
1344
- Data_Get_Struct( self, RMtx3, m );
1411
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1345
1412
 
1346
- return DOUBLE2NUM( RMtx3GetElement( m, 0, 1 ) );
1413
+ return DBL2NUM( RMtx3GetElement( m, 0, 1 ) );
1347
1414
  }
1348
1415
 
1349
1416
  /* Returns the element at row 0 and column 2.
@@ -1353,9 +1420,9 @@ RMtx3_get_e02( VALUE self )
1353
1420
  {
1354
1421
  RMtx3* m;
1355
1422
 
1356
- Data_Get_Struct( self, RMtx3, m );
1423
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1357
1424
 
1358
- return DOUBLE2NUM( RMtx3GetElement( m, 0, 2 ) );
1425
+ return DBL2NUM( RMtx3GetElement( m, 0, 2 ) );
1359
1426
  }
1360
1427
 
1361
1428
  /* Returns the element at row 1 and column 0.
@@ -1365,9 +1432,9 @@ RMtx3_get_e10( VALUE self )
1365
1432
  {
1366
1433
  RMtx3* m;
1367
1434
 
1368
- Data_Get_Struct( self, RMtx3, m );
1435
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1369
1436
 
1370
- return DOUBLE2NUM( RMtx3GetElement( m, 1, 0 ) );
1437
+ return DBL2NUM( RMtx3GetElement( m, 1, 0 ) );
1371
1438
  }
1372
1439
 
1373
1440
  /* Returns the element at row 1 and column 1.
@@ -1377,9 +1444,9 @@ RMtx3_get_e11( VALUE self )
1377
1444
  {
1378
1445
  RMtx3* m;
1379
1446
 
1380
- Data_Get_Struct( self, RMtx3, m );
1447
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1381
1448
 
1382
- return DOUBLE2NUM( RMtx3GetElement( m, 1, 1 ) );
1449
+ return DBL2NUM( RMtx3GetElement( m, 1, 1 ) );
1383
1450
  }
1384
1451
 
1385
1452
  /* Returns the element at row 1 and column 2.
@@ -1389,9 +1456,9 @@ RMtx3_get_e12( VALUE self )
1389
1456
  {
1390
1457
  RMtx3* m;
1391
1458
 
1392
- Data_Get_Struct( self, RMtx3, m );
1459
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1393
1460
 
1394
- return DOUBLE2NUM( RMtx3GetElement( m, 1, 2 ) );
1461
+ return DBL2NUM( RMtx3GetElement( m, 1, 2 ) );
1395
1462
  }
1396
1463
 
1397
1464
  /* Returns the element at row 2 and column 0.
@@ -1401,9 +1468,9 @@ RMtx3_get_e20( VALUE self )
1401
1468
  {
1402
1469
  RMtx3* m;
1403
1470
 
1404
- Data_Get_Struct( self, RMtx3, m );
1471
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1405
1472
 
1406
- return DOUBLE2NUM( RMtx3GetElement( m, 2, 0 ) );
1473
+ return DBL2NUM( RMtx3GetElement( m, 2, 0 ) );
1407
1474
  }
1408
1475
 
1409
1476
  /* Returns the element at row 2 and column 1.
@@ -1413,9 +1480,9 @@ RMtx3_get_e21( VALUE self )
1413
1480
  {
1414
1481
  RMtx3* m;
1415
1482
 
1416
- Data_Get_Struct( self, RMtx3, m );
1483
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1417
1484
 
1418
- return DOUBLE2NUM( RMtx3GetElement( m, 2, 1 ) );
1485
+ return DBL2NUM( RMtx3GetElement( m, 2, 1 ) );
1419
1486
  }
1420
1487
 
1421
1488
  /* Returns the element at row 2 and column 2.
@@ -1425,9 +1492,9 @@ RMtx3_get_e22( VALUE self )
1425
1492
  {
1426
1493
  RMtx3* m;
1427
1494
 
1428
- Data_Get_Struct( self, RMtx3, m );
1495
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1429
1496
 
1430
- return DOUBLE2NUM( RMtx3GetElement( m, 2, 2 ) );
1497
+ return DBL2NUM( RMtx3GetElement( m, 2, 2 ) );
1431
1498
  }
1432
1499
 
1433
1500
 
@@ -1438,7 +1505,7 @@ RMtx3_set_e00( VALUE self, VALUE f )
1438
1505
  {
1439
1506
  RMtx3* m;
1440
1507
 
1441
- Data_Get_Struct( self, RMtx3, m );
1508
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1442
1509
 
1443
1510
  RMtx3SetElement( m, 0, 0, NUM2DBL(f) );
1444
1511
 
@@ -1452,7 +1519,7 @@ RMtx3_set_e01( VALUE self, VALUE f )
1452
1519
  {
1453
1520
  RMtx3* m;
1454
1521
 
1455
- Data_Get_Struct( self, RMtx3, m );
1522
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1456
1523
 
1457
1524
  RMtx3SetElement( m, 0, 1, NUM2DBL(f) );
1458
1525
 
@@ -1466,7 +1533,7 @@ RMtx3_set_e02( VALUE self, VALUE f )
1466
1533
  {
1467
1534
  RMtx3* m;
1468
1535
 
1469
- Data_Get_Struct( self, RMtx3, m );
1536
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1470
1537
 
1471
1538
  RMtx3SetElement( m, 0, 2, NUM2DBL(f) );
1472
1539
 
@@ -1480,7 +1547,7 @@ RMtx3_set_e10( VALUE self, VALUE f )
1480
1547
  {
1481
1548
  RMtx3* m;
1482
1549
 
1483
- Data_Get_Struct( self, RMtx3, m );
1550
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1484
1551
 
1485
1552
  RMtx3SetElement( m, 1, 0, NUM2DBL(f) );
1486
1553
 
@@ -1494,7 +1561,7 @@ RMtx3_set_e11( VALUE self, VALUE f )
1494
1561
  {
1495
1562
  RMtx3* m;
1496
1563
 
1497
- Data_Get_Struct( self, RMtx3, m );
1564
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1498
1565
 
1499
1566
  RMtx3SetElement( m, 1, 1, NUM2DBL(f) );
1500
1567
 
@@ -1508,7 +1575,7 @@ RMtx3_set_e12( VALUE self, VALUE f )
1508
1575
  {
1509
1576
  RMtx3* m;
1510
1577
 
1511
- Data_Get_Struct( self, RMtx3, m );
1578
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1512
1579
 
1513
1580
  RMtx3SetElement( m, 1, 2, NUM2DBL(f) );
1514
1581
 
@@ -1522,7 +1589,7 @@ RMtx3_set_e20( VALUE self, VALUE f )
1522
1589
  {
1523
1590
  RMtx3* m;
1524
1591
 
1525
- Data_Get_Struct( self, RMtx3, m );
1592
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1526
1593
 
1527
1594
  RMtx3SetElement( m, 2, 0, NUM2DBL(f) );
1528
1595
 
@@ -1536,7 +1603,7 @@ RMtx3_set_e21( VALUE self, VALUE f )
1536
1603
  {
1537
1604
  RMtx3* m;
1538
1605
 
1539
- Data_Get_Struct( self, RMtx3, m );
1606
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1540
1607
 
1541
1608
  RMtx3SetElement( m, 2, 1, NUM2DBL(f) );
1542
1609
 
@@ -1550,7 +1617,7 @@ RMtx3_set_e22( VALUE self, VALUE f )
1550
1617
  {
1551
1618
  RMtx3* m;
1552
1619
 
1553
- Data_Get_Struct( self, RMtx3, m );
1620
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1554
1621
 
1555
1622
  RMtx3SetElement( m, 2, 2, NUM2DBL(f) );
1556
1623
 
@@ -1571,7 +1638,7 @@ RMtx3_getRow( VALUE self, VALUE row )
1571
1638
  int at;
1572
1639
  RVec3 out;
1573
1640
 
1574
- Data_Get_Struct( self, RMtx3, m );
1641
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1575
1642
  at = FIX2INT(row);
1576
1643
  RMtx3GetRow( &out, m, at );
1577
1644
 
@@ -1590,7 +1657,7 @@ RMtx3_getColumn( VALUE self, VALUE column )
1590
1657
  int at;
1591
1658
  RVec3 out;
1592
1659
 
1593
- Data_Get_Struct( self, RMtx3, m );
1660
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1594
1661
  at = FIX2INT(column);
1595
1662
  RMtx3GetColumn( &out, m, at );
1596
1663
 
@@ -1610,8 +1677,8 @@ RMtx3_setRow( VALUE self, VALUE v, VALUE row )
1610
1677
  RVec3* in;
1611
1678
  int at;
1612
1679
 
1613
- Data_Get_Struct( self, RMtx3, m );
1614
- Data_Get_Struct( v, RVec3, in );
1680
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1681
+ TypedData_Get_Struct( v, RVec3, &RVec3_type, in );
1615
1682
  at = FIX2INT(row);
1616
1683
  RMtx3SetRow( m, in, at );
1617
1684
 
@@ -1631,8 +1698,8 @@ RMtx3_setColumn( VALUE self, VALUE v, VALUE column )
1631
1698
  RVec3* in;
1632
1699
  int at;
1633
1700
 
1634
- Data_Get_Struct( self, RMtx3, m );
1635
- Data_Get_Struct( v, RVec3, in );
1701
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1702
+ TypedData_Get_Struct( v, RVec3, &RVec3_type, in );
1636
1703
  at = FIX2INT(column);
1637
1704
  RMtx3SetColumn( m, in, at );
1638
1705
 
@@ -1651,7 +1718,7 @@ RMtx3_setZero( VALUE self )
1651
1718
  {
1652
1719
  RMtx3* m = NULL;
1653
1720
 
1654
- Data_Get_Struct( self, RMtx3, m );
1721
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1655
1722
  RMtx3Zero( m );
1656
1723
 
1657
1724
  return self;
@@ -1667,7 +1734,7 @@ RMtx3_setIdentity( VALUE self )
1667
1734
  {
1668
1735
  RMtx3* m = NULL;
1669
1736
 
1670
- Data_Get_Struct( self, RMtx3, m );
1737
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1671
1738
  RMtx3Identity( m );
1672
1739
 
1673
1740
  return self;
@@ -1684,10 +1751,10 @@ RMtx3_getDeterminant( VALUE self )
1684
1751
  RMtx3* m = NULL;
1685
1752
  rmReal f;
1686
1753
 
1687
- Data_Get_Struct( self, RMtx3, m );
1754
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1688
1755
  f = RMtx3Determinant( m );
1689
1756
 
1690
- return DOUBLE2NUM( f );
1757
+ return DBL2NUM( f );
1691
1758
  }
1692
1759
 
1693
1760
  /*
@@ -1701,7 +1768,7 @@ RMtx3_transpose( VALUE self )
1701
1768
  RMtx3* m = NULL;
1702
1769
  RMtx3 out;
1703
1770
 
1704
- Data_Get_Struct( self, RMtx3, m );
1771
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1705
1772
  RMtx3Transpose( &out, m );
1706
1773
 
1707
1774
  return RMtx3_from_source( &out );
@@ -1717,7 +1784,7 @@ RMtx3_transpose_intrusive( VALUE self )
1717
1784
  {
1718
1785
  RMtx3* m = NULL;
1719
1786
 
1720
- Data_Get_Struct( self, RMtx3, m );
1787
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1721
1788
  RMtx3Transpose( m, m );
1722
1789
 
1723
1790
  return self;
@@ -1734,7 +1801,7 @@ RMtx3_inverse( VALUE self )
1734
1801
  RMtx3* m = NULL;
1735
1802
  RMtx3 out;
1736
1803
 
1737
- Data_Get_Struct( self, RMtx3, m );
1804
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1738
1805
  RMtx3Inverse( &out, m );
1739
1806
 
1740
1807
  return RMtx3_from_source( &out );
@@ -1750,7 +1817,7 @@ RMtx3_invert( VALUE self )
1750
1817
  {
1751
1818
  RMtx3* m = NULL;
1752
1819
 
1753
- Data_Get_Struct( self, RMtx3, m );
1820
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1754
1821
  RMtx3Inverse( m, m );
1755
1822
 
1756
1823
  return self;
@@ -1767,7 +1834,7 @@ RMtx3_rotationX( VALUE self, VALUE radian )
1767
1834
  RMtx3* m = NULL;
1768
1835
  rmReal angle_radian;
1769
1836
 
1770
- Data_Get_Struct( self, RMtx3, m );
1837
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1771
1838
  angle_radian = NUM2DBL(radian);
1772
1839
  RMtx3RotationX( m, angle_radian );
1773
1840
 
@@ -1785,7 +1852,7 @@ RMtx3_rotationY( VALUE self, VALUE radian )
1785
1852
  RMtx3* m = NULL;
1786
1853
  rmReal angle_radian;
1787
1854
 
1788
- Data_Get_Struct( self, RMtx3, m );
1855
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1789
1856
  angle_radian = NUM2DBL(radian);
1790
1857
  RMtx3RotationY( m, angle_radian );
1791
1858
 
@@ -1803,7 +1870,7 @@ RMtx3_rotationZ( VALUE self, VALUE radian )
1803
1870
  RMtx3* m = NULL;
1804
1871
  rmReal angle_radian;
1805
1872
 
1806
- Data_Get_Struct( self, RMtx3, m );
1873
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1807
1874
  angle_radian = NUM2DBL(radian);
1808
1875
  RMtx3RotationZ( m, angle_radian );
1809
1876
 
@@ -1822,8 +1889,8 @@ RMtx3_rotationAxis( VALUE self, VALUE axis, VALUE radian )
1822
1889
  RVec3* vAxis = NULL;
1823
1890
  rmReal angle_radian;
1824
1891
 
1825
- Data_Get_Struct( self, RMtx3, m );
1826
- Data_Get_Struct( axis, RVec3, vAxis );
1892
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1893
+ TypedData_Get_Struct( axis, RVec3, &RVec3_type, vAxis );
1827
1894
  angle_radian = NUM2DBL(radian);
1828
1895
  RMtx3RotationAxis( m, vAxis, angle_radian );
1829
1896
 
@@ -1841,8 +1908,8 @@ RMtx3_rotationQuaternion( VALUE self, VALUE quat )
1841
1908
  RMtx3* m = NULL;
1842
1909
  RQuat* q = NULL;
1843
1910
 
1844
- Data_Get_Struct( self, RMtx3, m );
1845
- Data_Get_Struct( quat, RQuat, q );
1911
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1912
+ TypedData_Get_Struct( quat, RQuat, &RQuat_type, q );
1846
1913
  RMtx3RotationQuaternion( m, q );
1847
1914
 
1848
1915
  return self;
@@ -1859,7 +1926,7 @@ RMtx3_scaling( VALUE self, VALUE x, VALUE y, VALUE z )
1859
1926
  RMtx3* m = NULL;
1860
1927
  rmReal sx, sy, sz;
1861
1928
 
1862
- Data_Get_Struct( self, RMtx3, m );
1929
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1863
1930
  sx = NUM2DBL(x);
1864
1931
  sy = NUM2DBL(y);
1865
1932
  sz = NUM2DBL(z);
@@ -1890,7 +1957,7 @@ RMtx3_op_unary_minus( VALUE self )
1890
1957
  RMtx3* m = NULL;
1891
1958
  RMtx3 out;
1892
1959
 
1893
- Data_Get_Struct( self, RMtx3, m );
1960
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m );
1894
1961
  RMtx3Scale( &out, m, (rmReal)(-1) );
1895
1962
 
1896
1963
  return RMtx3_from_source( &out );
@@ -1919,8 +1986,8 @@ RMtx3_op_binary_plus( VALUE self, VALUE other )
1919
1986
  }
1920
1987
  #endif
1921
1988
 
1922
- Data_Get_Struct( self, RMtx3, m1 );
1923
- Data_Get_Struct( other, RMtx3, m2 );
1989
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m1 );
1990
+ TypedData_Get_Struct( other, RMtx3, &RMtx3_type, m2 );
1924
1991
  RMtx3Add( &result, m1, m2 );
1925
1992
 
1926
1993
  return RMtx3_from_source( &result );
@@ -1949,8 +2016,8 @@ RMtx3_op_binary_minus( VALUE self, VALUE other )
1949
2016
  }
1950
2017
  #endif
1951
2018
 
1952
- Data_Get_Struct( self, RMtx3, m1 );
1953
- Data_Get_Struct( other, RMtx3, m2 );
2019
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m1 );
2020
+ TypedData_Get_Struct( other, RMtx3, &RMtx3_type, m2 );
1954
2021
  RMtx3Sub( &result, m1, m2 );
1955
2022
 
1956
2023
  return RMtx3_from_source( &result );
@@ -1969,11 +2036,11 @@ RMtx3_op_binary_mult( VALUE self, VALUE other )
1969
2036
  rmReal f;
1970
2037
  RMtx3 result;
1971
2038
 
1972
- Data_Get_Struct( self, RMtx3, m1 );
2039
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m1 );
1973
2040
 
1974
2041
  if ( IsRMtx3(other) )
1975
2042
  {
1976
- Data_Get_Struct( other, RMtx3, m2 );
2043
+ TypedData_Get_Struct( other, RMtx3, &RMtx3_type, m2 );
1977
2044
  RMtx3Mul( &result, m1, m2 );
1978
2045
  }
1979
2046
  else
@@ -2007,8 +2074,8 @@ RMtx3_op_binary_eq( VALUE self, VALUE other )
2007
2074
  }
2008
2075
  #endif
2009
2076
 
2010
- Data_Get_Struct( self, RMtx3, m1 );
2011
- Data_Get_Struct( other, RMtx3, m2 );
2077
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m1 );
2078
+ TypedData_Get_Struct( other, RMtx3, &RMtx3_type, m2 );
2012
2079
 
2013
2080
  if ( !RMtx3Equal(m1,m2) )
2014
2081
  return Qfalse;
@@ -2038,8 +2105,8 @@ RMtx3_op_assign_plus( VALUE self, VALUE other )
2038
2105
  }
2039
2106
  #endif
2040
2107
 
2041
- Data_Get_Struct( self, RMtx3, m1 );
2042
- Data_Get_Struct( other, RMtx3, m2 );
2108
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m1 );
2109
+ TypedData_Get_Struct( other, RMtx3, &RMtx3_type, m2 );
2043
2110
  RMtx3Add( m1, m1, m2 );
2044
2111
 
2045
2112
  return self;
@@ -2067,8 +2134,8 @@ RMtx3_op_assign_minus( VALUE self, VALUE other )
2067
2134
  }
2068
2135
  #endif
2069
2136
 
2070
- Data_Get_Struct( self, RMtx3, m1 );
2071
- Data_Get_Struct( other, RMtx3, m2 );
2137
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m1 );
2138
+ TypedData_Get_Struct( other, RMtx3, &RMtx3_type, m2 );
2072
2139
  RMtx3Sub( m1, m1, m2 );
2073
2140
 
2074
2141
  return self;
@@ -2086,11 +2153,11 @@ RMtx3_op_assign_mult( VALUE self, VALUE other )
2086
2153
  RMtx3* m2 = NULL;
2087
2154
  rmReal f;
2088
2155
 
2089
- Data_Get_Struct( self, RMtx3, m1 );
2156
+ TypedData_Get_Struct( self, RMtx3, &RMtx3_type, m1 );
2090
2157
 
2091
2158
  if ( IsRMtx3(other) )
2092
2159
  {
2093
- Data_Get_Struct( other, RMtx3, m2 );
2160
+ TypedData_Get_Struct( other, RMtx3, &RMtx3_type, m2 );
2094
2161
  RMtx3Mul( m1, m1, m2 );
2095
2162
  }
2096
2163
  else
@@ -2110,7 +2177,7 @@ RMtx3_op_assign_mult( VALUE self, VALUE other )
2110
2177
  ********************************************************************************/
2111
2178
 
2112
2179
  /*
2113
- * Document-class: RMath::RMtx4
2180
+ * Document-class: RMath3D::RMtx4
2114
2181
  * provies 4x4 matrix arithmetic.
2115
2182
  *
2116
2183
  * <b>Notice</b>
@@ -2123,25 +2190,27 @@ RMtx4_free( void* ptr )
2123
2190
  xfree( ptr );
2124
2191
  }
2125
2192
 
2193
+ static size_t
2194
+ RMtx4_memsize( const void* ptr )
2195
+ {
2196
+ const struct RMtx4* data = ptr;
2197
+ return data ? sizeof(*data) : 0;
2198
+ }
2199
+
2126
2200
  static VALUE
2127
2201
  RMtx4_from_source( RMtx4* src )
2128
2202
  {
2129
- RMtx4* v = ALLOC( RMtx4 );
2130
-
2203
+ RMtx4* v = ZALLOC( struct RMtx4 );
2131
2204
  RMtx4Copy( v, src );
2132
-
2133
- return Data_Wrap_Struct( rb_cRMtx4, NULL, RMtx4_free, v );
2205
+ return TypedData_Wrap_Struct( rb_cRMtx4, &RMtx4_type, v );
2134
2206
  }
2135
2207
 
2136
2208
 
2137
2209
  static VALUE
2138
2210
  RMtx4_allocate( VALUE klass )
2139
2211
  {
2140
- RMtx4* v = ALLOC( RMtx4 );
2141
-
2142
- memset( v, 0, sizeof(RMtx4) );
2143
-
2144
- return Data_Wrap_Struct( klass, NULL, RMtx4_free, v );
2212
+ RMtx4* v = ZALLOC( RMtx4 );
2213
+ return TypedData_Wrap_Struct( klass, &RMtx4_type, v );
2145
2214
  }
2146
2215
 
2147
2216
 
@@ -2158,7 +2227,7 @@ static VALUE
2158
2227
  RMtx4_initialize( int argc, VALUE* argv, VALUE self )
2159
2228
  {
2160
2229
  RMtx4* v = NULL;
2161
- Data_Get_Struct( self, RMtx4, v );
2230
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, v );
2162
2231
 
2163
2232
  switch( argc )
2164
2233
  {
@@ -2195,7 +2264,7 @@ RMtx4_initialize( int argc, VALUE* argv, VALUE self )
2195
2264
  {
2196
2265
  /* Copy Constructor */
2197
2266
  RMtx4* other;
2198
- Data_Get_Struct( arg , RMtx4, other );
2267
+ TypedData_Get_Struct( arg , RMtx4, &RMtx4_type, other );
2199
2268
  RMtx4Copy( v, other );
2200
2269
  return self;
2201
2270
  }
@@ -2276,7 +2345,7 @@ RMtx4_to_s( VALUE self )
2276
2345
  int row, col, n;
2277
2346
  rmReal val;
2278
2347
 
2279
- Data_Get_Struct( self, RMtx4, v );
2348
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, v );
2280
2349
 
2281
2350
  p = dest;
2282
2351
  for ( row = 0; row < 4; ++row )
@@ -2322,7 +2391,7 @@ RMtx4_to_a( VALUE self )
2322
2391
  int row, col;
2323
2392
  RMtx4* v = NULL;
2324
2393
  VALUE dbl[16];
2325
- Data_Get_Struct( self, RMtx4, v );
2394
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, v );
2326
2395
 
2327
2396
  /* column-major */
2328
2397
  for ( col = 0; col < 4; ++col )
@@ -2330,7 +2399,7 @@ RMtx4_to_a( VALUE self )
2330
2399
  for ( row = 0; row < 4; ++row )
2331
2400
  {
2332
2401
  int i = 4*col + row;
2333
- dbl[i] = DOUBLE2NUM(RMtx4GetElement(v,row,col));
2402
+ dbl[i] = DBL2NUM(RMtx4GetElement(v,row,col));
2334
2403
  }
2335
2404
  }
2336
2405
 
@@ -2346,7 +2415,7 @@ static VALUE
2346
2415
  RMtx4_coerce( VALUE self, VALUE other )
2347
2416
  {
2348
2417
  RMtx4* v = NULL;
2349
- Data_Get_Struct( self, RMtx4, v );
2418
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, v );
2350
2419
 
2351
2420
  switch( TYPE(other) )
2352
2421
  {
@@ -2393,7 +2462,7 @@ RMtx4_setElements( int argc, VALUE* argv, VALUE self )
2393
2462
  }
2394
2463
  #endif
2395
2464
 
2396
- Data_Get_Struct( self, RMtx4, m );
2465
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2397
2466
  for ( row = 0; row < 4; ++row )
2398
2467
  {
2399
2468
  for ( col = 0; col < 4; ++col )
@@ -2418,7 +2487,7 @@ RMtx4_setElement( VALUE self, VALUE r, VALUE c, VALUE f )
2418
2487
  int row, col;
2419
2488
  rmReal flt;
2420
2489
 
2421
- Data_Get_Struct( self, RMtx4, m );
2490
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2422
2491
  row = FIX2INT(r);
2423
2492
  col = FIX2INT(c);
2424
2493
  flt = NUM2DBL(f);
@@ -2440,12 +2509,12 @@ RMtx4_getElement( VALUE self, VALUE r, VALUE c )
2440
2509
  int row, col;
2441
2510
  rmReal flt;
2442
2511
 
2443
- Data_Get_Struct( self, RMtx4, m );
2512
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2444
2513
  row = FIX2INT(r);
2445
2514
  col = FIX2INT(c);
2446
2515
  flt = RMtx4GetElement( m, row, col );
2447
2516
 
2448
- return DOUBLE2NUM( flt );
2517
+ return DBL2NUM( flt );
2449
2518
  }
2450
2519
 
2451
2520
  /* Returns the element at row 0 and column 0.
@@ -2455,9 +2524,9 @@ RMtx4_get_e00( VALUE self )
2455
2524
  {
2456
2525
  RMtx4* m;
2457
2526
 
2458
- Data_Get_Struct( self, RMtx4, m );
2527
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2459
2528
 
2460
- return DOUBLE2NUM( RMtx4GetElement( m, 0, 0 ) );
2529
+ return DBL2NUM( RMtx4GetElement( m, 0, 0 ) );
2461
2530
  }
2462
2531
 
2463
2532
 
@@ -2468,9 +2537,9 @@ RMtx4_get_e01( VALUE self )
2468
2537
  {
2469
2538
  RMtx4* m;
2470
2539
 
2471
- Data_Get_Struct( self, RMtx4, m );
2540
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2472
2541
 
2473
- return DOUBLE2NUM( RMtx4GetElement( m, 0, 1 ) );
2542
+ return DBL2NUM( RMtx4GetElement( m, 0, 1 ) );
2474
2543
  }
2475
2544
 
2476
2545
 
@@ -2481,9 +2550,9 @@ RMtx4_get_e02( VALUE self )
2481
2550
  {
2482
2551
  RMtx4* m;
2483
2552
 
2484
- Data_Get_Struct( self, RMtx4, m );
2553
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2485
2554
 
2486
- return DOUBLE2NUM( RMtx4GetElement( m, 0, 2 ) );
2555
+ return DBL2NUM( RMtx4GetElement( m, 0, 2 ) );
2487
2556
  }
2488
2557
 
2489
2558
 
@@ -2494,9 +2563,9 @@ RMtx4_get_e03( VALUE self )
2494
2563
  {
2495
2564
  RMtx4* m;
2496
2565
 
2497
- Data_Get_Struct( self, RMtx4, m );
2566
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2498
2567
 
2499
- return DOUBLE2NUM( RMtx4GetElement( m, 0, 3 ) );
2568
+ return DBL2NUM( RMtx4GetElement( m, 0, 3 ) );
2500
2569
  }
2501
2570
 
2502
2571
 
@@ -2507,9 +2576,9 @@ RMtx4_get_e10( VALUE self )
2507
2576
  {
2508
2577
  RMtx4* m;
2509
2578
 
2510
- Data_Get_Struct( self, RMtx4, m );
2579
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2511
2580
 
2512
- return DOUBLE2NUM( RMtx4GetElement( m, 1, 0 ) );
2581
+ return DBL2NUM( RMtx4GetElement( m, 1, 0 ) );
2513
2582
  }
2514
2583
 
2515
2584
 
@@ -2520,9 +2589,9 @@ RMtx4_get_e11( VALUE self )
2520
2589
  {
2521
2590
  RMtx4* m;
2522
2591
 
2523
- Data_Get_Struct( self, RMtx4, m );
2592
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2524
2593
 
2525
- return DOUBLE2NUM( RMtx4GetElement( m, 1, 1 ) );
2594
+ return DBL2NUM( RMtx4GetElement( m, 1, 1 ) );
2526
2595
  }
2527
2596
 
2528
2597
 
@@ -2533,9 +2602,9 @@ RMtx4_get_e12( VALUE self )
2533
2602
  {
2534
2603
  RMtx4* m;
2535
2604
 
2536
- Data_Get_Struct( self, RMtx4, m );
2605
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2537
2606
 
2538
- return DOUBLE2NUM( RMtx4GetElement( m, 1, 2 ) );
2607
+ return DBL2NUM( RMtx4GetElement( m, 1, 2 ) );
2539
2608
  }
2540
2609
 
2541
2610
 
@@ -2546,9 +2615,9 @@ RMtx4_get_e13( VALUE self )
2546
2615
  {
2547
2616
  RMtx4* m;
2548
2617
 
2549
- Data_Get_Struct( self, RMtx4, m );
2618
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2550
2619
 
2551
- return DOUBLE2NUM( RMtx4GetElement( m, 1, 3 ) );
2620
+ return DBL2NUM( RMtx4GetElement( m, 1, 3 ) );
2552
2621
  }
2553
2622
 
2554
2623
 
@@ -2559,9 +2628,9 @@ RMtx4_get_e20( VALUE self )
2559
2628
  {
2560
2629
  RMtx4* m;
2561
2630
 
2562
- Data_Get_Struct( self, RMtx4, m );
2631
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2563
2632
 
2564
- return DOUBLE2NUM( RMtx4GetElement( m, 2, 0 ) );
2633
+ return DBL2NUM( RMtx4GetElement( m, 2, 0 ) );
2565
2634
  }
2566
2635
 
2567
2636
 
@@ -2572,9 +2641,9 @@ RMtx4_get_e21( VALUE self )
2572
2641
  {
2573
2642
  RMtx4* m;
2574
2643
 
2575
- Data_Get_Struct( self, RMtx4, m );
2644
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2576
2645
 
2577
- return DOUBLE2NUM( RMtx4GetElement( m, 2, 1 ) );
2646
+ return DBL2NUM( RMtx4GetElement( m, 2, 1 ) );
2578
2647
  }
2579
2648
 
2580
2649
 
@@ -2585,9 +2654,9 @@ RMtx4_get_e22( VALUE self )
2585
2654
  {
2586
2655
  RMtx4* m;
2587
2656
 
2588
- Data_Get_Struct( self, RMtx4, m );
2657
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2589
2658
 
2590
- return DOUBLE2NUM( RMtx4GetElement( m, 2, 2 ) );
2659
+ return DBL2NUM( RMtx4GetElement( m, 2, 2 ) );
2591
2660
  }
2592
2661
 
2593
2662
 
@@ -2598,9 +2667,9 @@ RMtx4_get_e23( VALUE self )
2598
2667
  {
2599
2668
  RMtx4* m;
2600
2669
 
2601
- Data_Get_Struct( self, RMtx4, m );
2670
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2602
2671
 
2603
- return DOUBLE2NUM( RMtx4GetElement( m, 2, 3 ) );
2672
+ return DBL2NUM( RMtx4GetElement( m, 2, 3 ) );
2604
2673
  }
2605
2674
 
2606
2675
 
@@ -2611,9 +2680,9 @@ RMtx4_get_e30( VALUE self )
2611
2680
  {
2612
2681
  RMtx4* m;
2613
2682
 
2614
- Data_Get_Struct( self, RMtx4, m );
2683
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2615
2684
 
2616
- return DOUBLE2NUM( RMtx4GetElement( m, 3, 0 ) );
2685
+ return DBL2NUM( RMtx4GetElement( m, 3, 0 ) );
2617
2686
  }
2618
2687
 
2619
2688
 
@@ -2624,9 +2693,9 @@ RMtx4_get_e31( VALUE self )
2624
2693
  {
2625
2694
  RMtx4* m;
2626
2695
 
2627
- Data_Get_Struct( self, RMtx4, m );
2696
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2628
2697
 
2629
- return DOUBLE2NUM( RMtx4GetElement( m, 3, 1 ) );
2698
+ return DBL2NUM( RMtx4GetElement( m, 3, 1 ) );
2630
2699
  }
2631
2700
 
2632
2701
 
@@ -2637,9 +2706,9 @@ RMtx4_get_e32( VALUE self )
2637
2706
  {
2638
2707
  RMtx4* m;
2639
2708
 
2640
- Data_Get_Struct( self, RMtx4, m );
2709
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2641
2710
 
2642
- return DOUBLE2NUM( RMtx4GetElement( m, 3, 2 ) );
2711
+ return DBL2NUM( RMtx4GetElement( m, 3, 2 ) );
2643
2712
  }
2644
2713
 
2645
2714
 
@@ -2650,9 +2719,9 @@ RMtx4_get_e33( VALUE self )
2650
2719
  {
2651
2720
  RMtx4* m;
2652
2721
 
2653
- Data_Get_Struct( self, RMtx4, m );
2722
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2654
2723
 
2655
- return DOUBLE2NUM( RMtx4GetElement( m, 3, 3 ) );
2724
+ return DBL2NUM( RMtx4GetElement( m, 3, 3 ) );
2656
2725
  }
2657
2726
 
2658
2727
  /* Replaces the element at row 0 and column 0 by +value+.
@@ -2662,7 +2731,7 @@ RMtx4_set_e00( VALUE self, VALUE f )
2662
2731
  {
2663
2732
  RMtx4* m;
2664
2733
 
2665
- Data_Get_Struct( self, RMtx4, m );
2734
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2666
2735
 
2667
2736
  RMtx4SetElement( m, 0, 0, NUM2DBL(f) );
2668
2737
 
@@ -2677,7 +2746,7 @@ RMtx4_set_e01( VALUE self, VALUE f )
2677
2746
  {
2678
2747
  RMtx4* m;
2679
2748
 
2680
- Data_Get_Struct( self, RMtx4, m );
2749
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2681
2750
 
2682
2751
  RMtx4SetElement( m, 0, 1, NUM2DBL(f) );
2683
2752
 
@@ -2692,7 +2761,7 @@ RMtx4_set_e02( VALUE self, VALUE f )
2692
2761
  {
2693
2762
  RMtx4* m;
2694
2763
 
2695
- Data_Get_Struct( self, RMtx4, m );
2764
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2696
2765
 
2697
2766
  RMtx4SetElement( m, 0, 2, NUM2DBL(f) );
2698
2767
 
@@ -2707,7 +2776,7 @@ RMtx4_set_e03( VALUE self, VALUE f )
2707
2776
  {
2708
2777
  RMtx4* m;
2709
2778
 
2710
- Data_Get_Struct( self, RMtx4, m );
2779
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2711
2780
 
2712
2781
  RMtx4SetElement( m, 0, 3, NUM2DBL(f) );
2713
2782
 
@@ -2722,7 +2791,7 @@ RMtx4_set_e10( VALUE self, VALUE f )
2722
2791
  {
2723
2792
  RMtx4* m;
2724
2793
 
2725
- Data_Get_Struct( self, RMtx4, m );
2794
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2726
2795
 
2727
2796
  RMtx4SetElement( m, 1, 0, NUM2DBL(f) );
2728
2797
 
@@ -2737,7 +2806,7 @@ RMtx4_set_e11( VALUE self, VALUE f )
2737
2806
  {
2738
2807
  RMtx4* m;
2739
2808
 
2740
- Data_Get_Struct( self, RMtx4, m );
2809
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2741
2810
 
2742
2811
  RMtx4SetElement( m, 1, 1, NUM2DBL(f) );
2743
2812
 
@@ -2752,7 +2821,7 @@ RMtx4_set_e12( VALUE self, VALUE f )
2752
2821
  {
2753
2822
  RMtx4* m;
2754
2823
 
2755
- Data_Get_Struct( self, RMtx4, m );
2824
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2756
2825
 
2757
2826
  RMtx4SetElement( m, 1, 2, NUM2DBL(f) );
2758
2827
 
@@ -2767,7 +2836,7 @@ RMtx4_set_e13( VALUE self, VALUE f )
2767
2836
  {
2768
2837
  RMtx4* m;
2769
2838
 
2770
- Data_Get_Struct( self, RMtx4, m );
2839
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2771
2840
 
2772
2841
  RMtx4SetElement( m, 1, 3, NUM2DBL(f) );
2773
2842
 
@@ -2782,7 +2851,7 @@ RMtx4_set_e20( VALUE self, VALUE f )
2782
2851
  {
2783
2852
  RMtx4* m;
2784
2853
 
2785
- Data_Get_Struct( self, RMtx4, m );
2854
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2786
2855
 
2787
2856
  RMtx4SetElement( m, 2, 0, NUM2DBL(f) );
2788
2857
 
@@ -2797,7 +2866,7 @@ RMtx4_set_e21( VALUE self, VALUE f )
2797
2866
  {
2798
2867
  RMtx4* m;
2799
2868
 
2800
- Data_Get_Struct( self, RMtx4, m );
2869
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2801
2870
 
2802
2871
  RMtx4SetElement( m, 2, 1, NUM2DBL(f) );
2803
2872
 
@@ -2812,7 +2881,7 @@ RMtx4_set_e22( VALUE self, VALUE f )
2812
2881
  {
2813
2882
  RMtx4* m;
2814
2883
 
2815
- Data_Get_Struct( self, RMtx4, m );
2884
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2816
2885
 
2817
2886
  RMtx4SetElement( m, 2, 2, NUM2DBL(f) );
2818
2887
 
@@ -2827,7 +2896,7 @@ RMtx4_set_e23( VALUE self, VALUE f )
2827
2896
  {
2828
2897
  RMtx4* m;
2829
2898
 
2830
- Data_Get_Struct( self, RMtx4, m );
2899
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2831
2900
 
2832
2901
  RMtx4SetElement( m, 2, 3, NUM2DBL(f) );
2833
2902
 
@@ -2842,7 +2911,7 @@ RMtx4_set_e30( VALUE self, VALUE f )
2842
2911
  {
2843
2912
  RMtx4* m;
2844
2913
 
2845
- Data_Get_Struct( self, RMtx4, m );
2914
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2846
2915
 
2847
2916
  RMtx4SetElement( m, 3, 0, NUM2DBL(f) );
2848
2917
 
@@ -2857,7 +2926,7 @@ RMtx4_set_e31( VALUE self, VALUE f )
2857
2926
  {
2858
2927
  RMtx4* m;
2859
2928
 
2860
- Data_Get_Struct( self, RMtx4, m );
2929
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2861
2930
 
2862
2931
  RMtx4SetElement( m, 3, 1, NUM2DBL(f) );
2863
2932
 
@@ -2872,7 +2941,7 @@ RMtx4_set_e32( VALUE self, VALUE f )
2872
2941
  {
2873
2942
  RMtx4* m;
2874
2943
 
2875
- Data_Get_Struct( self, RMtx4, m );
2944
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2876
2945
 
2877
2946
  RMtx4SetElement( m, 3, 2, NUM2DBL(f) );
2878
2947
 
@@ -2887,7 +2956,7 @@ RMtx4_set_e33( VALUE self, VALUE f )
2887
2956
  {
2888
2957
  RMtx4* m;
2889
2958
 
2890
- Data_Get_Struct( self, RMtx4, m );
2959
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2891
2960
 
2892
2961
  RMtx4SetElement( m, 3, 3, NUM2DBL(f) );
2893
2962
 
@@ -2907,7 +2976,7 @@ RMtx4_getRow( VALUE self, VALUE row )
2907
2976
  int at;
2908
2977
  RVec4 out;
2909
2978
 
2910
- Data_Get_Struct( self, RMtx4, m );
2979
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2911
2980
  at = FIX2INT(row);
2912
2981
  RMtx4GetRow( &out, m, at );
2913
2982
 
@@ -2926,7 +2995,7 @@ RMtx4_getColumn( VALUE self, VALUE column )
2926
2995
  int at;
2927
2996
  RVec4 out;
2928
2997
 
2929
- Data_Get_Struct( self, RMtx4, m );
2998
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
2930
2999
  at = FIX2INT(column);
2931
3000
  RMtx4GetColumn( &out, m, at );
2932
3001
 
@@ -2946,8 +3015,8 @@ RMtx4_setRow( VALUE self, VALUE v, VALUE row )
2946
3015
  RVec4* in;
2947
3016
  int at;
2948
3017
 
2949
- Data_Get_Struct( self, RMtx4, m );
2950
- Data_Get_Struct( v, RVec4, in );
3018
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3019
+ TypedData_Get_Struct( v, RVec4, &RVec4_type, in );
2951
3020
  at = FIX2INT(row);
2952
3021
  RMtx4SetRow( m, in, at );
2953
3022
 
@@ -2967,8 +3036,8 @@ RMtx4_setColumn( VALUE self, VALUE v, VALUE column )
2967
3036
  RVec4* in;
2968
3037
  int at;
2969
3038
 
2970
- Data_Get_Struct( self, RMtx4, m );
2971
- Data_Get_Struct( v, RVec4, in );
3039
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3040
+ TypedData_Get_Struct( v, RVec4, &RVec4_type, in );
2972
3041
  at = FIX2INT(column);
2973
3042
  RMtx4SetColumn( m, in, at );
2974
3043
 
@@ -2987,7 +3056,7 @@ RMtx4_getUpper3x3( VALUE self )
2987
3056
  RMtx4* mtx4x4 = NULL;
2988
3057
  RMtx3 out;
2989
3058
 
2990
- Data_Get_Struct( self, RMtx4, mtx4x4 );
3059
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, mtx4x4 );
2991
3060
  RMtx4GetUpper3x3( &out, mtx4x4 );
2992
3061
 
2993
3062
  return RMtx3_from_source( &out );
@@ -3005,8 +3074,8 @@ RMtx4_setUpper3x3( VALUE self, VALUE in )
3005
3074
  RMtx3* mtx3x3 = NULL;
3006
3075
  RMtx4* mtx4x4 = NULL;
3007
3076
 
3008
- Data_Get_Struct( in, RMtx3, mtx3x3 );
3009
- Data_Get_Struct( self, RMtx4, mtx4x4 );
3077
+ TypedData_Get_Struct( in, RMtx3, &RMtx3_type, mtx3x3 );
3078
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, mtx4x4 );
3010
3079
  RMtx4SetUpper3x3( mtx4x4, mtx3x3 );
3011
3080
 
3012
3081
  return self;
@@ -3024,7 +3093,7 @@ RMtx4_setZero( VALUE self )
3024
3093
  {
3025
3094
  RMtx4* m = NULL;
3026
3095
 
3027
- Data_Get_Struct( self, RMtx4, m );
3096
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3028
3097
  RMtx4Zero( m );
3029
3098
 
3030
3099
  return self;
@@ -3040,7 +3109,7 @@ RMtx4_setIdentity( VALUE self )
3040
3109
  {
3041
3110
  RMtx4* m = NULL;
3042
3111
 
3043
- Data_Get_Struct( self, RMtx4, m );
3112
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3044
3113
  RMtx4Identity( m );
3045
3114
 
3046
3115
  return self;
@@ -3057,10 +3126,10 @@ RMtx4_getDeterminant( VALUE self )
3057
3126
  RMtx4* m = NULL;
3058
3127
  rmReal f;
3059
3128
 
3060
- Data_Get_Struct( self, RMtx4, m );
3129
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3061
3130
  f = RMtx4Determinant( m );
3062
3131
 
3063
- return DOUBLE2NUM( f );
3132
+ return DBL2NUM( f );
3064
3133
  }
3065
3134
 
3066
3135
  /*
@@ -3074,7 +3143,7 @@ RMtx4_transpose( VALUE self )
3074
3143
  RMtx4* m = NULL;
3075
3144
  RMtx4 out;
3076
3145
 
3077
- Data_Get_Struct( self, RMtx4, m );
3146
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3078
3147
  RMtx4Transpose( &out, m );
3079
3148
 
3080
3149
  return RMtx4_from_source( &out );
@@ -3090,7 +3159,7 @@ RMtx4_transpose_intrusive( VALUE self )
3090
3159
  {
3091
3160
  RMtx4* m = NULL;
3092
3161
 
3093
- Data_Get_Struct( self, RMtx4, m );
3162
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3094
3163
  RMtx4Transpose( m, m );
3095
3164
 
3096
3165
  return self;
@@ -3107,7 +3176,7 @@ RMtx4_inverse( VALUE self )
3107
3176
  RMtx4* m = NULL;
3108
3177
  RMtx4 out;
3109
3178
 
3110
- Data_Get_Struct( self, RMtx4, m );
3179
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3111
3180
  RMtx4Inverse( &out, m );
3112
3181
 
3113
3182
  return RMtx4_from_source( &out );
@@ -3123,7 +3192,7 @@ RMtx4_inverse_intrusive( VALUE self )
3123
3192
  {
3124
3193
  RMtx4* m = NULL;
3125
3194
 
3126
- Data_Get_Struct( self, RMtx4, m );
3195
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3127
3196
  RMtx4Inverse( m, m );
3128
3197
 
3129
3198
  return self;
@@ -3140,7 +3209,7 @@ RMtx4_translation( VALUE self, VALUE x, VALUE y, VALUE z )
3140
3209
  RMtx4* m = NULL;
3141
3210
  rmReal tx, ty, tz;
3142
3211
 
3143
- Data_Get_Struct( self, RMtx4, m );
3212
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3144
3213
  tx = NUM2DBL(x);
3145
3214
  ty = NUM2DBL(y);
3146
3215
  tz = NUM2DBL(z);
@@ -3160,7 +3229,7 @@ RMtx4_rotationX( VALUE self, VALUE radian )
3160
3229
  RMtx4* m = NULL;
3161
3230
  rmReal angle_radian;
3162
3231
 
3163
- Data_Get_Struct( self, RMtx4, m );
3232
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3164
3233
  angle_radian = NUM2DBL(radian);
3165
3234
  RMtx4RotationX( m, angle_radian );
3166
3235
 
@@ -3178,7 +3247,7 @@ RMtx4_rotationY( VALUE self, VALUE radian )
3178
3247
  RMtx4* m = NULL;
3179
3248
  rmReal angle_radian;
3180
3249
 
3181
- Data_Get_Struct( self, RMtx4, m );
3250
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3182
3251
  angle_radian = NUM2DBL(radian);
3183
3252
  RMtx4RotationY( m, angle_radian );
3184
3253
 
@@ -3196,7 +3265,7 @@ RMtx4_rotationZ( VALUE self, VALUE radian )
3196
3265
  RMtx4* m = NULL;
3197
3266
  rmReal angle_radian;
3198
3267
 
3199
- Data_Get_Struct( self, RMtx4, m );
3268
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3200
3269
  angle_radian = NUM2DBL(radian);
3201
3270
  RMtx4RotationZ( m, angle_radian );
3202
3271
 
@@ -3215,8 +3284,8 @@ RMtx4_rotationAxis( VALUE self, VALUE axis, VALUE radian )
3215
3284
  RVec3* vAxis = NULL;
3216
3285
  rmReal angle_radian;
3217
3286
 
3218
- Data_Get_Struct( self, RMtx4, m );
3219
- Data_Get_Struct( axis, RVec3, vAxis );
3287
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3288
+ TypedData_Get_Struct( axis, RVec3, &RVec3_type, vAxis );
3220
3289
  angle_radian = NUM2DBL(radian);
3221
3290
  RMtx4RotationAxis( m, vAxis, angle_radian );
3222
3291
 
@@ -3234,8 +3303,8 @@ RMtx4_rotationQuaternion( VALUE self, VALUE q )
3234
3303
  RMtx4* m = NULL;
3235
3304
  RQuat* quat = NULL;
3236
3305
 
3237
- Data_Get_Struct( self, RMtx4, m );
3238
- Data_Get_Struct( q, RQuat, quat );
3306
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3307
+ TypedData_Get_Struct( q, RQuat, &RQuat_type, quat );
3239
3308
  RMtx4RotationQuaternion( m, quat );
3240
3309
 
3241
3310
  return self;
@@ -3252,7 +3321,7 @@ RMtx4_scaling( VALUE self, VALUE x, VALUE y, VALUE z )
3252
3321
  RMtx4* m = NULL;
3253
3322
  rmReal sx, sy, sz;
3254
3323
 
3255
- Data_Get_Struct( self, RMtx4, m );
3324
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3256
3325
  sx = NUM2DBL(x);
3257
3326
  sy = NUM2DBL(y);
3258
3327
  sz = NUM2DBL(z);
@@ -3277,10 +3346,10 @@ RMtx4_lookAtRH( VALUE self, VALUE e, VALUE a, VALUE u )
3277
3346
  RVec3* at = NULL;
3278
3347
  RVec3* up = NULL;
3279
3348
 
3280
- Data_Get_Struct( self, RMtx4, m );
3281
- Data_Get_Struct( e, RVec3, eye );
3282
- Data_Get_Struct( a, RVec3, at );
3283
- Data_Get_Struct( u, RVec3, up );
3349
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3350
+ TypedData_Get_Struct( e, RVec3, &RVec3_type, eye );
3351
+ TypedData_Get_Struct( a, RVec3, &RVec3_type, at );
3352
+ TypedData_Get_Struct( u, RVec3, &RVec3_type, up );
3284
3353
  RMtx4LookAtRH( m, eye, at, up );
3285
3354
 
3286
3355
  return self;
@@ -3301,7 +3370,7 @@ RMtx4_perspectiveRH( VALUE self, VALUE w, VALUE h, VALUE zn, VALUE zf )
3301
3370
  RMtx4* m = NULL;
3302
3371
  rmReal width, height, znear, zfar;
3303
3372
 
3304
- Data_Get_Struct( self, RMtx4, m );
3373
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3305
3374
  width = NUM2DBL(w);
3306
3375
  height = NUM2DBL(h);
3307
3376
  znear = NUM2DBL(zn);
@@ -3327,7 +3396,7 @@ RMtx4_perspectiveFovRH( VALUE self, VALUE fovy, VALUE asp, VALUE zn, VALUE zf )
3327
3396
  RMtx4* m = NULL;
3328
3397
  rmReal fovy_radian, aspect, znear, zfar;
3329
3398
 
3330
- Data_Get_Struct( self, RMtx4, m );
3399
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3331
3400
  fovy_radian = NUM2DBL(fovy);
3332
3401
  aspect = NUM2DBL(asp);
3333
3402
  znear = NUM2DBL(zn);
@@ -3355,7 +3424,7 @@ RMtx4_perspectiveOffCenterRH( VALUE self, VALUE l, VALUE r, VALUE b, VALUE t, VA
3355
3424
  RMtx4* m = NULL;
3356
3425
  rmReal left, right, bottom, top, znear, zfar;
3357
3426
 
3358
- Data_Get_Struct( self, RMtx4, m );
3427
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3359
3428
  left = NUM2DBL(l);
3360
3429
  right = NUM2DBL(r);
3361
3430
  bottom = NUM2DBL(b);
@@ -3382,7 +3451,7 @@ RMtx4_orthoRH( VALUE self, VALUE w, VALUE h, VALUE zn, VALUE zf )
3382
3451
  RMtx4* m = NULL;
3383
3452
  rmReal width, height, znear, zfar;
3384
3453
 
3385
- Data_Get_Struct( self, RMtx4, m );
3454
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3386
3455
  width = NUM2DBL(w);
3387
3456
  height = NUM2DBL(h);
3388
3457
  znear = NUM2DBL(zn);
@@ -3410,7 +3479,7 @@ RMtx4_orthoOffCenterRH( VALUE self, VALUE l, VALUE r, VALUE b, VALUE t, VALUE zn
3410
3479
  RMtx4* m = NULL;
3411
3480
  rmReal left, right, bottom, top, znear, zfar;
3412
3481
 
3413
- Data_Get_Struct( self, RMtx4, m );
3482
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3414
3483
  left = NUM2DBL(l);
3415
3484
  right = NUM2DBL(r);
3416
3485
  bottom = NUM2DBL(b);
@@ -3444,7 +3513,7 @@ RMtx4_op_unary_minus( VALUE self )
3444
3513
  RMtx4* m = NULL;
3445
3514
  RMtx4 out;
3446
3515
 
3447
- Data_Get_Struct( self, RMtx4, m );
3516
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
3448
3517
  RMtx4Scale( &out, m, (rmReal)(-1) );
3449
3518
 
3450
3519
  return RMtx4_from_source( &out );
@@ -3473,8 +3542,8 @@ RMtx4_op_binary_plus( VALUE self, VALUE other )
3473
3542
  }
3474
3543
  #endif
3475
3544
 
3476
- Data_Get_Struct( self, RMtx4, m1 );
3477
- Data_Get_Struct( other, RMtx4, m2 );
3545
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m1 );
3546
+ TypedData_Get_Struct( other, RMtx4, &RMtx4_type, m2 );
3478
3547
  RMtx4Add( &result, m1, m2 );
3479
3548
 
3480
3549
  return RMtx4_from_source( &result );
@@ -3503,8 +3572,8 @@ RMtx4_op_binary_minus( VALUE self, VALUE other )
3503
3572
  }
3504
3573
  #endif
3505
3574
 
3506
- Data_Get_Struct( self, RMtx4, m1 );
3507
- Data_Get_Struct( other, RMtx4, m2 );
3575
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m1 );
3576
+ TypedData_Get_Struct( other, RMtx4, &RMtx4_type, m2 );
3508
3577
  RMtx4Sub( &result, m1, m2 );
3509
3578
 
3510
3579
  return RMtx4_from_source( &result );
@@ -3523,11 +3592,11 @@ RMtx4_op_binary_mult( VALUE self, VALUE other )
3523
3592
  rmReal f;
3524
3593
  RMtx4 result;
3525
3594
 
3526
- Data_Get_Struct( self, RMtx4, m1 );
3595
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m1 );
3527
3596
 
3528
3597
  if ( IsRMtx4(other) )
3529
3598
  {
3530
- Data_Get_Struct( other, RMtx4, m2 );
3599
+ TypedData_Get_Struct( other, RMtx4, &RMtx4_type, m2 );
3531
3600
  RMtx4Mul( &result, m1, m2 );
3532
3601
  }
3533
3602
  else
@@ -3561,8 +3630,8 @@ RMtx4_op_binary_eq( VALUE self, VALUE other )
3561
3630
  }
3562
3631
  #endif
3563
3632
 
3564
- Data_Get_Struct( self, RMtx4, m1 );
3565
- Data_Get_Struct( other, RMtx4, m2 );
3633
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m1 );
3634
+ TypedData_Get_Struct( other, RMtx4, &RMtx4_type, m2 );
3566
3635
 
3567
3636
  if ( !RMtx4Equal(m1,m2) )
3568
3637
  return Qfalse;
@@ -3592,8 +3661,8 @@ RMtx4_op_assign_plus( VALUE self, VALUE other )
3592
3661
  }
3593
3662
  #endif
3594
3663
 
3595
- Data_Get_Struct( self, RMtx4, m1 );
3596
- Data_Get_Struct( other, RMtx4, m2 );
3664
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m1 );
3665
+ TypedData_Get_Struct( other, RMtx4, &RMtx4_type, m2 );
3597
3666
  RMtx4Add( m1, m1, m2 );
3598
3667
 
3599
3668
  return self;
@@ -3621,8 +3690,8 @@ RMtx4_op_assign_minus( VALUE self, VALUE other )
3621
3690
  }
3622
3691
  #endif
3623
3692
 
3624
- Data_Get_Struct( self, RMtx4, m1 );
3625
- Data_Get_Struct( other, RMtx4, m2 );
3693
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m1 );
3694
+ TypedData_Get_Struct( other, RMtx4, &RMtx4_type, m2 );
3626
3695
  RMtx4Sub( m1, m1, m2 );
3627
3696
 
3628
3697
  return self;
@@ -3640,11 +3709,11 @@ RMtx4_op_assign_mult( VALUE self, VALUE other )
3640
3709
  RMtx4* m2 = NULL;
3641
3710
  rmReal f;
3642
3711
 
3643
- Data_Get_Struct( self, RMtx4, m1 );
3712
+ TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m1 );
3644
3713
 
3645
3714
  if ( IsRMtx4(other) )
3646
3715
  {
3647
- Data_Get_Struct( other, RMtx4, m2 );
3716
+ TypedData_Get_Struct( other, RMtx4, &RMtx4_type, m2 );
3648
3717
  RMtx4Mul( m1, m1, m2 );
3649
3718
  }
3650
3719
  else
@@ -3664,7 +3733,7 @@ RMtx4_op_assign_mult( VALUE self, VALUE other )
3664
3733
  ********************************************************************************/
3665
3734
 
3666
3735
  /*
3667
- * Document-class: RMath::RQuat
3736
+ * Document-class: RMath3D::RQuat
3668
3737
  * provies quaternion arithmetic.
3669
3738
  */
3670
3739
 
@@ -3674,25 +3743,27 @@ RQuat_free( void* ptr )
3674
3743
  xfree( ptr );
3675
3744
  }
3676
3745
 
3746
+ static size_t
3747
+ RQuat_memsize( const void* ptr )
3748
+ {
3749
+ const struct RQuat* data = ptr;
3750
+ return data ? sizeof(*data) : 0;
3751
+ }
3752
+
3677
3753
  static VALUE
3678
3754
  RQuat_from_source( RQuat* src )
3679
3755
  {
3680
- RQuat* v = ALLOC( RQuat );
3681
-
3756
+ RQuat* v = ZALLOC( struct RQuat );
3682
3757
  RQuatCopy( v, src );
3683
-
3684
- return Data_Wrap_Struct( rb_cRQuat, NULL, RQuat_free, v );
3758
+ return TypedData_Wrap_Struct( rb_cRQuat, &RQuat_type, v );
3685
3759
  }
3686
3760
 
3687
3761
 
3688
3762
  static VALUE
3689
3763
  RQuat_allocate( VALUE klass )
3690
3764
  {
3691
- RQuat* v = ALLOC( RQuat );
3692
-
3693
- memset( v, 0, sizeof(RQuat) );
3694
-
3695
- return Data_Wrap_Struct( klass, NULL, RQuat_free, v );
3765
+ RQuat* v = ZALLOC( RQuat );
3766
+ return TypedData_Wrap_Struct( klass, &RQuat_type, v );
3696
3767
  }
3697
3768
 
3698
3769
 
@@ -3709,7 +3780,7 @@ static VALUE
3709
3780
  RQuat_initialize( int argc, VALUE* argv, VALUE self )
3710
3781
  {
3711
3782
  RQuat* v = NULL;
3712
- Data_Get_Struct( self, RQuat, v );
3783
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3713
3784
 
3714
3785
  switch( argc )
3715
3786
  {
@@ -3742,7 +3813,7 @@ RQuat_initialize( int argc, VALUE* argv, VALUE self )
3742
3813
  {
3743
3814
  /* Copy Constructor */
3744
3815
  RQuat* other;
3745
- Data_Get_Struct( arg , RQuat, other );
3816
+ TypedData_Get_Struct( arg , RQuat, &RQuat_type, other );
3746
3817
  RQuatSetElements( v, other->x, other->y, other->z, other->w );
3747
3818
  return self;
3748
3819
  }
@@ -3818,7 +3889,7 @@ RQuat_to_s( VALUE self )
3818
3889
  char dest[128], work[4][32];
3819
3890
  int i;
3820
3891
 
3821
- Data_Get_Struct( self, RQuat, q );
3892
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
3822
3893
 
3823
3894
  for ( i = 0; i < 4; ++i )
3824
3895
  {
@@ -3855,12 +3926,12 @@ RQuat_to_a( VALUE self )
3855
3926
  {
3856
3927
  RQuat* v = NULL;
3857
3928
  VALUE dbl[4];
3858
- Data_Get_Struct( self, RQuat, v );
3929
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3859
3930
 
3860
- dbl[0] = DOUBLE2NUM(RQuatGetElement(v,0));
3861
- dbl[1] = DOUBLE2NUM(RQuatGetElement(v,1));
3862
- dbl[2] = DOUBLE2NUM(RQuatGetElement(v,2));
3863
- dbl[3] = DOUBLE2NUM(RQuatGetElement(v,3));
3931
+ dbl[0] = DBL2NUM(RQuatGetElement(v,0));
3932
+ dbl[1] = DBL2NUM(RQuatGetElement(v,1));
3933
+ dbl[2] = DBL2NUM(RQuatGetElement(v,2));
3934
+ dbl[3] = DBL2NUM(RQuatGetElement(v,3));
3864
3935
 
3865
3936
  return rb_ary_new4( 4, dbl );
3866
3937
  }
@@ -3874,7 +3945,7 @@ static VALUE
3874
3945
  RQuat_coerce( VALUE self, VALUE other )
3875
3946
  {
3876
3947
  RQuat* v = NULL;
3877
- Data_Get_Struct( self, RQuat, v );
3948
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3878
3949
 
3879
3950
  switch( TYPE(other) )
3880
3951
  {
@@ -3913,7 +3984,7 @@ RQuat_setElements( VALUE self, VALUE x, VALUE y, VALUE z, VALUE w )
3913
3984
  RQuat* v = NULL;
3914
3985
  rmReal flt0, flt1, flt2, flt3;
3915
3986
 
3916
- Data_Get_Struct( self, RQuat, v );
3987
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3917
3988
  flt0 = NUM2DBL(x);
3918
3989
  flt1 = NUM2DBL(y);
3919
3990
  flt2 = NUM2DBL(z);
@@ -3936,7 +4007,7 @@ RQuat_setElement( VALUE self, VALUE i, VALUE f )
3936
4007
  int at;
3937
4008
  rmReal flt;
3938
4009
 
3939
- Data_Get_Struct( self, RQuat, v );
4010
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3940
4011
  at = NUM2INT(i);
3941
4012
  flt = NUM2DBL(f);
3942
4013
 
@@ -3956,7 +4027,7 @@ RQuat_setX( VALUE self, VALUE x )
3956
4027
  RQuat* v = NULL;
3957
4028
  rmReal flt0;
3958
4029
 
3959
- Data_Get_Struct( self, RQuat, v );
4030
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3960
4031
  flt0 = NUM2DBL(x);
3961
4032
 
3962
4033
  RQuatSetX( v, flt0 );
@@ -3975,7 +4046,7 @@ RQuat_setY( VALUE self, VALUE y )
3975
4046
  RQuat* v = NULL;
3976
4047
  rmReal flt0;
3977
4048
 
3978
- Data_Get_Struct( self, RQuat, v );
4049
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3979
4050
  flt0 = NUM2DBL(y);
3980
4051
 
3981
4052
  RQuatSetY( v, flt0 );
@@ -3994,7 +4065,7 @@ RQuat_setZ( VALUE self, VALUE z )
3994
4065
  RQuat* v = NULL;
3995
4066
  rmReal flt0;
3996
4067
 
3997
- Data_Get_Struct( self, RQuat, v );
4068
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
3998
4069
  flt0 = NUM2DBL(z);
3999
4070
 
4000
4071
  RQuatSetZ( v, flt0 );
@@ -4013,7 +4084,7 @@ RQuat_setW( VALUE self, VALUE w )
4013
4084
  RQuat* v = NULL;
4014
4085
  rmReal flt0;
4015
4086
 
4016
- Data_Get_Struct( self, RQuat, v );
4087
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4017
4088
  flt0 = NUM2DBL(w);
4018
4089
 
4019
4090
  RQuatSetW( v, flt0 );
@@ -4032,8 +4103,8 @@ RQuat_setXYZ( VALUE self, VALUE xyz )
4032
4103
  RQuat* v = NULL;
4033
4104
  RVec3* in = NULL;
4034
4105
 
4035
- Data_Get_Struct( self, RQuat, v );
4036
- Data_Get_Struct( xyz, RVec3, in );
4106
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4107
+ TypedData_Get_Struct( xyz, RVec3, &RVec3_type, in );
4037
4108
 
4038
4109
  RQuatSetXYZ( v, in );
4039
4110
 
@@ -4052,11 +4123,11 @@ RQuat_getElement( VALUE self, VALUE i )
4052
4123
  int at;
4053
4124
  rmReal flt0;
4054
4125
 
4055
- Data_Get_Struct( self, RQuat, v );
4126
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4056
4127
  at = FIX2INT(i);
4057
4128
  flt0 = RQuatGetElement( v, at );
4058
4129
 
4059
- return DOUBLE2NUM( flt0 );
4130
+ return DBL2NUM( flt0 );
4060
4131
  }
4061
4132
 
4062
4133
  /*
@@ -4070,10 +4141,10 @@ RQuat_getX( VALUE self )
4070
4141
  RQuat* v = NULL;
4071
4142
  rmReal flt0;
4072
4143
 
4073
- Data_Get_Struct( self, RQuat, v );
4144
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4074
4145
  flt0 = RQuatGetX( v );
4075
4146
 
4076
- return DOUBLE2NUM( flt0 );
4147
+ return DBL2NUM( flt0 );
4077
4148
  }
4078
4149
 
4079
4150
  /*
@@ -4087,10 +4158,10 @@ RQuat_getY( VALUE self )
4087
4158
  RQuat* v = NULL;
4088
4159
  rmReal flt0;
4089
4160
 
4090
- Data_Get_Struct( self, RQuat, v );
4161
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4091
4162
  flt0 = RQuatGetY( v );
4092
4163
 
4093
- return DOUBLE2NUM( flt0 );
4164
+ return DBL2NUM( flt0 );
4094
4165
  }
4095
4166
 
4096
4167
  /*
@@ -4104,10 +4175,10 @@ RQuat_getZ( VALUE self )
4104
4175
  RQuat* v = NULL;
4105
4176
  rmReal flt0;
4106
4177
 
4107
- Data_Get_Struct( self, RQuat, v );
4178
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4108
4179
  flt0 = RQuatGetZ( v );
4109
4180
 
4110
- return DOUBLE2NUM( flt0 );
4181
+ return DBL2NUM( flt0 );
4111
4182
  }
4112
4183
 
4113
4184
  /*
@@ -4121,10 +4192,10 @@ RQuat_getW( VALUE self )
4121
4192
  RQuat* v = NULL;
4122
4193
  rmReal flt0;
4123
4194
 
4124
- Data_Get_Struct( self, RQuat, v );
4195
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4125
4196
  flt0 = RQuatGetW( v );
4126
4197
 
4127
- return DOUBLE2NUM( flt0 );
4198
+ return DBL2NUM( flt0 );
4128
4199
  }
4129
4200
 
4130
4201
  /*
@@ -4138,7 +4209,7 @@ RQuat_getXYZ( VALUE self )
4138
4209
  RQuat* v = NULL;
4139
4210
  RVec3 out;
4140
4211
 
4141
- Data_Get_Struct( self, RQuat, v );
4212
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4142
4213
 
4143
4214
  RQuatGetXYZ( &out, v );
4144
4215
 
@@ -4156,10 +4227,10 @@ RQuat_getLength( VALUE self )
4156
4227
  RQuat* v = NULL;
4157
4228
  rmReal flt0;
4158
4229
 
4159
- Data_Get_Struct( self, RQuat, v );
4230
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4160
4231
  flt0 = RQuatLength( v );
4161
4232
 
4162
- return DOUBLE2NUM( flt0 );
4233
+ return DBL2NUM( flt0 );
4163
4234
  }
4164
4235
 
4165
4236
  /*
@@ -4173,10 +4244,10 @@ RQuat_getLengthSq( VALUE self )
4173
4244
  RQuat* v = NULL;
4174
4245
  rmReal flt0;
4175
4246
 
4176
- Data_Get_Struct( self, RQuat, v );
4247
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4177
4248
  flt0 = RQuatLengthSq( v );
4178
4249
 
4179
- return DOUBLE2NUM( flt0 );
4250
+ return DBL2NUM( flt0 );
4180
4251
  }
4181
4252
 
4182
4253
  /*
@@ -4191,11 +4262,11 @@ RQuat_dot( VALUE self, VALUE q1, VALUE q2 )
4191
4262
  RQuat* quat2 = NULL;
4192
4263
  rmReal result;
4193
4264
 
4194
- Data_Get_Struct( q1, RQuat, quat1 );
4195
- Data_Get_Struct( q2, RQuat, quat2 );
4265
+ TypedData_Get_Struct( q1, RQuat, &RQuat_type, quat1 );
4266
+ TypedData_Get_Struct( q2, RQuat, &RQuat_type, quat2 );
4196
4267
  result = RQuatDot( quat1, quat2 );
4197
4268
 
4198
- return DOUBLE2NUM( result );
4269
+ return DBL2NUM( result );
4199
4270
  }
4200
4271
 
4201
4272
  /*
@@ -4212,8 +4283,8 @@ RQuat_slerp( VALUE self, VALUE q1, VALUE q2, VALUE t )
4212
4283
  rmReal time;
4213
4284
  RQuat result;
4214
4285
 
4215
- Data_Get_Struct( q1, RQuat, quat1 );
4216
- Data_Get_Struct( q2, RQuat, quat2 );
4286
+ TypedData_Get_Struct( q1, RQuat, &RQuat_type, quat1 );
4287
+ TypedData_Get_Struct( q2, RQuat, &RQuat_type, quat2 );
4217
4288
  time = NUM2DBL( t );
4218
4289
  RQuatSlerp( &result, quat1, quat2, time );
4219
4290
 
@@ -4230,7 +4301,7 @@ RQuat_setIdentity( VALUE self )
4230
4301
  {
4231
4302
  RQuat* q = NULL;
4232
4303
 
4233
- Data_Get_Struct( self, RQuat, q );
4304
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4234
4305
  RQuatIdentity( q );
4235
4306
 
4236
4307
  return self;
@@ -4247,7 +4318,7 @@ RQuat_conjugate( VALUE self )
4247
4318
  RQuat* q = NULL;
4248
4319
  RQuat out;
4249
4320
 
4250
- Data_Get_Struct( self, RQuat, q );
4321
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4251
4322
  RQuatConjugate( &out, q );
4252
4323
 
4253
4324
  return RQuat_from_source( &out );
@@ -4263,7 +4334,7 @@ RQuat_conjugate_intrusive( VALUE self )
4263
4334
  {
4264
4335
  RQuat* q = NULL;
4265
4336
 
4266
- Data_Get_Struct( self, RQuat, q );
4337
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4267
4338
  RQuatConjugate( q, q );
4268
4339
 
4269
4340
  return self;
@@ -4280,7 +4351,7 @@ RQuat_inverse( VALUE self )
4280
4351
  RQuat* q = NULL;
4281
4352
  RQuat out;
4282
4353
 
4283
- Data_Get_Struct( self, RQuat, q );
4354
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4284
4355
  RQuatInverse( &out, q );
4285
4356
 
4286
4357
  return RQuat_from_source( &out );
@@ -4296,7 +4367,7 @@ RQuat_inverse_intrusive( VALUE self )
4296
4367
  {
4297
4368
  RQuat* q = NULL;
4298
4369
 
4299
- Data_Get_Struct( self, RQuat, q );
4370
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4300
4371
  RQuatInverse( q, q );
4301
4372
 
4302
4373
  return self;
@@ -4313,7 +4384,7 @@ RQuat_normalize( VALUE self )
4313
4384
  RQuat* v = NULL;
4314
4385
  RQuat out;
4315
4386
 
4316
- Data_Get_Struct( self, RQuat, v );
4387
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4317
4388
  RQuatNormalize( &out, v );
4318
4389
 
4319
4390
  return RQuat_from_source( &out );
@@ -4329,7 +4400,7 @@ RQuat_normalize_intrusive( VALUE self )
4329
4400
  {
4330
4401
  RQuat* v = NULL;
4331
4402
 
4332
- Data_Get_Struct( self, RQuat, v );
4403
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4333
4404
  RQuatNormalize( v, v );
4334
4405
 
4335
4406
  return self;
@@ -4357,7 +4428,7 @@ RQuat_op_unary_minus( VALUE self )
4357
4428
  RQuat* v = NULL;
4358
4429
  RQuat out;
4359
4430
 
4360
- Data_Get_Struct( self, RQuat, v );
4431
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4361
4432
  RQuatScale( &out, v, (rmReal)(-1) );
4362
4433
 
4363
4434
  return RQuat_from_source( &out );
@@ -4386,8 +4457,8 @@ RQuat_op_binary_plus( VALUE self, VALUE other )
4386
4457
  }
4387
4458
  #endif
4388
4459
 
4389
- Data_Get_Struct( self, RQuat, v1 );
4390
- Data_Get_Struct( other, RQuat, v2 );
4460
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v1 );
4461
+ TypedData_Get_Struct( other, RQuat, &RQuat_type, v2 );
4391
4462
  RQuatAdd( &result, v1, v2 );
4392
4463
 
4393
4464
  return RQuat_from_source( &result );
@@ -4416,8 +4487,8 @@ RQuat_op_binary_minus( VALUE self, VALUE other )
4416
4487
  }
4417
4488
  #endif
4418
4489
 
4419
- Data_Get_Struct( self, RQuat, v1 );
4420
- Data_Get_Struct( other, RQuat, v2 );
4490
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v1 );
4491
+ TypedData_Get_Struct( other, RQuat, &RQuat_type, v2 );
4421
4492
  RQuatSub( &result, v1, v2 );
4422
4493
 
4423
4494
  return RQuat_from_source( &result );
@@ -4435,11 +4506,11 @@ RQuat_op_binary_mult( VALUE self, VALUE other )
4435
4506
  RQuat result;
4436
4507
  rmReal f;
4437
4508
 
4438
- Data_Get_Struct( self, RQuat, v );
4509
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4439
4510
  if ( IsRQuat(other) )
4440
4511
  {
4441
4512
  RQuat* q = NULL;
4442
- Data_Get_Struct( other, RQuat, q );
4513
+ TypedData_Get_Struct( other, RQuat, &RQuat_type, q );
4443
4514
  RQuatMul( &result, v, q );
4444
4515
 
4445
4516
  return RQuat_from_source( &result );
@@ -4492,8 +4563,8 @@ RQuat_op_binary_eq( VALUE self, VALUE other )
4492
4563
  }
4493
4564
  #endif
4494
4565
 
4495
- Data_Get_Struct( self, RQuat, v1 );
4496
- Data_Get_Struct( other, RQuat, v2 );
4566
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v1 );
4567
+ TypedData_Get_Struct( other, RQuat, &RQuat_type, v2 );
4497
4568
 
4498
4569
  if ( !RQuatEqual(v1,v2) )
4499
4570
  return Qfalse;
@@ -4523,8 +4594,8 @@ RQuat_op_assign_plus( VALUE self, VALUE other )
4523
4594
  }
4524
4595
  #endif
4525
4596
 
4526
- Data_Get_Struct( self, RQuat, v1 );
4527
- Data_Get_Struct( other, RQuat, v2 );
4597
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v1 );
4598
+ TypedData_Get_Struct( other, RQuat, &RQuat_type, v2 );
4528
4599
 
4529
4600
  RQuatAdd( v1, v1, v2 );
4530
4601
 
@@ -4553,8 +4624,8 @@ RQuat_op_assign_minus( VALUE self, VALUE other )
4553
4624
  }
4554
4625
  #endif
4555
4626
 
4556
- Data_Get_Struct( self, RQuat, v1 );
4557
- Data_Get_Struct( other, RQuat, v2 );
4627
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v1 );
4628
+ TypedData_Get_Struct( other, RQuat, &RQuat_type, v2 );
4558
4629
 
4559
4630
  RQuatSub( v1, v1, v2 );
4560
4631
 
@@ -4572,11 +4643,11 @@ RQuat_op_assign_mult( VALUE self, VALUE other )
4572
4643
  RQuat* v = NULL;
4573
4644
  rmReal f;
4574
4645
 
4575
- Data_Get_Struct( self, RQuat, v );
4646
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, v );
4576
4647
  if ( IsRQuat(other) )
4577
4648
  {
4578
4649
  RQuat* q = NULL;
4579
- Data_Get_Struct( other, RQuat, q );
4650
+ TypedData_Get_Struct( other, RQuat, &RQuat_type, q );
4580
4651
  RQuatMul( v, v, q );
4581
4652
 
4582
4653
  return self;
@@ -4611,8 +4682,8 @@ RQuat_rotationMatrix( VALUE self, VALUE mtx )
4611
4682
  RQuat* q = NULL;
4612
4683
  RMtx4* m = NULL;
4613
4684
 
4614
- Data_Get_Struct( self, RQuat, q );
4615
- Data_Get_Struct( mtx, RMtx4, m );
4685
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4686
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
4616
4687
 
4617
4688
  RQuatRotationMatrix( q, m );
4618
4689
 
@@ -4631,8 +4702,8 @@ RQuat_rotationAxis( VALUE self, VALUE axis, VALUE radian )
4631
4702
  RVec3* vAxis = NULL;
4632
4703
  rmReal angle_radian;
4633
4704
 
4634
- Data_Get_Struct( self, RQuat, q );
4635
- Data_Get_Struct( axis, RVec3, vAxis );
4705
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4706
+ TypedData_Get_Struct( axis, RVec3, &RVec3_type, vAxis );
4636
4707
  angle_radian = NUM2DBL( radian );
4637
4708
 
4638
4709
  RQuatRotationAxis( q, vAxis, angle_radian );
@@ -4652,11 +4723,11 @@ RQuat_toAxisAngle( VALUE self )
4652
4723
  RVec3 axis;
4653
4724
  rmReal radian;
4654
4725
 
4655
- Data_Get_Struct( self, RQuat, q );
4726
+ TypedData_Get_Struct( self, RQuat, &RQuat_type, q );
4656
4727
 
4657
4728
  RQuatToAxisAngle( q, &axis, &radian );
4658
4729
 
4659
- return rb_ary_new3( 2, RVec3_from_source(&axis), DOUBLE2NUM(radian) );
4730
+ return rb_ary_new3( 2, RVec3_from_source(&axis), DBL2NUM(radian) );
4660
4731
  }
4661
4732
 
4662
4733
 
@@ -4667,7 +4738,7 @@ RQuat_toAxisAngle( VALUE self )
4667
4738
  ********************************************************************************/
4668
4739
 
4669
4740
  /*
4670
- * Document-class: RMath::RVec2
4741
+ * Document-class: RMath3D::RVec2
4671
4742
  * provies 3 element vector arithmetic.
4672
4743
  */
4673
4744
 
@@ -4677,25 +4748,27 @@ RVec2_free( void* ptr )
4677
4748
  xfree( ptr );
4678
4749
  }
4679
4750
 
4751
+ static size_t
4752
+ RVec2_memsize( const void* ptr )
4753
+ {
4754
+ const struct RVec2* data = ptr;
4755
+ return data ? sizeof(*data) : 0;
4756
+ }
4757
+
4680
4758
  static VALUE
4681
4759
  RVec2_from_source( RVec2* src )
4682
4760
  {
4683
- RVec2* v = ALLOC( RVec2 );
4684
-
4761
+ RVec2* v = ZALLOC( struct RVec2 );
4685
4762
  RVec2Copy( v, src );
4686
-
4687
- return Data_Wrap_Struct( rb_cRVec2, NULL, RVec2_free, v );
4763
+ return TypedData_Wrap_Struct( rb_cRVec2, &RVec2_type, v );
4688
4764
  }
4689
4765
 
4690
4766
 
4691
4767
  static VALUE
4692
4768
  RVec2_allocate( VALUE klass )
4693
4769
  {
4694
- RVec2* v = ALLOC( RVec2 );
4695
-
4696
- memset( v, 0, sizeof(RVec2) );
4697
-
4698
- return Data_Wrap_Struct( klass, NULL, RVec2_free, v );
4770
+ RVec2* v = ZALLOC( RVec2 );
4771
+ return TypedData_Wrap_Struct( klass, &RVec2_type, v );
4699
4772
  }
4700
4773
 
4701
4774
 
@@ -4712,7 +4785,7 @@ static VALUE
4712
4785
  RVec2_initialize( int argc, VALUE* argv, VALUE self )
4713
4786
  {
4714
4787
  RVec2* v = NULL;
4715
- Data_Get_Struct( self, RVec2, v );
4788
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4716
4789
 
4717
4790
  switch( argc )
4718
4791
  {
@@ -4745,7 +4818,7 @@ RVec2_initialize( int argc, VALUE* argv, VALUE self )
4745
4818
  {
4746
4819
  /* Copy Constructor */
4747
4820
  RVec2* other;
4748
- Data_Get_Struct( arg , RVec2, other );
4821
+ TypedData_Get_Struct( arg , RVec2, &RVec2_type, other );
4749
4822
  RVec2SetElements( v, other->x, other->y );
4750
4823
  return self;
4751
4824
  }
@@ -4821,7 +4894,7 @@ RVec2_to_s( VALUE self )
4821
4894
  char dest[128], work[2][32];
4822
4895
  int i;
4823
4896
 
4824
- Data_Get_Struct( self, RVec2, v );
4897
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4825
4898
 
4826
4899
  for ( i = 0; i < 2; ++i )
4827
4900
  {
@@ -4858,10 +4931,10 @@ RVec2_to_a( VALUE self )
4858
4931
  {
4859
4932
  RVec2* v = NULL;
4860
4933
  VALUE dbl[2];
4861
- Data_Get_Struct( self, RVec2, v );
4934
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4862
4935
 
4863
- dbl[0] = DOUBLE2NUM(RVec2GetElement(v,0));
4864
- dbl[1] = DOUBLE2NUM(RVec2GetElement(v,1));
4936
+ dbl[0] = DBL2NUM(RVec2GetElement(v,0));
4937
+ dbl[1] = DBL2NUM(RVec2GetElement(v,1));
4865
4938
 
4866
4939
  return rb_ary_new4( 2, dbl );
4867
4940
  }
@@ -4875,7 +4948,7 @@ static VALUE
4875
4948
  RVec2_coerce( VALUE self, VALUE other )
4876
4949
  {
4877
4950
  RVec2* v = NULL;
4878
- Data_Get_Struct( self, RVec2, v );
4951
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4879
4952
 
4880
4953
  switch( TYPE(other) )
4881
4954
  {
@@ -4914,7 +4987,7 @@ RVec2_setElements( VALUE self, VALUE x, VALUE y )
4914
4987
  RVec2* v = NULL;
4915
4988
  rmReal flt0, flt1;
4916
4989
 
4917
- Data_Get_Struct( self, RVec2, v );
4990
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4918
4991
  flt0 = NUM2DBL(x);
4919
4992
  flt1 = NUM2DBL(y);
4920
4993
 
@@ -4935,7 +5008,7 @@ RVec2_setElement( VALUE self, VALUE i, VALUE f )
4935
5008
  int at;
4936
5009
  rmReal flt;
4937
5010
 
4938
- Data_Get_Struct( self, RVec2, v );
5011
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4939
5012
  at = NUM2INT(i);
4940
5013
  flt = NUM2DBL(f);
4941
5014
 
@@ -4955,7 +5028,7 @@ RVec2_setX( VALUE self, VALUE x )
4955
5028
  RVec2* v = NULL;
4956
5029
  rmReal flt0;
4957
5030
 
4958
- Data_Get_Struct( self, RVec2, v );
5031
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4959
5032
  flt0 = NUM2DBL(x);
4960
5033
 
4961
5034
  RVec2SetX( v, flt0 );
@@ -4974,7 +5047,7 @@ RVec2_setY( VALUE self, VALUE y )
4974
5047
  RVec2* v = NULL;
4975
5048
  rmReal flt0;
4976
5049
 
4977
- Data_Get_Struct( self, RVec2, v );
5050
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4978
5051
  flt0 = NUM2DBL(y);
4979
5052
 
4980
5053
  RVec2SetY( v, flt0 );
@@ -4994,11 +5067,11 @@ RVec2_getElement( VALUE self, VALUE i )
4994
5067
  int at;
4995
5068
  rmReal flt0;
4996
5069
 
4997
- Data_Get_Struct( self, RVec2, v );
5070
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
4998
5071
  at = FIX2INT(i);
4999
5072
  flt0 = RVec2GetElement( v, at );
5000
5073
 
5001
- return DOUBLE2NUM( flt0 );
5074
+ return DBL2NUM( flt0 );
5002
5075
  }
5003
5076
 
5004
5077
  /*
@@ -5012,10 +5085,10 @@ RVec2_getX( VALUE self )
5012
5085
  RVec2* v = NULL;
5013
5086
  rmReal flt0;
5014
5087
 
5015
- Data_Get_Struct( self, RVec2, v );
5088
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5016
5089
  flt0 = RVec2GetX( v );
5017
5090
 
5018
- return DOUBLE2NUM( flt0 );
5091
+ return DBL2NUM( flt0 );
5019
5092
  }
5020
5093
 
5021
5094
  /*
@@ -5029,10 +5102,10 @@ RVec2_getY( VALUE self )
5029
5102
  RVec2* v = NULL;
5030
5103
  rmReal flt0;
5031
5104
 
5032
- Data_Get_Struct( self, RVec2, v );
5105
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5033
5106
  flt0 = RVec2GetY( v );
5034
5107
 
5035
- return DOUBLE2NUM( flt0 );
5108
+ return DBL2NUM( flt0 );
5036
5109
  }
5037
5110
 
5038
5111
  /*
@@ -5046,10 +5119,10 @@ RVec2_getLength( VALUE self )
5046
5119
  RVec2* v = NULL;
5047
5120
  rmReal flt0;
5048
5121
 
5049
- Data_Get_Struct( self, RVec2, v );
5122
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5050
5123
  flt0 = RVec2Length( v );
5051
5124
 
5052
- return DOUBLE2NUM( flt0 );
5125
+ return DBL2NUM( flt0 );
5053
5126
  }
5054
5127
 
5055
5128
  /*
@@ -5063,10 +5136,10 @@ RVec2_getLengthSq( VALUE self )
5063
5136
  RVec2* v = NULL;
5064
5137
  rmReal flt0;
5065
5138
 
5066
- Data_Get_Struct( self, RVec2, v );
5139
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5067
5140
  flt0 = RVec2LengthSq( v );
5068
5141
 
5069
- return DOUBLE2NUM( flt0 );
5142
+ return DBL2NUM( flt0 );
5070
5143
  }
5071
5144
 
5072
5145
  /*
@@ -5081,11 +5154,11 @@ RVec2_dot( VALUE self, VALUE v1, VALUE v2 )
5081
5154
  RVec2* vec2 = NULL;
5082
5155
  rmReal result;
5083
5156
 
5084
- Data_Get_Struct( v1, RVec2, vec1 );
5085
- Data_Get_Struct( v2, RVec2, vec2 );
5157
+ TypedData_Get_Struct( v1, RVec2, &RVec2_type, vec1 );
5158
+ TypedData_Get_Struct( v2, RVec2, &RVec2_type, vec2 );
5086
5159
  result = RVec2Dot( vec1, vec2 );
5087
5160
 
5088
- return DOUBLE2NUM( result );
5161
+ return DBL2NUM( result );
5089
5162
  }
5090
5163
 
5091
5164
  /*
@@ -5100,11 +5173,11 @@ RVec2_cross( VALUE self, VALUE v1, VALUE v2 )
5100
5173
  RVec2* vec2 = NULL;
5101
5174
  rmReal result;
5102
5175
 
5103
- Data_Get_Struct( v1, RVec2, vec1 );
5104
- Data_Get_Struct( v2, RVec2, vec2 );
5176
+ TypedData_Get_Struct( v1, RVec2, &RVec2_type, vec1 );
5177
+ TypedData_Get_Struct( v2, RVec2, &RVec2_type, vec2 );
5105
5178
  result = RVec2Cross( vec1, vec2 );
5106
5179
 
5107
- return DOUBLE2NUM( result );
5180
+ return DBL2NUM( result );
5108
5181
  }
5109
5182
 
5110
5183
  /*
@@ -5120,8 +5193,8 @@ RVec2_transform( VALUE self, VALUE mtx )
5120
5193
  RMtx2* m;
5121
5194
  RVec2 out;
5122
5195
 
5123
- Data_Get_Struct( self, RVec2, v );
5124
- Data_Get_Struct( mtx, RMtx2, m );
5196
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5197
+ TypedData_Get_Struct( mtx, RMtx2, &RMtx2_type, m );
5125
5198
  RVec2Transform( &out, m, v );
5126
5199
 
5127
5200
  return RVec2_from_source( &out );
@@ -5138,7 +5211,7 @@ RVec2_normalize( VALUE self )
5138
5211
  RVec2* v = NULL;
5139
5212
  RVec2 out;
5140
5213
 
5141
- Data_Get_Struct( self, RVec2, v );
5214
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5142
5215
  RVec2Normalize( &out, v );
5143
5216
 
5144
5217
  return RVec2_from_source( &out );
@@ -5154,7 +5227,7 @@ RVec2_normalize_intrusive( VALUE self )
5154
5227
  {
5155
5228
  RVec2* v = NULL;
5156
5229
 
5157
- Data_Get_Struct( self, RVec2, v );
5230
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5158
5231
  RVec2Normalize( v, v );
5159
5232
 
5160
5233
  return self;
@@ -5182,7 +5255,7 @@ RVec2_op_unary_minus( VALUE self )
5182
5255
  RVec2* v = NULL;
5183
5256
  RVec2 out;
5184
5257
 
5185
- Data_Get_Struct( self, RVec2, v );
5258
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5186
5259
  RVec2Scale( &out, v, (rmReal)(-1) );
5187
5260
 
5188
5261
  return RVec2_from_source( &out );
@@ -5211,8 +5284,8 @@ RVec2_op_binary_plus( VALUE self, VALUE other )
5211
5284
  }
5212
5285
  #endif
5213
5286
 
5214
- Data_Get_Struct( self, RVec2, v1 );
5215
- Data_Get_Struct( other, RVec2, v2 );
5287
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v1 );
5288
+ TypedData_Get_Struct( other, RVec2, &RVec2_type, v2 );
5216
5289
  RVec2Add( &result, v1, v2 );
5217
5290
 
5218
5291
  return RVec2_from_source( &result );
@@ -5241,8 +5314,8 @@ RVec2_op_binary_minus( VALUE self, VALUE other )
5241
5314
  }
5242
5315
  #endif
5243
5316
 
5244
- Data_Get_Struct( self, RVec2, v1 );
5245
- Data_Get_Struct( other, RVec2, v2 );
5317
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v1 );
5318
+ TypedData_Get_Struct( other, RVec2, &RVec2_type, v2 );
5246
5319
  RVec2Sub( &result, v1, v2 );
5247
5320
 
5248
5321
  return RVec2_from_source( &result );
@@ -5265,7 +5338,7 @@ RVec2_op_binary_mult( VALUE self, VALUE other )
5265
5338
  case T_FIXNUM:
5266
5339
  case T_FLOAT:
5267
5340
  {
5268
- Data_Get_Struct( self, RVec2, v );
5341
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5269
5342
  f = NUM2DBL( other );
5270
5343
  RVec2Scale( &result, v, f );
5271
5344
 
@@ -5306,8 +5379,8 @@ RVec2_op_binary_eq( VALUE self, VALUE other )
5306
5379
  }
5307
5380
  #endif
5308
5381
 
5309
- Data_Get_Struct( self, RVec2, v1 );
5310
- Data_Get_Struct( other, RVec2, v2 );
5382
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v1 );
5383
+ TypedData_Get_Struct( other, RVec2, &RVec2_type, v2 );
5311
5384
 
5312
5385
  if ( !RVec2Equal(v1,v2) )
5313
5386
  return Qfalse;
@@ -5337,8 +5410,8 @@ RVec2_op_assign_plus( VALUE self, VALUE other )
5337
5410
  }
5338
5411
  #endif
5339
5412
 
5340
- Data_Get_Struct( self, RVec2, v1 );
5341
- Data_Get_Struct( other, RVec2, v2 );
5413
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v1 );
5414
+ TypedData_Get_Struct( other, RVec2, &RVec2_type, v2 );
5342
5415
 
5343
5416
  RVec2Add( v1, v1, v2 );
5344
5417
 
@@ -5367,8 +5440,8 @@ RVec2_op_assign_minus( VALUE self, VALUE other )
5367
5440
  }
5368
5441
  #endif
5369
5442
 
5370
- Data_Get_Struct( self, RVec2, v1 );
5371
- Data_Get_Struct( other, RVec2, v2 );
5443
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v1 );
5444
+ TypedData_Get_Struct( other, RVec2, &RVec2_type, v2 );
5372
5445
 
5373
5446
  RVec2Sub( v1, v1, v2 );
5374
5447
 
@@ -5397,7 +5470,7 @@ RVec2_op_assign_mult( VALUE self, VALUE other )
5397
5470
  }
5398
5471
  #endif
5399
5472
 
5400
- Data_Get_Struct( self, RVec2, v );
5473
+ TypedData_Get_Struct( self, RVec2, &RVec2_type, v );
5401
5474
  f = NUM2DBL( other );
5402
5475
  RVec2Scale( v, v, f );
5403
5476
 
@@ -5412,7 +5485,7 @@ RVec2_op_assign_mult( VALUE self, VALUE other )
5412
5485
  ********************************************************************************/
5413
5486
 
5414
5487
  /*
5415
- * Document-class: RMath::RVec3
5488
+ * Document-class: RMath3D::RVec3
5416
5489
  * provies 3 element vector arithmetic.
5417
5490
  */
5418
5491
 
@@ -5422,25 +5495,27 @@ RVec3_free( void* ptr )
5422
5495
  xfree( ptr );
5423
5496
  }
5424
5497
 
5498
+ static size_t
5499
+ RVec3_memsize( const void* ptr )
5500
+ {
5501
+ const struct RVec3* data = ptr;
5502
+ return data ? sizeof(*data) : 0;
5503
+ }
5504
+
5425
5505
  static VALUE
5426
5506
  RVec3_from_source( RVec3* src )
5427
5507
  {
5428
- RVec3* v = ALLOC( RVec3 );
5429
-
5508
+ RVec3* v = ZALLOC( struct RVec3 );
5430
5509
  RVec3Copy( v, src );
5431
-
5432
- return Data_Wrap_Struct( rb_cRVec3, NULL, RVec3_free, v );
5510
+ return TypedData_Wrap_Struct( rb_cRVec3, &RVec3_type, v );
5433
5511
  }
5434
5512
 
5435
5513
 
5436
5514
  static VALUE
5437
5515
  RVec3_allocate( VALUE klass )
5438
5516
  {
5439
- RVec3* v = ALLOC( RVec3 );
5440
-
5441
- memset( v, 0, sizeof(RVec3) );
5442
-
5443
- return Data_Wrap_Struct( klass, NULL, RVec3_free, v );
5517
+ RVec3* v = ZALLOC( RVec3 );
5518
+ return TypedData_Wrap_Struct( klass, &RVec3_type, v );
5444
5519
  }
5445
5520
 
5446
5521
 
@@ -5457,7 +5532,7 @@ static VALUE
5457
5532
  RVec3_initialize( int argc, VALUE* argv, VALUE self )
5458
5533
  {
5459
5534
  RVec3* v = NULL;
5460
- Data_Get_Struct( self, RVec3, v );
5535
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5461
5536
 
5462
5537
  switch( argc )
5463
5538
  {
@@ -5490,7 +5565,7 @@ RVec3_initialize( int argc, VALUE* argv, VALUE self )
5490
5565
  {
5491
5566
  /* Copy Constructor */
5492
5567
  RVec3* other;
5493
- Data_Get_Struct( arg , RVec3, other );
5568
+ TypedData_Get_Struct( arg , RVec3, &RVec3_type, other );
5494
5569
  RVec3SetElements( v, other->x, other->y, other->z );
5495
5570
  return self;
5496
5571
  }
@@ -5566,7 +5641,7 @@ RVec3_to_s( VALUE self )
5566
5641
  char dest[128], work[3][32];
5567
5642
  int i;
5568
5643
 
5569
- Data_Get_Struct( self, RVec3, v );
5644
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5570
5645
 
5571
5646
  for ( i = 0; i < 3; ++i )
5572
5647
  {
@@ -5603,11 +5678,11 @@ RVec3_to_a( VALUE self )
5603
5678
  {
5604
5679
  RVec3* v = NULL;
5605
5680
  VALUE dbl[3];
5606
- Data_Get_Struct( self, RVec3, v );
5681
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5607
5682
 
5608
- dbl[0] = DOUBLE2NUM(RVec3GetElement(v,0));
5609
- dbl[1] = DOUBLE2NUM(RVec3GetElement(v,1));
5610
- dbl[2] = DOUBLE2NUM(RVec3GetElement(v,2));
5683
+ dbl[0] = DBL2NUM(RVec3GetElement(v,0));
5684
+ dbl[1] = DBL2NUM(RVec3GetElement(v,1));
5685
+ dbl[2] = DBL2NUM(RVec3GetElement(v,2));
5611
5686
 
5612
5687
  return rb_ary_new4( 3, dbl );
5613
5688
  }
@@ -5621,7 +5696,7 @@ static VALUE
5621
5696
  RVec3_coerce( VALUE self, VALUE other )
5622
5697
  {
5623
5698
  RVec3* v = NULL;
5624
- Data_Get_Struct( self, RVec3, v );
5699
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5625
5700
 
5626
5701
  switch( TYPE(other) )
5627
5702
  {
@@ -5660,7 +5735,7 @@ RVec3_setElements( VALUE self, VALUE x, VALUE y, VALUE z )
5660
5735
  RVec3* v = NULL;
5661
5736
  rmReal flt0, flt1, flt2;
5662
5737
 
5663
- Data_Get_Struct( self, RVec3, v );
5738
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5664
5739
  flt0 = NUM2DBL(x);
5665
5740
  flt1 = NUM2DBL(y);
5666
5741
  flt2 = NUM2DBL(z);
@@ -5682,7 +5757,7 @@ RVec3_setElement( VALUE self, VALUE i, VALUE f )
5682
5757
  int at;
5683
5758
  rmReal flt;
5684
5759
 
5685
- Data_Get_Struct( self, RVec3, v );
5760
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5686
5761
  at = NUM2INT(i);
5687
5762
  flt = NUM2DBL(f);
5688
5763
 
@@ -5702,7 +5777,7 @@ RVec3_setX( VALUE self, VALUE x )
5702
5777
  RVec3* v = NULL;
5703
5778
  rmReal flt0;
5704
5779
 
5705
- Data_Get_Struct( self, RVec3, v );
5780
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5706
5781
  flt0 = NUM2DBL(x);
5707
5782
 
5708
5783
  RVec3SetX( v, flt0 );
@@ -5721,7 +5796,7 @@ RVec3_setY( VALUE self, VALUE y )
5721
5796
  RVec3* v = NULL;
5722
5797
  rmReal flt0;
5723
5798
 
5724
- Data_Get_Struct( self, RVec3, v );
5799
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5725
5800
  flt0 = NUM2DBL(y);
5726
5801
 
5727
5802
  RVec3SetY( v, flt0 );
@@ -5740,7 +5815,7 @@ RVec3_setZ( VALUE self, VALUE z )
5740
5815
  RVec3* v = NULL;
5741
5816
  rmReal flt0;
5742
5817
 
5743
- Data_Get_Struct( self, RVec3, v );
5818
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5744
5819
  flt0 = NUM2DBL(z);
5745
5820
 
5746
5821
  RVec3SetZ( v, flt0 );
@@ -5760,11 +5835,11 @@ RVec3_getElement( VALUE self, VALUE i )
5760
5835
  int at;
5761
5836
  rmReal flt0;
5762
5837
 
5763
- Data_Get_Struct( self, RVec3, v );
5838
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5764
5839
  at = FIX2INT(i);
5765
5840
  flt0 = RVec3GetElement( v, at );
5766
5841
 
5767
- return DOUBLE2NUM( flt0 );
5842
+ return DBL2NUM( flt0 );
5768
5843
  }
5769
5844
 
5770
5845
  /*
@@ -5778,10 +5853,10 @@ RVec3_getX( VALUE self )
5778
5853
  RVec3* v = NULL;
5779
5854
  rmReal flt0;
5780
5855
 
5781
- Data_Get_Struct( self, RVec3, v );
5856
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5782
5857
  flt0 = RVec3GetX( v );
5783
5858
 
5784
- return DOUBLE2NUM( flt0 );
5859
+ return DBL2NUM( flt0 );
5785
5860
  }
5786
5861
 
5787
5862
  /*
@@ -5795,10 +5870,10 @@ RVec3_getY( VALUE self )
5795
5870
  RVec3* v = NULL;
5796
5871
  rmReal flt0;
5797
5872
 
5798
- Data_Get_Struct( self, RVec3, v );
5873
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5799
5874
  flt0 = RVec3GetY( v );
5800
5875
 
5801
- return DOUBLE2NUM( flt0 );
5876
+ return DBL2NUM( flt0 );
5802
5877
  }
5803
5878
 
5804
5879
  /*
@@ -5812,10 +5887,10 @@ RVec3_getZ( VALUE self )
5812
5887
  RVec3* v = NULL;
5813
5888
  rmReal flt0;
5814
5889
 
5815
- Data_Get_Struct( self, RVec3, v );
5890
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5816
5891
  flt0 = RVec3GetZ( v );
5817
5892
 
5818
- return DOUBLE2NUM( flt0 );
5893
+ return DBL2NUM( flt0 );
5819
5894
  }
5820
5895
 
5821
5896
  /*
@@ -5829,10 +5904,10 @@ RVec3_getLength( VALUE self )
5829
5904
  RVec3* v = NULL;
5830
5905
  rmReal flt0;
5831
5906
 
5832
- Data_Get_Struct( self, RVec3, v );
5907
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5833
5908
  flt0 = RVec3Length( v );
5834
5909
 
5835
- return DOUBLE2NUM( flt0 );
5910
+ return DBL2NUM( flt0 );
5836
5911
  }
5837
5912
 
5838
5913
  /*
@@ -5846,10 +5921,10 @@ RVec3_getLengthSq( VALUE self )
5846
5921
  RVec3* v = NULL;
5847
5922
  rmReal flt0;
5848
5923
 
5849
- Data_Get_Struct( self, RVec3, v );
5924
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5850
5925
  flt0 = RVec3LengthSq( v );
5851
5926
 
5852
- return DOUBLE2NUM( flt0 );
5927
+ return DBL2NUM( flt0 );
5853
5928
  }
5854
5929
 
5855
5930
  /*
@@ -5864,11 +5939,11 @@ RVec3_dot( VALUE self, VALUE v1, VALUE v2 )
5864
5939
  RVec3* vec2 = NULL;
5865
5940
  rmReal result;
5866
5941
 
5867
- Data_Get_Struct( v1, RVec3, vec1 );
5868
- Data_Get_Struct( v2, RVec3, vec2 );
5942
+ TypedData_Get_Struct( v1, RVec3, &RVec3_type, vec1 );
5943
+ TypedData_Get_Struct( v2, RVec3, &RVec3_type, vec2 );
5869
5944
  result = RVec3Dot( vec1, vec2 );
5870
5945
 
5871
- return DOUBLE2NUM( result );
5946
+ return DBL2NUM( result );
5872
5947
  }
5873
5948
 
5874
5949
  /*
@@ -5883,8 +5958,8 @@ RVec3_cross( VALUE self, VALUE v1, VALUE v2 )
5883
5958
  RVec3* vec2 = NULL;
5884
5959
  RVec3 out;
5885
5960
 
5886
- Data_Get_Struct( v1, RVec3, vec1 );
5887
- Data_Get_Struct( v2, RVec3, vec2 );
5961
+ TypedData_Get_Struct( v1, RVec3, &RVec3_type, vec1 );
5962
+ TypedData_Get_Struct( v2, RVec3, &RVec3_type, vec2 );
5888
5963
  RVec3Cross( &out, vec1, vec2 );
5889
5964
 
5890
5965
  return RVec3_from_source( &out );
@@ -5903,8 +5978,8 @@ RVec3_transform( VALUE self, VALUE mtx )
5903
5978
  RMtx4* m;
5904
5979
  RVec4 out;
5905
5980
 
5906
- Data_Get_Struct( self, RVec3, v );
5907
- Data_Get_Struct( mtx, RMtx4, m );
5981
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
5982
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
5908
5983
  RVec3Transform( &out, m, v );
5909
5984
 
5910
5985
  return RVec4_from_source( &out );
@@ -5924,8 +5999,8 @@ RVec3_transformCoord( VALUE self, VALUE mtx )
5924
5999
  RMtx4* m;
5925
6000
  RVec3 out;
5926
6001
 
5927
- Data_Get_Struct( self, RVec3, v );
5928
- Data_Get_Struct( mtx, RMtx4, m );
6002
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6003
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
5929
6004
  RVec3TransformCoord( &out, m, v );
5930
6005
 
5931
6006
  return RVec3_from_source( &out );
@@ -5944,8 +6019,8 @@ RVec3_transformCoord_intrusive( VALUE self, VALUE mtx )
5944
6019
  RVec3* v;
5945
6020
  RMtx4* m;
5946
6021
 
5947
- Data_Get_Struct( self, RVec3, v );
5948
- Data_Get_Struct( mtx, RMtx4, m );
6022
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6023
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
5949
6024
  RVec3TransformCoord( v, m, v );
5950
6025
 
5951
6026
  return self;
@@ -5967,8 +6042,8 @@ RVec3_transformNormal( VALUE self, VALUE mtx )
5967
6042
  RMtx4* m;
5968
6043
  RVec3 out;
5969
6044
 
5970
- Data_Get_Struct( self, RVec3, v );
5971
- Data_Get_Struct( mtx, RMtx4, m );
6045
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6046
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
5972
6047
  RVec3TransformNormal( &out, m, v );
5973
6048
 
5974
6049
  return RVec3_from_source( &out );
@@ -5989,8 +6064,8 @@ RVec3_transformNormal_intrusive( VALUE self, VALUE mtx )
5989
6064
  RVec3* v;
5990
6065
  RMtx4* m;
5991
6066
 
5992
- Data_Get_Struct( self, RVec3, v );
5993
- Data_Get_Struct( mtx, RMtx4, m );
6067
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6068
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
5994
6069
  RVec3TransformNormal( v, m, v );
5995
6070
 
5996
6071
  return self;
@@ -6014,8 +6089,8 @@ RVec3_transformRS( VALUE self, VALUE mtx )
6014
6089
  RMtx3* m;
6015
6090
  RVec3 out;
6016
6091
 
6017
- Data_Get_Struct( self, RVec3, v );
6018
- Data_Get_Struct( mtx, RMtx3, m );
6092
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6093
+ TypedData_Get_Struct( mtx, RMtx3, &RMtx3_type, m );
6019
6094
  RVec3TransformRS( &out, m, v );
6020
6095
 
6021
6096
  return RVec3_from_source( &out );
@@ -6038,8 +6113,8 @@ RVec3_transformRS_intrusive( VALUE self, VALUE mtx )
6038
6113
  RVec3* v;
6039
6114
  RMtx3* m;
6040
6115
 
6041
- Data_Get_Struct( self, RVec3, v );
6042
- Data_Get_Struct( mtx, RMtx3, m );
6116
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6117
+ TypedData_Get_Struct( mtx, RMtx3, &RMtx3_type, m );
6043
6118
  RVec3TransformRS( v, m, v );
6044
6119
 
6045
6120
  return self;
@@ -6063,8 +6138,8 @@ RVec3_transformRSTransposed( VALUE self, VALUE mtx )
6063
6138
  RMtx3* m;
6064
6139
  RVec3 out;
6065
6140
 
6066
- Data_Get_Struct( self, RVec3, v );
6067
- Data_Get_Struct( mtx, RMtx3, m );
6141
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6142
+ TypedData_Get_Struct( mtx, RMtx3, &RMtx3_type, m );
6068
6143
  RVec3TransformRSTransposed( &out, m, v );
6069
6144
 
6070
6145
  return RVec3_from_source( &out );
@@ -6087,8 +6162,8 @@ RVec3_transformRSTransposed_intrusive( VALUE self, VALUE mtx )
6087
6162
  RVec3* v;
6088
6163
  RMtx3* m;
6089
6164
 
6090
- Data_Get_Struct( self, RVec3, v );
6091
- Data_Get_Struct( mtx, RMtx3, m );
6165
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6166
+ TypedData_Get_Struct( mtx, RMtx3, &RMtx3_type, m );
6092
6167
  RVec3TransformRSTransposed( v, m, v );
6093
6168
 
6094
6169
  return self;
@@ -6104,8 +6179,8 @@ RVec3_transformByQuaternion( VALUE self, VALUE quat )
6104
6179
  RQuat* q;
6105
6180
  RVec3 out;
6106
6181
 
6107
- Data_Get_Struct( self, RVec3, v );
6108
- Data_Get_Struct( quat, RQuat, q );
6182
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6183
+ TypedData_Get_Struct( quat, RQuat, &RQuat_type, q );
6109
6184
  RVec3TransformByQuaternion( &out, q, v );
6110
6185
 
6111
6186
  return RVec3_from_source( &out );
@@ -6120,8 +6195,8 @@ RVec3_transformByQuaternion_intrusive( VALUE self, VALUE quat )
6120
6195
  RVec3* v;
6121
6196
  RQuat* q;
6122
6197
 
6123
- Data_Get_Struct( self, RVec3, v );
6124
- Data_Get_Struct( quat, RQuat, q );
6198
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6199
+ TypedData_Get_Struct( quat, RQuat, &RQuat_type, q );
6125
6200
  RVec3TransformByQuaternion( v, q, v );
6126
6201
 
6127
6202
  return self;
@@ -6138,7 +6213,7 @@ RVec3_normalize( VALUE self )
6138
6213
  RVec3* v = NULL;
6139
6214
  RVec3 out;
6140
6215
 
6141
- Data_Get_Struct( self, RVec3, v );
6216
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6142
6217
  RVec3Normalize( &out, v );
6143
6218
 
6144
6219
  return RVec3_from_source( &out );
@@ -6154,7 +6229,7 @@ RVec3_normalize_intrusive( VALUE self )
6154
6229
  {
6155
6230
  RVec3* v = NULL;
6156
6231
 
6157
- Data_Get_Struct( self, RVec3, v );
6232
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6158
6233
  RVec3Normalize( v, v );
6159
6234
 
6160
6235
  return self;
@@ -6182,7 +6257,7 @@ RVec3_op_unary_minus( VALUE self )
6182
6257
  RVec3* v = NULL;
6183
6258
  RVec3 out;
6184
6259
 
6185
- Data_Get_Struct( self, RVec3, v );
6260
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6186
6261
  RVec3Scale( &out, v, (rmReal)(-1) );
6187
6262
 
6188
6263
  return RVec3_from_source( &out );
@@ -6211,8 +6286,8 @@ RVec3_op_binary_plus( VALUE self, VALUE other )
6211
6286
  }
6212
6287
  #endif
6213
6288
 
6214
- Data_Get_Struct( self, RVec3, v1 );
6215
- Data_Get_Struct( other, RVec3, v2 );
6289
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v1 );
6290
+ TypedData_Get_Struct( other, RVec3, &RVec3_type, v2 );
6216
6291
  RVec3Add( &result, v1, v2 );
6217
6292
 
6218
6293
  return RVec3_from_source( &result );
@@ -6241,8 +6316,8 @@ RVec3_op_binary_minus( VALUE self, VALUE other )
6241
6316
  }
6242
6317
  #endif
6243
6318
 
6244
- Data_Get_Struct( self, RVec3, v1 );
6245
- Data_Get_Struct( other, RVec3, v2 );
6319
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v1 );
6320
+ TypedData_Get_Struct( other, RVec3, &RVec3_type, v2 );
6246
6321
  RVec3Sub( &result, v1, v2 );
6247
6322
 
6248
6323
  return RVec3_from_source( &result );
@@ -6265,7 +6340,7 @@ RVec3_op_binary_mult( VALUE self, VALUE other )
6265
6340
  case T_FIXNUM:
6266
6341
  case T_FLOAT:
6267
6342
  {
6268
- Data_Get_Struct( self, RVec3, v );
6343
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6269
6344
  f = NUM2DBL( other );
6270
6345
  RVec3Scale( &result, v, f );
6271
6346
 
@@ -6306,8 +6381,8 @@ RVec3_op_binary_eq( VALUE self, VALUE other )
6306
6381
  }
6307
6382
  #endif
6308
6383
 
6309
- Data_Get_Struct( self, RVec3, v1 );
6310
- Data_Get_Struct( other, RVec3, v2 );
6384
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v1 );
6385
+ TypedData_Get_Struct( other, RVec3, &RVec3_type, v2 );
6311
6386
 
6312
6387
  if ( !RVec3Equal(v1,v2) )
6313
6388
  return Qfalse;
@@ -6337,8 +6412,8 @@ RVec3_op_assign_plus( VALUE self, VALUE other )
6337
6412
  }
6338
6413
  #endif
6339
6414
 
6340
- Data_Get_Struct( self, RVec3, v1 );
6341
- Data_Get_Struct( other, RVec3, v2 );
6415
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v1 );
6416
+ TypedData_Get_Struct( other, RVec3, &RVec3_type, v2 );
6342
6417
 
6343
6418
  RVec3Add( v1, v1, v2 );
6344
6419
 
@@ -6367,8 +6442,8 @@ RVec3_op_assign_minus( VALUE self, VALUE other )
6367
6442
  }
6368
6443
  #endif
6369
6444
 
6370
- Data_Get_Struct( self, RVec3, v1 );
6371
- Data_Get_Struct( other, RVec3, v2 );
6445
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v1 );
6446
+ TypedData_Get_Struct( other, RVec3, &RVec3_type, v2 );
6372
6447
 
6373
6448
  RVec3Sub( v1, v1, v2 );
6374
6449
 
@@ -6397,7 +6472,7 @@ RVec3_op_assign_mult( VALUE self, VALUE other )
6397
6472
  }
6398
6473
  #endif
6399
6474
 
6400
- Data_Get_Struct( self, RVec3, v );
6475
+ TypedData_Get_Struct( self, RVec3, &RVec3_type, v );
6401
6476
  f = NUM2DBL( other );
6402
6477
  RVec3Scale( v, v, f );
6403
6478
 
@@ -6412,7 +6487,7 @@ RVec3_op_assign_mult( VALUE self, VALUE other )
6412
6487
  ********************************************************************************/
6413
6488
 
6414
6489
  /*
6415
- * Document-class: RMath::RVec4
6490
+ * Document-class: RMath3D::RVec4
6416
6491
  * provies 4 element vector arithmetic.
6417
6492
  */
6418
6493
 
@@ -6422,25 +6497,27 @@ RVec4_free( void* ptr )
6422
6497
  xfree( ptr );
6423
6498
  }
6424
6499
 
6500
+ static size_t
6501
+ RVec4_memsize( const void* ptr )
6502
+ {
6503
+ const struct RVec4* data = ptr;
6504
+ return data ? sizeof(*data) : 0;
6505
+ }
6506
+
6425
6507
  static VALUE
6426
6508
  RVec4_from_source( RVec4* src )
6427
6509
  {
6428
- RVec4* v = ALLOC( RVec4 );
6429
-
6510
+ RVec4* v = ZALLOC( struct RVec4 );
6430
6511
  RVec4Copy( v, src );
6431
-
6432
- return Data_Wrap_Struct( rb_cRVec4, NULL, RVec4_free, v );
6512
+ return TypedData_Wrap_Struct( rb_cRVec4, &RVec4_type, v );
6433
6513
  }
6434
6514
 
6435
6515
 
6436
6516
  static VALUE
6437
6517
  RVec4_allocate( VALUE klass )
6438
6518
  {
6439
- RVec4* v = ALLOC( RVec4 );
6440
-
6441
- memset( v, 0, sizeof(RVec4) );
6442
-
6443
- return Data_Wrap_Struct( klass, NULL, RVec4_free, v );
6519
+ RVec4* v = ZALLOC( RVec4 );
6520
+ return TypedData_Wrap_Struct( klass, &RVec4_type, v );
6444
6521
  }
6445
6522
 
6446
6523
 
@@ -6457,7 +6534,7 @@ static VALUE
6457
6534
  RVec4_initialize( int argc, VALUE* argv, VALUE self )
6458
6535
  {
6459
6536
  RVec4* v = NULL;
6460
- Data_Get_Struct( self, RVec4, v );
6537
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6461
6538
 
6462
6539
  switch( argc )
6463
6540
  {
@@ -6490,7 +6567,7 @@ RVec4_initialize( int argc, VALUE* argv, VALUE self )
6490
6567
  {
6491
6568
  /* Create from RVec3 */
6492
6569
  RVec3* other;
6493
- Data_Get_Struct( arg , RVec3, other );
6570
+ TypedData_Get_Struct( arg , RVec3, &RVec3_type, other );
6494
6571
  RVec4SetElements( v, other->x, other->y, other->z, 0.0f );
6495
6572
  return self;
6496
6573
  }
@@ -6498,7 +6575,7 @@ RVec4_initialize( int argc, VALUE* argv, VALUE self )
6498
6575
  {
6499
6576
  /* Copy Constructor */
6500
6577
  RVec4* other;
6501
- Data_Get_Struct( arg , RVec4, other );
6578
+ TypedData_Get_Struct( arg , RVec4, &RVec4_type, other );
6502
6579
  RVec4SetElements( v, other->x, other->y, other->z, other->w );
6503
6580
  return self;
6504
6581
  }
@@ -6574,7 +6651,7 @@ RVec4_to_s( VALUE self )
6574
6651
  char dest[128], work[4][32];
6575
6652
  int i;
6576
6653
 
6577
- Data_Get_Struct( self, RVec4, v );
6654
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6578
6655
 
6579
6656
  for ( i = 0; i < 4; ++i )
6580
6657
  {
@@ -6611,12 +6688,12 @@ RVec4_to_a( VALUE self )
6611
6688
  {
6612
6689
  RVec4* v = NULL;
6613
6690
  VALUE dbl[4];
6614
- Data_Get_Struct( self, RVec4, v );
6691
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6615
6692
 
6616
- dbl[0] = DOUBLE2NUM(RVec4GetElement(v,0));
6617
- dbl[1] = DOUBLE2NUM(RVec4GetElement(v,1));
6618
- dbl[2] = DOUBLE2NUM(RVec4GetElement(v,2));
6619
- dbl[3] = DOUBLE2NUM(RVec4GetElement(v,3));
6693
+ dbl[0] = DBL2NUM(RVec4GetElement(v,0));
6694
+ dbl[1] = DBL2NUM(RVec4GetElement(v,1));
6695
+ dbl[2] = DBL2NUM(RVec4GetElement(v,2));
6696
+ dbl[3] = DBL2NUM(RVec4GetElement(v,3));
6620
6697
 
6621
6698
  return rb_ary_new4( 4, dbl );
6622
6699
  }
@@ -6630,7 +6707,7 @@ static VALUE
6630
6707
  RVec4_coerce( VALUE self, VALUE other )
6631
6708
  {
6632
6709
  RVec4* v = NULL;
6633
- Data_Get_Struct( self, RVec4, v );
6710
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6634
6711
 
6635
6712
  switch( TYPE(other) )
6636
6713
  {
@@ -6669,7 +6746,7 @@ RVec4_setElements( VALUE self, VALUE x, VALUE y, VALUE z, VALUE w )
6669
6746
  RVec4* v = NULL;
6670
6747
  rmReal flt0, flt1, flt2, flt3;
6671
6748
 
6672
- Data_Get_Struct( self, RVec4, v );
6749
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6673
6750
  flt0 = NUM2DBL(x);
6674
6751
  flt1 = NUM2DBL(y);
6675
6752
  flt2 = NUM2DBL(z);
@@ -6692,7 +6769,7 @@ RVec4_setElement( VALUE self, VALUE i, VALUE f )
6692
6769
  int at;
6693
6770
  rmReal flt;
6694
6771
 
6695
- Data_Get_Struct( self, RVec4, v );
6772
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6696
6773
  at = NUM2INT(i);
6697
6774
  flt = NUM2DBL(f);
6698
6775
 
@@ -6712,7 +6789,7 @@ RVec4_setX( VALUE self, VALUE x )
6712
6789
  RVec4* v = NULL;
6713
6790
  rmReal flt0;
6714
6791
 
6715
- Data_Get_Struct( self, RVec4, v );
6792
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6716
6793
  flt0 = NUM2DBL(x);
6717
6794
 
6718
6795
  RVec4SetX( v, flt0 );
@@ -6731,7 +6808,7 @@ RVec4_setY( VALUE self, VALUE y )
6731
6808
  RVec4* v = NULL;
6732
6809
  rmReal flt0;
6733
6810
 
6734
- Data_Get_Struct( self, RVec4, v );
6811
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6735
6812
  flt0 = NUM2DBL(y);
6736
6813
 
6737
6814
  RVec4SetY( v, flt0 );
@@ -6750,7 +6827,7 @@ RVec4_setZ( VALUE self, VALUE z )
6750
6827
  RVec4* v = NULL;
6751
6828
  rmReal flt0;
6752
6829
 
6753
- Data_Get_Struct( self, RVec4, v );
6830
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6754
6831
  flt0 = NUM2DBL(z);
6755
6832
 
6756
6833
  RVec4SetZ( v, flt0 );
@@ -6769,7 +6846,7 @@ RVec4_setW( VALUE self, VALUE w )
6769
6846
  RVec4* v = NULL;
6770
6847
  rmReal flt0;
6771
6848
 
6772
- Data_Get_Struct( self, RVec4, v );
6849
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6773
6850
  flt0 = NUM2DBL(w);
6774
6851
 
6775
6852
  RVec4SetW( v, flt0 );
@@ -6788,8 +6865,8 @@ RVec4_setXYZ( VALUE self, VALUE xyz )
6788
6865
  RVec4* v = NULL;
6789
6866
  RVec3* in = NULL;
6790
6867
 
6791
- Data_Get_Struct( self, RVec4, v );
6792
- Data_Get_Struct( xyz, RVec3, in );
6868
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6869
+ TypedData_Get_Struct( xyz, RVec3, &RVec3_type, in );
6793
6870
 
6794
6871
  RVec4SetXYZ( v, in );
6795
6872
 
@@ -6808,11 +6885,11 @@ RVec4_getElement( VALUE self, VALUE i )
6808
6885
  int at;
6809
6886
  rmReal flt0;
6810
6887
 
6811
- Data_Get_Struct( self, RVec4, v );
6888
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6812
6889
  at = FIX2INT(i);
6813
6890
  flt0 = RVec4GetElement( v, at );
6814
6891
 
6815
- return DOUBLE2NUM( flt0 );
6892
+ return DBL2NUM( flt0 );
6816
6893
  }
6817
6894
 
6818
6895
  /*
@@ -6826,10 +6903,10 @@ RVec4_getX( VALUE self )
6826
6903
  RVec4* v = NULL;
6827
6904
  rmReal flt0;
6828
6905
 
6829
- Data_Get_Struct( self, RVec4, v );
6906
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6830
6907
  flt0 = RVec4GetX( v );
6831
6908
 
6832
- return DOUBLE2NUM( flt0 );
6909
+ return DBL2NUM( flt0 );
6833
6910
  }
6834
6911
 
6835
6912
  /*
@@ -6843,10 +6920,10 @@ RVec4_getY( VALUE self )
6843
6920
  RVec4* v = NULL;
6844
6921
  rmReal flt0;
6845
6922
 
6846
- Data_Get_Struct( self, RVec4, v );
6923
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6847
6924
  flt0 = RVec4GetY( v );
6848
6925
 
6849
- return DOUBLE2NUM( flt0 );
6926
+ return DBL2NUM( flt0 );
6850
6927
  }
6851
6928
 
6852
6929
  /*
@@ -6860,10 +6937,10 @@ RVec4_getZ( VALUE self )
6860
6937
  RVec4* v = NULL;
6861
6938
  rmReal flt0;
6862
6939
 
6863
- Data_Get_Struct( self, RVec4, v );
6940
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6864
6941
  flt0 = RVec4GetZ( v );
6865
6942
 
6866
- return DOUBLE2NUM( flt0 );
6943
+ return DBL2NUM( flt0 );
6867
6944
  }
6868
6945
 
6869
6946
  /*
@@ -6877,10 +6954,10 @@ RVec4_getW( VALUE self )
6877
6954
  RVec4* v = NULL;
6878
6955
  rmReal flt0;
6879
6956
 
6880
- Data_Get_Struct( self, RVec4, v );
6957
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6881
6958
  flt0 = RVec4GetW( v );
6882
6959
 
6883
- return DOUBLE2NUM( flt0 );
6960
+ return DBL2NUM( flt0 );
6884
6961
  }
6885
6962
 
6886
6963
  /*
@@ -6894,7 +6971,7 @@ RVec4_getXYZ( VALUE self )
6894
6971
  RVec4* v = NULL;
6895
6972
  RVec3 out;
6896
6973
 
6897
- Data_Get_Struct( self, RVec4, v );
6974
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6898
6975
 
6899
6976
  RVec4GetXYZ( &out, v );
6900
6977
 
@@ -6912,10 +6989,10 @@ RVec4_getLength( VALUE self )
6912
6989
  RVec4* v = NULL;
6913
6990
  rmReal flt0;
6914
6991
 
6915
- Data_Get_Struct( self, RVec4, v );
6992
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6916
6993
  flt0 = RVec4Length( v );
6917
6994
 
6918
- return DOUBLE2NUM( flt0 );
6995
+ return DBL2NUM( flt0 );
6919
6996
  }
6920
6997
 
6921
6998
  /*
@@ -6929,10 +7006,10 @@ RVec4_getLengthSq( VALUE self )
6929
7006
  RVec4* v = NULL;
6930
7007
  rmReal flt0;
6931
7008
 
6932
- Data_Get_Struct( self, RVec4, v );
7009
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
6933
7010
  flt0 = RVec4LengthSq( v );
6934
7011
 
6935
- return DOUBLE2NUM( flt0 );
7012
+ return DBL2NUM( flt0 );
6936
7013
  }
6937
7014
 
6938
7015
  /*
@@ -6947,11 +7024,11 @@ RVec4_dot( VALUE self, VALUE v1, VALUE v2 )
6947
7024
  RVec4* vec2 = NULL;
6948
7025
  rmReal result;
6949
7026
 
6950
- Data_Get_Struct( v1, RVec4, vec1 );
6951
- Data_Get_Struct( v2, RVec4, vec2 );
7027
+ TypedData_Get_Struct( v1, RVec4, &RVec4_type, vec1 );
7028
+ TypedData_Get_Struct( v2, RVec4, &RVec4_type, vec2 );
6952
7029
  result = RVec4Dot( vec1, vec2 );
6953
7030
 
6954
- return DOUBLE2NUM( result );
7031
+ return DBL2NUM( result );
6955
7032
  }
6956
7033
 
6957
7034
  /*
@@ -6966,8 +7043,8 @@ RVec4_transform( VALUE self, VALUE mtx )
6966
7043
  RMtx4* m;
6967
7044
  RVec4 out;
6968
7045
 
6969
- Data_Get_Struct( self, RVec4, v );
6970
- Data_Get_Struct( mtx, RMtx4, m );
7046
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7047
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
6971
7048
  RVec4Transform( &out, m, v );
6972
7049
 
6973
7050
  return RVec4_from_source( &out );
@@ -6984,8 +7061,8 @@ RVec4_transform_intrusive( VALUE self, VALUE mtx )
6984
7061
  RVec4* v;
6985
7062
  RMtx4* m;
6986
7063
 
6987
- Data_Get_Struct( self, RVec4, v );
6988
- Data_Get_Struct( mtx, RMtx4, m );
7064
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7065
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
6989
7066
  RVec4Transform( v, m, v );
6990
7067
 
6991
7068
  return self;
@@ -7003,8 +7080,8 @@ RVec4_transformTransposed( VALUE self, VALUE mtx )
7003
7080
  RMtx4* m;
7004
7081
  RVec4 out;
7005
7082
 
7006
- Data_Get_Struct( self, RVec4, v );
7007
- Data_Get_Struct( mtx, RMtx4, m );
7083
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7084
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
7008
7085
  RVec4TransformTransposed( &out, m, v );
7009
7086
 
7010
7087
  return RVec4_from_source( &out );
@@ -7021,8 +7098,8 @@ RVec4_transformTransposed_intrusive( VALUE self, VALUE mtx )
7021
7098
  RVec4* v;
7022
7099
  RMtx4* m;
7023
7100
 
7024
- Data_Get_Struct( self, RVec4, v );
7025
- Data_Get_Struct( mtx, RMtx4, m );
7101
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7102
+ TypedData_Get_Struct( mtx, RMtx4, &RMtx4_type, m );
7026
7103
  RVec4TransformTransposed( v, m, v );
7027
7104
 
7028
7105
  return self;
@@ -7039,7 +7116,7 @@ RVec4_normalize( VALUE self )
7039
7116
  RVec4* v = NULL;
7040
7117
  RVec4 out;
7041
7118
 
7042
- Data_Get_Struct( self, RVec4, v );
7119
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7043
7120
  RVec4Normalize( &out, v );
7044
7121
 
7045
7122
  return RVec4_from_source( &out );
@@ -7055,7 +7132,7 @@ RVec4_normalize_intrusive( VALUE self )
7055
7132
  {
7056
7133
  RVec4* v = NULL;
7057
7134
 
7058
- Data_Get_Struct( self, RVec4, v );
7135
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7059
7136
  RVec4Normalize( v, v );
7060
7137
 
7061
7138
  return self;
@@ -7083,7 +7160,7 @@ RVec4_op_unary_minus( VALUE self )
7083
7160
  RVec4* v = NULL;
7084
7161
  RVec4 out;
7085
7162
 
7086
- Data_Get_Struct( self, RVec4, v );
7163
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7087
7164
  RVec4Scale( &out, v, (rmReal)(-1) );
7088
7165
 
7089
7166
  return RVec4_from_source( &out );
@@ -7112,8 +7189,8 @@ RVec4_op_binary_plus( VALUE self, VALUE other )
7112
7189
  }
7113
7190
  #endif
7114
7191
 
7115
- Data_Get_Struct( self, RVec4, v1 );
7116
- Data_Get_Struct( other, RVec4, v2 );
7192
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v1 );
7193
+ TypedData_Get_Struct( other, RVec4, &RVec4_type, v2 );
7117
7194
  RVec4Add( &result, v1, v2 );
7118
7195
 
7119
7196
  return RVec4_from_source( &result );
@@ -7142,8 +7219,8 @@ RVec4_op_binary_minus( VALUE self, VALUE other )
7142
7219
  }
7143
7220
  #endif
7144
7221
 
7145
- Data_Get_Struct( self, RVec4, v1 );
7146
- Data_Get_Struct( other, RVec4, v2 );
7222
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v1 );
7223
+ TypedData_Get_Struct( other, RVec4, &RVec4_type, v2 );
7147
7224
  RVec4Sub( &result, v1, v2 );
7148
7225
 
7149
7226
  return RVec4_from_source( &result );
@@ -7166,7 +7243,7 @@ RVec4_op_binary_mult( VALUE self, VALUE other )
7166
7243
  case T_FIXNUM:
7167
7244
  case T_FLOAT:
7168
7245
  {
7169
- Data_Get_Struct( self, RVec4, v );
7246
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7170
7247
  f = NUM2DBL( other );
7171
7248
  RVec4Scale( &result, v, f );
7172
7249
 
@@ -7207,8 +7284,8 @@ RVec4_op_binary_eq( VALUE self, VALUE other )
7207
7284
  }
7208
7285
  #endif
7209
7286
 
7210
- Data_Get_Struct( self, RVec4, v1 );
7211
- Data_Get_Struct( other, RVec4, v2 );
7287
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v1 );
7288
+ TypedData_Get_Struct( other, RVec4, &RVec4_type, v2 );
7212
7289
 
7213
7290
  if ( !RVec4Equal(v1,v2) )
7214
7291
  return Qfalse;
@@ -7238,8 +7315,8 @@ RVec4_op_assign_plus( VALUE self, VALUE other )
7238
7315
  }
7239
7316
  #endif
7240
7317
 
7241
- Data_Get_Struct( self, RVec4, v1 );
7242
- Data_Get_Struct( other, RVec4, v2 );
7318
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v1 );
7319
+ TypedData_Get_Struct( other, RVec4, &RVec4_type, v2 );
7243
7320
 
7244
7321
  RVec4Add( v1, v1, v2 );
7245
7322
 
@@ -7268,8 +7345,8 @@ RVec4_op_assign_minus( VALUE self, VALUE other )
7268
7345
  }
7269
7346
  #endif
7270
7347
 
7271
- Data_Get_Struct( self, RVec4, v1 );
7272
- Data_Get_Struct( other, RVec4, v2 );
7348
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v1 );
7349
+ TypedData_Get_Struct( other, RVec4, &RVec4_type, v2 );
7273
7350
 
7274
7351
  RVec4Sub( v1, v1, v2 );
7275
7352
 
@@ -7298,7 +7375,7 @@ RVec4_op_assign_mult( VALUE self, VALUE other )
7298
7375
  }
7299
7376
  #endif
7300
7377
 
7301
- Data_Get_Struct( self, RVec4, v );
7378
+ TypedData_Get_Struct( self, RVec4, &RVec4_type, v );
7302
7379
  f = NUM2DBL( other );
7303
7380
  RVec4Scale( v, v, f );
7304
7381
 
@@ -7346,7 +7423,7 @@ Init_rmath3d()
7346
7423
  rb_cRMtx3 = rb_define_class_under( rb_mRMath, "RMtx3", rb_cObject );
7347
7424
  rb_cRMtx4 = rb_define_class_under( rb_mRMath, "RMtx4", rb_cObject );
7348
7425
 
7349
- rb_define_const( rb_mRMath, "TOLERANCE", DOUBLE2NUM(RMATH_TOLERANCE) );
7426
+ rb_define_const( rb_mRMath, "TOLERANCE", DBL2NUM(RMATH_TOLERANCE) );
7350
7427
 
7351
7428
  /********************************************************************************
7352
7429
  * RMtx2