rays 0.1.46 → 0.1.48

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 (74) hide show
  1. checksums.yaml +4 -4
  2. data/.doc/ext/rays/bitmap.cpp +499 -0
  3. data/.doc/ext/rays/camera.cpp +2 -2
  4. data/.doc/ext/rays/defs.cpp +35 -11
  5. data/.doc/ext/rays/font.cpp +50 -2
  6. data/.doc/ext/rays/native.cpp +2 -4
  7. data/.doc/ext/rays/painter.cpp +111 -6
  8. data/.doc/ext/rays/polygon.cpp +152 -41
  9. data/.doc/ext/rays/polyline.cpp +89 -10
  10. data/.doc/ext/rays/rays.cpp +91 -11
  11. data/.doc/ext/rays/{noise.cpp → util.cpp} +2 -2
  12. data/.github/workflows/test.yml +0 -1
  13. data/ChangeLog.md +38 -0
  14. data/Rakefile +4 -4
  15. data/VERSION +1 -1
  16. data/ext/rays/bitmap.cpp +501 -0
  17. data/ext/rays/camera.cpp +2 -2
  18. data/ext/rays/defs.cpp +35 -11
  19. data/ext/rays/defs.h +56 -3
  20. data/ext/rays/font.cpp +56 -4
  21. data/ext/rays/native.cpp +2 -4
  22. data/ext/rays/painter.cpp +125 -11
  23. data/ext/rays/polygon.cpp +161 -41
  24. data/ext/rays/polyline.cpp +95 -9
  25. data/ext/rays/rays.cpp +91 -11
  26. data/ext/rays/{noise.cpp → util.cpp} +2 -2
  27. data/include/rays/defs.h +24 -0
  28. data/include/rays/font.h +17 -3
  29. data/include/rays/matrix.h +2 -0
  30. data/include/rays/painter.h +29 -1
  31. data/include/rays/polygon.h +57 -33
  32. data/include/rays/polyline.h +20 -1
  33. data/include/rays/ruby/polygon.h +0 -11
  34. data/include/rays/ruby/rays.h +4 -0
  35. data/include/rays/{noise.h → util.h} +2 -2
  36. data/lib/rays/color.rb +1 -1
  37. data/lib/rays/font.rb +1 -1
  38. data/lib/rays/image.rb +1 -1
  39. data/lib/rays/painter.rb +13 -2
  40. data/lib/rays/point.rb +1 -1
  41. data/lib/rays/polygon.rb +54 -16
  42. data/lib/rays/polyline.rb +54 -8
  43. data/lib/rays.rb +0 -1
  44. data/rays.gemspec +2 -2
  45. data/src/color_space.cpp +2 -2
  46. data/src/font.cpp +24 -2
  47. data/src/font.h +8 -1
  48. data/src/ios/font.mm +88 -27
  49. data/src/matrix.cpp +8 -0
  50. data/src/osx/font.mm +90 -28
  51. data/src/osx/helper.h +2 -2
  52. data/src/osx/helper.mm +2 -2
  53. data/src/painter.cpp +227 -90
  54. data/src/painter.h +11 -3
  55. data/src/polygon.cpp +588 -205
  56. data/src/polyline.cpp +154 -28
  57. data/src/polyline.h +3 -5
  58. data/src/shader.cpp +36 -4
  59. data/src/shader.h +1 -1
  60. data/src/texture.cpp +2 -2
  61. data/src/{noise.cpp → util.cpp} +1 -1
  62. data/src/win32/font.cpp +1 -1
  63. data/test/test_bitmap.rb +16 -2
  64. data/test/test_color.rb +4 -0
  65. data/test/test_font.rb +20 -2
  66. data/test/test_image.rb +18 -18
  67. data/test/test_point.rb +1 -1
  68. data/test/test_polygon.rb +52 -45
  69. data/test/test_polyline.rb +191 -72
  70. metadata +11 -17
  71. data/.doc/ext/rays/polygon_line.cpp +0 -97
  72. data/ext/rays/polygon_line.cpp +0 -100
  73. data/lib/rays/polygon_line.rb +0 -33
  74. data/test/test_polygon_line.rb +0 -164
data/ext/rays/font.cpp CHANGED
@@ -30,6 +30,16 @@ RUCY_DEFN(initialize)
30
30
  }
31
31
  RUCY_END
32
32
 
33
+ static
34
+ RUCY_DEF1(initialize_copy, obj)
35
+ {
36
+ RUCY_CHECK_OBJ(Rays::Font, self);
37
+
38
+ *THIS = to<Rays::Font&>(obj).dup();
39
+ return self;
40
+ }
41
+ RUCY_END
42
+
33
43
  static
34
44
  RUCY_DEF0(name)
35
45
  {
@@ -38,6 +48,15 @@ RUCY_DEF0(name)
38
48
  }
39
49
  RUCY_END
40
50
 
51
+ static
52
+ RUCY_DEF1(set_size, size)
53
+ {
54
+ CHECK;
55
+ THIS->set_size(to<coord>(size));
56
+ return size;
57
+ }
58
+ RUCY_END
59
+
41
60
  static
42
61
  RUCY_DEF0(size)
43
62
  {
@@ -92,6 +111,35 @@ RUCY_DEF0(leading)
92
111
  }
93
112
  RUCY_END
94
113
 
114
+ static
115
+ RUCY_DEF0(families)
116
+ {
117
+ Hash hash;
118
+ for (const auto& family : Rays::get_font_families())
119
+ {
120
+ std::vector<Value> members;
121
+ for (const auto& member : family.second)
122
+ members.emplace_back(member.c_str());
123
+ hash.set(family.first.c_str(), value(members.size(), &members[0]));
124
+ }
125
+ return hash;
126
+ }
127
+ RUCY_END
128
+
129
+ static
130
+ RUCY_DEFN(load)
131
+ {
132
+ check_arg_count(__FILE__, __LINE__, "Font.load", argc, 1, 2);
133
+
134
+ const char* path = argv[0].c_str();
135
+
136
+ if (argc >= 2)
137
+ return value(Rays::load_font(path, to<Rays::coord>(argv[1])));
138
+ else
139
+ return value(Rays::load_font(path));
140
+ }
141
+ RUCY_END
142
+
95
143
 
96
144
  static Class cFont;
97
145
 
@@ -102,14 +150,18 @@ Init_rays_font ()
102
150
 
103
151
  cFont = mRays.define_class("Font");
104
152
  cFont.define_alloc_func(alloc);
105
- cFont.define_private_method("initialize", initialize);
153
+ cFont.define_private_method("initialize", initialize);
154
+ cFont.define_private_method("initialize_copy", initialize_copy);
106
155
  cFont.define_method("name", name);
107
- cFont.define_method("size", size);
156
+ cFont.define_method("size=", set_size);
157
+ cFont.define_method("size", size);
108
158
  cFont.define_method("width", width);
109
159
  cFont.define_method("height", height);
110
160
  cFont.define_method("ascent", ascent);
111
161
  cFont.define_method("descent", descent);
112
162
  cFont.define_method("leading", leading);
163
+ cFont.define_module_function("families", families);
164
+ cFont.define_module_function("load", load);
113
165
  }
114
166
 
115
167
 
@@ -131,9 +183,9 @@ namespace Rucy
131
183
  if (convert)
132
184
  {
133
185
  if (argc == 0)
134
- return Rays::default_font();
186
+ return Rays::get_default_font();
135
187
 
136
- coord size = argc >= 2 ? to<coord>(argv[1]) : 0;
188
+ coord size = argc >= 2 ? to<coord>(argv[1]) : Rays::Font::DEFAULT_SIZE;
137
189
  if (argv->is_nil())
138
190
  return Rays::Font(NULL, size);
139
191
  else if (argv->is_s() || argv->is_sym())
data/ext/rays/native.cpp CHANGED
@@ -12,7 +12,6 @@ void Init_rays_matrix ();
12
12
 
13
13
  void Init_rays_painter ();
14
14
  void Init_rays_polyline ();
15
- void Init_rays_polygon_line ();
16
15
  void Init_rays_polygon ();
17
16
  void Init_rays_bitmap ();
18
17
  void Init_rays_image ();
@@ -20,7 +19,7 @@ void Init_rays_font ();
20
19
  void Init_rays_shader ();
21
20
  void Init_rays_camera ();
22
21
 
23
- void Init_rays_noise ();
22
+ void Init_rays_util ();
24
23
 
25
24
 
26
25
  extern "C" void
@@ -45,7 +44,6 @@ extern "C" void
45
44
 
46
45
  Init_rays_painter();
47
46
  Init_rays_polyline();
48
- Init_rays_polygon_line();
49
47
  Init_rays_polygon();
50
48
  Init_rays_bitmap();
51
49
  Init_rays_image();
@@ -53,7 +51,7 @@ extern "C" void
53
51
  Init_rays_shader();
54
52
  Init_rays_camera();
55
53
 
56
- Init_rays_noise();
54
+ Init_rays_util();
57
55
 
58
56
  RUCY_CATCH
59
57
  }
data/ext/rays/painter.cpp CHANGED
@@ -129,11 +129,29 @@ RUCY_DEF0(clear)
129
129
  RUCY_END
130
130
 
131
131
  static
132
- RUCY_DEF1(polygon, poly)
132
+ RUCY_DEFN(polygon)
133
133
  {
134
134
  CHECK;
135
+ check_arg_count(__FILE__, __LINE__, "Painter#polygon", argc, 1, 3, 5);
136
+
137
+ const Rays::Polygon* polygon = to<Rays::Polygon*>(argv[0]);
138
+ if (!polygon)
139
+ argument_error(__FILE__, __LINE__, "%s is not a polygon.", argv[0].inspect().c_str());
140
+
141
+ if (argc == 1)
142
+ THIS->polygon(*polygon);
143
+ else if (argc == 3)
144
+ {
145
+ coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
146
+ THIS->polygon(*polygon, x, y);
147
+ }
148
+ else if (argc == 5)
149
+ {
150
+ coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
151
+ coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
152
+ THIS->polygon(*polygon, x, y, w, h);
153
+ }
135
154
 
136
- THIS->polygon(to<Rays::Polygon&>(poly));
137
155
  return self;
138
156
  }
139
157
  RUCY_END
@@ -144,7 +162,7 @@ RUCY_DEF2(line, args, loop)
144
162
  CHECK;
145
163
 
146
164
  std::vector<Rays::Point> points;
147
- get_line_args(&points, args.size(), args.as_array());
165
+ get_points(&points, args.size(), args.as_array());
148
166
 
149
167
  THIS->line(&points[0], points.size(), loop);
150
168
  return self;
@@ -206,7 +224,7 @@ RUCY_DEF2(curve, args, loop)
206
224
  argument_error(__FILE__, __LINE__);
207
225
 
208
226
  std::vector<Rays::Point> points;
209
- get_line_args(&points, args.size(), args.as_array());
227
+ get_points(&points, args.size(), args.as_array());
210
228
 
211
229
  THIS->curve(&points[0], points.size(), loop);
212
230
  return self;
@@ -222,7 +240,7 @@ RUCY_DEF2(bezier, args, loop)
222
240
  argument_error(__FILE__, __LINE__);
223
241
 
224
242
  std::vector<Rays::Point> points;
225
- get_line_args(&points, args.size(), args.as_array());
243
+ get_points(&points, args.size(), args.as_array());
226
244
 
227
245
  THIS->bezier(&points[0], points.size(), loop);
228
246
  return self;
@@ -393,6 +411,23 @@ RUCY_DEF0(get_stroke_width)
393
411
  }
394
412
  RUCY_END
395
413
 
414
+ static
415
+ RUCY_DEF1(set_stroke_outset, outset)
416
+ {
417
+ CHECK;
418
+ THIS->set_stroke_outset(to<float>(outset));
419
+ return self;
420
+ }
421
+ RUCY_END
422
+
423
+ static
424
+ RUCY_DEF0(get_stroke_outset)
425
+ {
426
+ CHECK;
427
+ return value(THIS->stroke_outset());
428
+ }
429
+ RUCY_END
430
+
396
431
  static
397
432
  RUCY_DEF1(set_stroke_cap, cap)
398
433
  {
@@ -523,6 +558,76 @@ RUCY_DEF0(get_font)
523
558
  }
524
559
  RUCY_END
525
560
 
561
+ static
562
+ RUCY_DEF1(set_texture, image)
563
+ {
564
+ CHECK;
565
+
566
+ if (!image)
567
+ THIS->no_texture();
568
+ else
569
+ THIS->set_texture(to<Rays::Image&>(image));
570
+ return self;
571
+ }
572
+ RUCY_END
573
+
574
+ static
575
+ RUCY_DEF0(get_texture)
576
+ {
577
+ CHECK;
578
+
579
+ const Rays::Image& image = THIS->texture();
580
+ return image ? value(image) : nil();
581
+ }
582
+ RUCY_END
583
+
584
+ static
585
+ RUCY_DEF0(no_texture)
586
+ {
587
+ CHECK;
588
+ THIS->no_texture();
589
+ return self;
590
+ }
591
+ RUCY_END
592
+
593
+ static
594
+ RUCY_DEF1(set_texcoord_mode, mode)
595
+ {
596
+ CHECK;
597
+
598
+ THIS->set_texcoord_mode(to<Rays::TexCoordMode>(mode));
599
+ return self;
600
+ }
601
+ RUCY_END
602
+
603
+ static
604
+ RUCY_DEF0(get_texcoord_mode)
605
+ {
606
+ CHECK;
607
+
608
+ return value(THIS->texcoord_mode());
609
+ }
610
+ RUCY_END
611
+
612
+ static
613
+ RUCY_DEF1(set_texcoord_wrap, wrap)
614
+ {
615
+ CHECK;
616
+
617
+ THIS->set_texcoord_wrap(to<Rays::TexCoordWrap>(wrap));
618
+ return self;
619
+ }
620
+ RUCY_END
621
+
622
+ static
623
+ RUCY_DEF0(get_texcoord_wrap)
624
+ {
625
+ CHECK;
626
+
627
+ return value(THIS->texcoord_wrap());
628
+ }
629
+ RUCY_END
630
+
526
631
  static
527
632
  RUCY_DEFN(set_shader)
528
633
  {
@@ -698,12 +803,14 @@ Init_rays_painter ()
698
803
  cPainter.define_method( "stroke=", set_stroke);
699
804
  cPainter.define_method( "stroke", get_stroke);
700
805
  cPainter.define_method("no_stroke", no_stroke);
701
- cPainter.define_method( "stroke_width=", set_stroke_width);
702
- cPainter.define_method( "stroke_width", get_stroke_width);
703
- cPainter.define_method( "stroke_cap=", set_stroke_cap);
704
- cPainter.define_method( "stroke_cap", get_stroke_cap);
705
- cPainter.define_method( "stroke_join=", set_stroke_join);
706
- cPainter.define_method( "stroke_join", get_stroke_join);
806
+ cPainter.define_method( "stroke_width=", set_stroke_width);
807
+ cPainter.define_method( "stroke_width", get_stroke_width);
808
+ cPainter.define_method( "stroke_outset=", set_stroke_outset);
809
+ cPainter.define_method( "stroke_outset", get_stroke_outset);
810
+ cPainter.define_method( "stroke_cap=", set_stroke_cap);
811
+ cPainter.define_method( "stroke_cap", get_stroke_cap);
812
+ cPainter.define_method( "stroke_join=", set_stroke_join);
813
+ cPainter.define_method( "stroke_join", get_stroke_join);
707
814
  cPainter.define_method("miter_limit=", set_miter_limit);
708
815
  cPainter.define_method("miter_limit", get_miter_limit);
709
816
  cPainter.define_method("nsegment=", set_nsegment);
@@ -715,6 +822,13 @@ Init_rays_painter ()
715
822
  cPainter.define_method("no_clip", no_clip);
716
823
  cPainter.define_method("font=", set_font);
717
824
  cPainter.define_method("font", get_font);
825
+ cPainter.define_method( "texture=", set_texture);
826
+ cPainter.define_method( "texture", get_texture);
827
+ cPainter.define_method("no_texture", no_texture);
828
+ cPainter.define_method("texcoord_mode=", set_texcoord_mode);
829
+ cPainter.define_method("texcoord_mode", get_texcoord_mode);
830
+ cPainter.define_method("texcoord_wrap=", set_texcoord_wrap);
831
+ cPainter.define_method("texcoord_wrap", get_texcoord_wrap);
718
832
  cPainter.define_private_method("set_shader", set_shader);
719
833
  cPainter.define_method( "shader", get_shader);
720
834
  cPainter.define_method( "no_shader", no_shader);
data/ext/rays/polygon.cpp CHANGED
@@ -1,7 +1,6 @@
1
1
  #include "rays/ruby/polygon.h"
2
2
 
3
3
 
4
- #include <assert.h>
5
4
  #include <vector>
6
5
  #include <functional>
7
6
  #include "rays/ruby/bounds.h"
@@ -24,7 +23,7 @@ RUCY_DEF_ALLOC(alloc, klass)
24
23
  RUCY_END
25
24
 
26
25
  static
27
- RUCY_DEF2(setup, args, loop)
26
+ RUCY_DEF4(setup, args, loop, colors, texcoords)
28
27
  {
29
28
  CHECK;
30
29
 
@@ -32,9 +31,10 @@ RUCY_DEF2(setup, args, loop)
32
31
  *THIS = to<Rays::Polygon>(args.size(), args.as_array());
33
32
  else
34
33
  {
35
- std::vector<Rays::Point> points;
36
- get_line_args(&points, args.size(), args.as_array());
37
- *THIS = Rays::Polygon(&points[0], points.size(), loop);
34
+ CreateParams params(args, colors, texcoords);
35
+ *THIS = Rays::Polygon(
36
+ params.ppoints(), params.size(), loop,
37
+ params.pcolors(), params.ptexcoords());
38
38
  }
39
39
  }
40
40
  RUCY_END
@@ -102,22 +102,63 @@ RUCY_DEF0(each)
102
102
  CHECK;
103
103
 
104
104
  Value ret = Qnil;
105
- for (const auto& line : *THIS)
106
- ret = rb_yield(value(line));
105
+ for (const auto& polyline : *THIS)
106
+ ret = rb_yield(value(polyline));
107
107
  return ret;
108
108
  }
109
109
  RUCY_END
110
110
 
111
- static void
112
- each_polygon (const Value& value, std::function<void(const Rays::Polygon&)> fun)
111
+ template <typename T>
112
+ static inline void
113
+ each_poly (const Value& value, auto fun)
113
114
  {
114
115
  int size = value.size();
115
116
  const Value* array = value.as_array();
116
117
 
117
118
  for (int i = 0; i < size; ++i)
118
- fun(to<Rays::Polygon&>(array[i]));
119
+ fun(to<T&>(array[i]));
119
120
  }
120
121
 
122
+ static
123
+ RUCY_DEF1(op_add, obj)
124
+ {
125
+ CHECK;
126
+
127
+ if (obj.is_kind_of(Rays::polyline_class()))
128
+ return value(*THIS + to<Rays::Polyline&>(obj));
129
+
130
+ if (obj.is_kind_of(Rays::polygon_class()))
131
+ return value(*THIS + to<Rays::Polygon&>(obj));
132
+
133
+ if (!obj.is_array())
134
+ argument_error(__FILE__, __LINE__);
135
+
136
+ if (obj.empty()) return self;
137
+
138
+ std::vector<Rays::Polyline> polylines;
139
+ for (const auto& polyline : to<Rays::Polygon&>(self))
140
+ polylines.emplace_back(polyline);
141
+
142
+ if (obj[0].is_kind_of(Rays::polyline_class()))
143
+ {
144
+ each_poly<Rays::Polyline>(obj, [&](const auto& polyline)
145
+ {
146
+ polylines.emplace_back(polyline);
147
+ });
148
+ }
149
+ else
150
+ {
151
+ each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
152
+ {
153
+ for (const auto& polyline : polygon)
154
+ polylines.emplace_back(polyline);
155
+ });
156
+ }
157
+
158
+ return value(Rays::Polygon(&polylines[0], polylines.size()));
159
+ }
160
+ RUCY_END
161
+
121
162
  static
122
163
  RUCY_DEF1(op_sub, obj)
123
164
  {
@@ -126,7 +167,7 @@ RUCY_DEF1(op_sub, obj)
126
167
  if (obj.is_array())
127
168
  {
128
169
  Rays::Polygon result = *THIS;
129
- each_polygon(obj, [&](const Rays::Polygon& polygon)
170
+ each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
130
171
  {
131
172
  result = result - polygon;
132
173
  });
@@ -145,7 +186,7 @@ RUCY_DEF1(op_and, obj)
145
186
  if (obj.is_array())
146
187
  {
147
188
  Rays::Polygon result = *THIS;
148
- each_polygon(obj, [&](const Rays::Polygon& polygon)
189
+ each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
149
190
  {
150
191
  result = result & polygon;
151
192
  });
@@ -164,7 +205,7 @@ RUCY_DEF1(op_or, obj)
164
205
  if (obj.is_array())
165
206
  {
166
207
  Rays::Polygon result = *THIS;
167
- each_polygon(obj, [&](const Rays::Polygon& polygon)
208
+ each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
168
209
  {
169
210
  result = result | polygon;
170
211
  });
@@ -183,7 +224,7 @@ RUCY_DEF1(op_xor, obj)
183
224
  if (obj.is_array())
184
225
  {
185
226
  Rays::Polygon result = *THIS;
186
- each_polygon(obj, [&](const Rays::Polygon& polygon)
227
+ each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
187
228
  {
188
229
  result = result ^ polygon;
189
230
  });
@@ -194,6 +235,60 @@ RUCY_DEF1(op_xor, obj)
194
235
  }
195
236
  RUCY_END
196
237
 
238
+ static
239
+ RUCY_DEF1(create_points, points)
240
+ {
241
+ CreateParams params(points, nil(), nil());
242
+ return value(Rays::create_points(params.ppoints(), params.size()));
243
+ }
244
+ RUCY_END
245
+
246
+ static
247
+ RUCY_DEF2(create_line, points, loop)
248
+ {
249
+ CreateParams params(points, nil(), nil());
250
+ return value(Rays::create_line(params.ppoints(), params.size(), loop));
251
+ }
252
+ RUCY_END
253
+
254
+ static
255
+ RUCY_DEF1(create_lines, points)
256
+ {
257
+ CreateParams params(points, nil(), nil());
258
+ return value(Rays::create_lines(params.ppoints(), params.size()));
259
+ }
260
+ RUCY_END
261
+
262
+ static
263
+ RUCY_DEF4(create_triangles, points, loop, colors, texcoords)
264
+ {
265
+ CreateParams params(points, colors, texcoords);
266
+ return value(Rays::create_triangles(
267
+ params.ppoints(), params.size(), loop,
268
+ params.pcolors(), params.ptexcoords()));
269
+ }
270
+ RUCY_END
271
+
272
+ static
273
+ RUCY_DEF3(create_triangle_strip, points, colors, texcoords)
274
+ {
275
+ CreateParams params(points, colors, texcoords);
276
+ return value(Rays::create_triangle_strip(
277
+ params.ppoints(), params.size(),
278
+ params.pcolors(), params.ptexcoords()));
279
+ }
280
+ RUCY_END
281
+
282
+ static
283
+ RUCY_DEF3(create_triangle_fan, points, colors, texcoords)
284
+ {
285
+ CreateParams params(points, colors, texcoords);
286
+ return value(Rays::create_triangle_fan(
287
+ params.ppoints(), params.size(),
288
+ params.pcolors(), params.ptexcoords()));
289
+ }
290
+ RUCY_END
291
+
197
292
  static
198
293
  RUCY_DEF7(create_rect,
199
294
  args, round, lefttop, righttop, leftbottom, rightbottom, nsegment)
@@ -209,6 +304,26 @@ RUCY_DEF7(create_rect,
209
304
  }
210
305
  RUCY_END
211
306
 
307
+ static
308
+ RUCY_DEF4(create_quads, points, loop, colors, texcoords)
309
+ {
310
+ CreateParams params(points, colors, texcoords);
311
+ return value(Rays::create_quads(
312
+ params.ppoints(), params.size(), loop,
313
+ params.pcolors(), params.ptexcoords()));
314
+ }
315
+ RUCY_END
316
+
317
+ static
318
+ RUCY_DEF3(create_quad_strip, points, colors, texcoords)
319
+ {
320
+ CreateParams params(points, colors, texcoords);
321
+ return value(Rays::create_quad_strip(
322
+ params.ppoints(), params.size(),
323
+ params.pcolors(), params.ptexcoords()));
324
+ }
325
+ RUCY_END
326
+
212
327
  static
213
328
  RUCY_DEF7(create_ellipse,
214
329
  args, center, radius, hole, angle_from, angle_to, nsegment)
@@ -227,22 +342,18 @@ RUCY_DEF7(create_ellipse,
227
342
  RUCY_END
228
343
 
229
344
  static
230
- RUCY_DEF2(create_curve, args, loop)
345
+ RUCY_DEF2(create_curve, points, loop)
231
346
  {
232
- std::vector<Rays::Point> points;
233
- get_line_args(&points, args.size(), args.as_array());
234
-
235
- return value(Rays::create_curve(&points[0], points.size(), loop));
347
+ CreateParams params(points, nil(), nil());
348
+ return value(Rays::create_curve(params.ppoints(), params.size(), loop));
236
349
  }
237
350
  RUCY_END
238
351
 
239
352
  static
240
- RUCY_DEF2(create_bezier, args, loop)
353
+ RUCY_DEF2(create_bezier, points, loop)
241
354
  {
242
- std::vector<Rays::Point> points;
243
- get_line_args(&points, args.size(), args.as_array());
244
-
245
- return value(Rays::create_bezier(&points[0], points.size(), loop));
355
+ CreateParams params(points, nil(), nil());
356
+ return value(Rays::create_bezier(params.ppoints(), params.size(), loop));
246
357
  }
247
358
  RUCY_END
248
359
 
@@ -259,19 +370,27 @@ Init_rays_polygon ()
259
370
  cPolygon.define_private_method("setup", setup);
260
371
  cPolygon.define_method("expand", expand);
261
372
  cPolygon.define_method("bounds", bounds);
262
- cPolygon.define_method("size", size);
373
+ cPolygon.define_method("size", size);
263
374
  cPolygon.define_method("empty?", is_empty);
264
375
  cPolygon.define_method("[]", get_at);
265
376
  cPolygon.define_method("each", each);
266
- cPolygon.define_method("+", op_or);
377
+ cPolygon.define_method("+", op_add);
267
378
  cPolygon.define_method("-", op_sub);
268
379
  cPolygon.define_method("&", op_and);
269
380
  cPolygon.define_method("|", op_or);
270
381
  cPolygon.define_method("^", op_xor);
271
- cPolygon.define_singleton_method("create_rect", create_rect);
272
- cPolygon.define_singleton_method("create_ellipse", create_ellipse);
273
- cPolygon.define_singleton_method("create_curve", create_curve);
274
- cPolygon.define_singleton_method("create_bezier", create_bezier);
382
+ cPolygon.define_singleton_method("points!", create_points);
383
+ cPolygon.define_singleton_method("line!", create_line);
384
+ cPolygon.define_singleton_method("lines!", create_lines);
385
+ cPolygon.define_singleton_method("triangles!", create_triangles);
386
+ cPolygon.define_singleton_method("triangle_strip!", create_triangle_strip);
387
+ cPolygon.define_singleton_method("triangle_fan!", create_triangle_fan);
388
+ cPolygon.define_singleton_method("rect!", create_rect);
389
+ cPolygon.define_singleton_method("quads!", create_quads);
390
+ cPolygon.define_singleton_method("quad_strip!", create_quad_strip);
391
+ cPolygon.define_singleton_method("ellipse!", create_ellipse);
392
+ cPolygon.define_singleton_method("curve!", create_curve);
393
+ cPolygon.define_singleton_method("bezier!", create_bezier);
275
394
  }
276
395
 
277
396
 
@@ -282,26 +401,27 @@ namespace Rucy
282
401
  template <> Rays::Polygon
283
402
  value_to<Rays::Polygon> (int argc, const Value* argv, bool convert)
284
403
  {
285
- assert(argc == 0 || (argc > 0 && argv));
286
-
287
404
  if (convert)
288
405
  {
289
406
  if (argc <= 0)
290
407
  return Rays::Polygon();
291
- else if (argv->is_kind_of(Rays::polygon_line_class()))
408
+ else if (argv->is_kind_of(Rays::polyline_class()))
292
409
  {
293
- std::vector<Rays::Polygon::Line> lines;
294
- lines.reserve(argc);
295
- for (int i = 0; i < argc; ++i)
296
- lines.emplace_back(to<Rays::Polygon::Line&>(argv[i]));
297
- return Rays::Polygon(&lines[0], lines.size());
410
+ if (argc == 1)
411
+ return Rays::Polygon(to<Rays::Polyline&>(*argv));
412
+ else
413
+ {
414
+ std::vector<Rays::Polyline> polylines;
415
+ polylines.reserve(argc);
416
+ for (int i = 0; i < argc; ++i)
417
+ polylines.emplace_back(to<Rays::Polyline&>(argv[i]));
418
+ return Rays::Polygon(&polylines[0], polylines.size());
419
+ }
298
420
  }
299
- else if (argv->is_kind_of(Rays::polyline_class()))
300
- return Rays::Polygon(to<Rays::Polyline&>(*argv));
301
421
  else if (argv->is_num() || argv->is_array())
302
422
  {
303
423
  std::vector<Rays::Point> points;
304
- get_line_args(&points, argc, argv);
424
+ get_points(&points, argc, argv);
305
425
  return Rays::Polygon(&points[0], points.size());
306
426
  }
307
427
  }