texplay 0.2.983pre2-i386-mingw32 → 0.3.0-i386-mingw32

Sign up to get free protection for your applications and to get access to all the features.
Files changed (66) hide show
  1. data/Rakefile +41 -49
  2. data/examples/common.rb +13 -2
  3. data/examples/example_alpha_blend.rb +1 -3
  4. data/examples/example_bezier.rb +1 -2
  5. data/examples/example_blank.rb +1 -3
  6. data/examples/example_cache.rb +1 -3
  7. data/examples/example_color_transform.rb +1 -3
  8. data/examples/example_color_transform_circle.rb +1 -3
  9. data/examples/example_darken.rb +1 -4
  10. data/examples/example_dup.rb +1 -4
  11. data/examples/example_each.rb +1 -4
  12. data/examples/example_effect.rb +1 -2
  13. data/examples/example_fill.rb +1 -2
  14. data/examples/example_fill_old.rb +1 -2
  15. data/examples/example_fluent.rb +1 -3
  16. data/examples/example_font.rb +1 -3
  17. data/examples/example_gen_eval.rb +1 -2
  18. data/examples/example_hash_arguments.rb +1 -2
  19. data/examples/example_ippa.rb +1 -3
  20. data/examples/example_light.rb +1 -3
  21. data/examples/example_light_multiply.rb +1 -3
  22. data/examples/example_lsystem.rb +1 -1
  23. data/examples/example_melt.rb +1 -3
  24. data/examples/example_meyet.rb +1 -3
  25. data/examples/example_polyline.rb +1 -2
  26. data/examples/example_scale.rb +1 -3
  27. data/examples/example_select.rb +1 -3
  28. data/examples/example_select2.rb +1 -4
  29. data/examples/example_simple.rb +1 -3
  30. data/examples/example_splice.rb +2 -4
  31. data/examples/example_sync.rb +1 -2
  32. data/examples/example_tiles.rb +1 -3
  33. data/examples/example_trace.rb +1 -2
  34. data/examples/example_transparent.rb +1 -3
  35. data/examples/example_transparent2.rb +1 -3
  36. data/examples/example_transparent3.rb +1 -3
  37. data/examples/example_turtle.rb +1 -2
  38. data/examples/example_weird.rb +1 -2
  39. data/examples/example_window_render_to_image.rb +41 -0
  40. data/examples/example_window_to_blob.rb +2 -5
  41. data/ext/texplay/actions.c +1006 -0
  42. data/ext/texplay/actions.h +60 -0
  43. data/ext/texplay/bindings.c +1186 -0
  44. data/ext/texplay/bindings.h +46 -0
  45. data/ext/texplay/cache.c +118 -0
  46. data/ext/texplay/cache.h +24 -0
  47. data/ext/texplay/compat.h +27 -0
  48. data/ext/texplay/extconf.rb +28 -0
  49. data/ext/texplay/gen_eval.c +211 -0
  50. data/ext/texplay/gen_eval.h +20 -0
  51. data/ext/texplay/graphics_utils.c +1244 -0
  52. data/ext/texplay/graphics_utils.h +22 -0
  53. data/ext/texplay/object2module.c +171 -0
  54. data/ext/texplay/object2module.h +11 -0
  55. data/ext/texplay/texplay.c +216 -0
  56. data/ext/texplay/texplay.h +148 -0
  57. data/ext/texplay/utils.c +887 -0
  58. data/ext/texplay/utils.h +153 -0
  59. data/lib/1.8/texplay.so +0 -0
  60. data/lib/1.9/texplay.so +0 -0
  61. data/lib/texplay.rb +271 -165
  62. data/lib/texplay/c_function_docs.rb +189 -0
  63. data/lib/texplay/version.rb +1 -1
  64. metadata +33 -21
  65. data/examples/example_window_to_texture.rb +0 -55
  66. data/lib/texplay/patches.rb +0 -4
@@ -0,0 +1,887 @@
1
+ /* utils.c */
2
+ #include <stdio.h>
3
+ #include <string.h>
4
+ #include <ctype.h>
5
+ #include <ruby.h>
6
+ #include <stdarg.h>
7
+ #include <assert.h>
8
+ #include <stdlib.h>
9
+ #include <math.h>
10
+ #include "cache.h"
11
+ #include "texplay.h"
12
+ #include "utils.h"
13
+
14
+ #ifdef __APPLE__
15
+ #include <glut.h>
16
+ #else
17
+ #include <GL/glut.h>
18
+ #endif
19
+
20
+ /*
21
+ #define MULT_FLOAT4(X, Y) ({ \
22
+ asm volatile ( \
23
+ "movups (%0), %%xmm0\n\t" \
24
+ "mulps (%1), %%xmm0\n\t" \
25
+ "movups %%xmm0, (%1)" \
26
+ :: "r" (X), "r" (Y)); })
27
+
28
+ #define COPY_FLOAT4(X, Y) ({ \
29
+ asm volatile ( \
30
+ "movups (%0), %%xmm0\n\t" \
31
+ "movups %%xmm0, (%1)" \
32
+ :: "r" (X), "r" (Y)); })
33
+
34
+ */
35
+ /* external linkage with static duration */
36
+ const rgba not_a_color_v = { -1.0, -1.0, -1.0, -1.0 };
37
+
38
+ /* utility functions */
39
+ char*
40
+ lowercase(char * string)
41
+ {
42
+ int i = 0;
43
+
44
+ while (string[i]) {
45
+ string[i] = tolower(string[i]);
46
+ i++;
47
+ }
48
+
49
+ return string;
50
+ }
51
+
52
+ char*
53
+ sym2string(VALUE sym)
54
+ {
55
+ return rb_id2name(SYM2ID(sym));
56
+ }
57
+
58
+ VALUE
59
+ string2sym(char * string)
60
+ {
61
+ return ID2SYM(rb_intern(string));
62
+ }
63
+
64
+ bool
65
+ is_a_hash(VALUE try_hash)
66
+ {
67
+ return TYPE(try_hash) == T_HASH;
68
+ }
69
+
70
+ bool
71
+ is_an_array(VALUE try_array)
72
+ {
73
+ return TYPE(try_array) == T_ARRAY;
74
+ }
75
+
76
+ bool is_a_num(VALUE try_num)
77
+ {
78
+ return TYPE(try_num) == T_FIXNUM || TYPE(try_num) == T_FLOAT;
79
+ }
80
+
81
+ VALUE
82
+ get_from_hash(VALUE hash, char * sym)
83
+ {
84
+
85
+ if(TYPE(hash) != T_HASH) rb_raise(rb_eArgError, "hash argument expected");
86
+
87
+ return rb_hash_aref(hash, string2sym(sym));
88
+ }
89
+
90
+ VALUE
91
+ set_hash_value(VALUE hash, char * sym, VALUE val)
92
+ {
93
+ if(TYPE(hash) != T_HASH) rb_raise(rb_eArgError, "hash argument expected");
94
+
95
+ rb_hash_aset(hash, string2sym(sym), val);
96
+
97
+ return val;
98
+ }
99
+
100
+ VALUE
101
+ delete_from_hash(VALUE hash, char * sym)
102
+ {
103
+ if(TYPE(hash) != T_HASH) rb_raise(rb_eArgError, "hash argument expected");
104
+
105
+ return rb_hash_delete(hash, string2sym(sym));
106
+ }
107
+
108
+ /* returns true if 'hash' is a hash and the value mapped to key 'sym' is
109
+ equal to 'val' */
110
+ bool
111
+ hash_value_is(VALUE hash, char * sym, VALUE val)
112
+ {
113
+ if(TYPE(hash) != T_HASH) return false;
114
+
115
+ if(get_from_hash(hash, sym) == val)
116
+ return true;
117
+
118
+ return false;
119
+ }
120
+
121
+ bool
122
+ has_optional_hash_arg(VALUE hash, char * sym)
123
+ {
124
+ if(TYPE(hash) != T_HASH) return false;
125
+
126
+ if(NIL_P(get_from_hash(hash, sym)))
127
+ return false;
128
+
129
+ /* 'hash' is a hash and the sym exists */
130
+ return true;
131
+ }
132
+
133
+ VALUE
134
+ set_array_value(VALUE array, int index, VALUE val)
135
+ {
136
+ if(TYPE(array) != T_ARRAY) rb_raise(rb_eArgError, "array argument expected");
137
+
138
+ rb_ary_store(array, index, val);
139
+
140
+ return val;
141
+ }
142
+
143
+ VALUE
144
+ get_from_array(VALUE array, int index)
145
+ {
146
+
147
+ if(TYPE(array) != T_ARRAY) rb_raise(rb_eArgError, "array argument expected");
148
+
149
+ return rb_ary_entry(array, index);
150
+ }
151
+
152
+
153
+ VALUE
154
+ init_image_local(VALUE image)
155
+ {
156
+ VALUE image_local;
157
+
158
+ if(!is_gosu_image(image))
159
+ rb_raise(rb_eArgError, "not a valid image");
160
+
161
+ /* initialize image_local hash if does not exist */
162
+ if(!is_an_array(rb_iv_get(image, "__image_local__"))) {
163
+ image_local = rb_ary_new();
164
+ rb_iv_set(image, "__image_local__", image_local);
165
+ }
166
+
167
+ image_local = rb_iv_get(image, "__image_local__");
168
+
169
+ return image_local;
170
+ }
171
+
172
+ void
173
+ set_image_local(VALUE image, int name, VALUE val)
174
+ {
175
+ VALUE image_local;
176
+
177
+ image_local = init_image_local(image);
178
+
179
+ set_array_value(image_local, name, val);
180
+ }
181
+
182
+ VALUE
183
+ get_image_local(VALUE image, int name)
184
+ {
185
+ VALUE image_local;
186
+ VALUE val;
187
+
188
+ init_image_local(image);
189
+
190
+ /* this var holds all the image local variables in an array */
191
+ image_local = rb_iv_get(image, "__image_local__");
192
+
193
+ /* a particular image_local variable */
194
+ val = get_from_array(image_local, name);
195
+
196
+ /* if the variable exists then return it */
197
+ if(!NIL_P(val))
198
+ return val;
199
+
200
+ /* otherwise initialize the variable and then return it */
201
+ else {
202
+ switch(name) {
203
+ VALUE init_offset, init_bounds, init_color, init_defaults;
204
+ case DRAW_OFFSET:
205
+ init_offset = rb_ary_new2(2);
206
+ set_array_value(init_offset, 0, INT2FIX(0));
207
+ set_array_value(init_offset, 1, INT2FIX(0));
208
+
209
+ set_array_value(image_local, DRAW_OFFSET, init_offset);
210
+
211
+ return init_offset;
212
+ break;
213
+ case LAZY_BOUNDS:
214
+ init_bounds = rb_ary_new2(4);
215
+ set_array_value(init_bounds, 0, INT2FIX(XMAX_OOB));
216
+ set_array_value(init_bounds, 1, INT2FIX(YMAX_OOB));
217
+ set_array_value(init_bounds, 2, INT2FIX(XMIN_OOB));
218
+ set_array_value(init_bounds, 3, INT2FIX(YMIN_OOB));
219
+
220
+ set_array_value(image_local, LAZY_BOUNDS, init_bounds);
221
+
222
+ return init_bounds;
223
+ break;
224
+ case IMAGE_COLOR:
225
+ init_color = rb_ary_new2(4);
226
+ set_array_value(init_color, 0, rb_float_new(1.0));
227
+ set_array_value(init_color, 1, rb_float_new(1.0));
228
+ set_array_value(init_color, 2, rb_float_new(1.0));
229
+ set_array_value(init_color, 3, rb_float_new(1.0));
230
+
231
+ set_array_value(image_local, IMAGE_COLOR, init_color);
232
+
233
+ return init_color;
234
+ break;
235
+ case USER_DEFAULTS:
236
+ init_defaults = rb_hash_new();
237
+
238
+ set_array_value(image_local, USER_DEFAULTS, init_defaults);
239
+
240
+ return init_defaults;
241
+ break;
242
+ default:
243
+ rb_raise(rb_eArgError, "unrecognized image_local variable number. got %d", name);
244
+ }
245
+ }
246
+
247
+ /* never reached */
248
+ return Qnil;
249
+ }
250
+
251
+ rgba
252
+ convert_image_local_color_to_rgba(VALUE image)
253
+ {
254
+ rgba color;
255
+ VALUE image_local_color = get_image_local(image, IMAGE_COLOR);
256
+
257
+ color.red = NUM2DBL(get_from_array(image_local_color, red));
258
+ color.green = NUM2DBL(get_from_array(image_local_color, green));
259
+ color.blue = NUM2DBL(get_from_array(image_local_color, blue));
260
+ color.alpha = NUM2DBL(get_from_array(image_local_color, alpha));
261
+
262
+ return color;
263
+ }
264
+
265
+ VALUE
266
+ save_rgba_to_image_local_color(VALUE image, rgba color)
267
+ {
268
+ /* abbreviation for image_local_color */
269
+ VALUE ilc = get_image_local(image, IMAGE_COLOR);
270
+
271
+ set_array_value(ilc, 0, rb_float_new(color.red));
272
+ set_array_value(ilc, 1, rb_float_new(color.green));
273
+ set_array_value(ilc, 2, rb_float_new(color.blue));
274
+ set_array_value(ilc, 3, rb_float_new(color.alpha));
275
+
276
+ return ilc;
277
+ }
278
+
279
+ bool
280
+ not_a_color(rgba color1)
281
+ {
282
+ return color1.red == -1 || color1.green == -1 ||
283
+ color1.blue == -1 || color1.alpha == -1;
284
+ }
285
+
286
+ bool
287
+ is_a_color(rgba color1)
288
+ {
289
+ return !not_a_color(color1);
290
+ }
291
+
292
+ bool
293
+ is_rb_raw_color(VALUE cval)
294
+ {
295
+ return TYPE(cval) == T_ARRAY &&
296
+ is_a_num(get_from_array(cval, 0)) &&
297
+ is_a_num(get_from_array(cval, 1)) &&
298
+ is_a_num(get_from_array(cval, 2)) &&
299
+ is_a_num(get_from_array(cval, 3));
300
+ }
301
+
302
+ bool
303
+ not_rb_raw_color(VALUE cval)
304
+ {
305
+ return TYPE(cval) != T_ARRAY ||
306
+ !is_a_num(get_from_array(cval, 0));
307
+ }
308
+
309
+ /** cmp_color related functions **/
310
+ static bool
311
+ is_transparent_color(rgba color1)
312
+ {
313
+ return color1.red == -666 && color1.green == -666 && color1.blue == -666 &&
314
+ color1.alpha == -666;
315
+ }
316
+
317
+ static bool
318
+ special_cmp_color(rgba color1, rgba color2)
319
+ {
320
+ if (is_transparent_color(color1))
321
+ return color2.alpha == 0;
322
+ else if (is_transparent_color(color2))
323
+ return color1.alpha == 0;
324
+ else
325
+ return false;
326
+ }
327
+
328
+ static bool
329
+ special_cmp_color_with_tolerance(rgba color1, rgba color2, float tolerance)
330
+ {
331
+ if (is_transparent_color(color1))
332
+ return (color2.alpha) <= tolerance;
333
+ else if (is_transparent_color(color2))
334
+ return color1.alpha <= tolerance;
335
+ else
336
+ return false;
337
+ }
338
+
339
+
340
+ static float
341
+ color_distance_squared(rgba c1, rgba c2)
342
+ {
343
+ return (c1.red - c2.red) * (c1.red - c2.red) +
344
+ (c1.green - c2.green) * (c1.green - c2.green) +
345
+ (c1.blue - c2.blue) * (c1.blue - c2.blue) +
346
+ (c1.alpha - c2.alpha) * (c1.alpha - c2.alpha);
347
+ }
348
+
349
+
350
+ bool
351
+ cmp_color_with_tolerance(rgba color1, rgba color2, float tolerance)
352
+ {
353
+ if (color1.red < 0 || color2.red < 0)
354
+ return special_cmp_color_with_tolerance(color1, color2, tolerance);
355
+
356
+ return color_distance_squared(color1, color2) <= (tolerance * tolerance);
357
+ }
358
+
359
+ bool
360
+ cmp_color(rgba color1, rgba color2)
361
+ {
362
+ if (color1.red < 0 || color2.red < 0)
363
+ return special_cmp_color(color1, color2);
364
+
365
+ return (color1.red == color2.red) && (color1.green == color2.green) && (color1.blue == color2.blue)
366
+ && (color1.alpha == color2.alpha);
367
+ }
368
+
369
+
370
+ /*** these functions are UNSAFE ***/
371
+ void
372
+ color_copy(float * source, float * dest)
373
+ {
374
+ //COPY_FLOAT4(source, dest);
375
+ memcpy(dest, source, 4 * sizeof(float));
376
+ }
377
+
378
+ void
379
+ zero_color(float * tex)
380
+ {
381
+ memset(tex, 0, 4 * sizeof(float));
382
+ }
383
+ /*** ***/
384
+
385
+ rgba
386
+ find_color_from_string(char * try_color)
387
+ {
388
+ rgba cur_color;
389
+
390
+ if(!strcmp("red", try_color)) {
391
+ cur_color.red = 1.0; cur_color.green = 0.0; cur_color.blue = 0.0; cur_color.alpha = 1.0;
392
+ }
393
+ else if(!strcmp("green", try_color)) {
394
+ cur_color.red = 0.0; cur_color.green = 1.0; cur_color.blue = 0.0; cur_color.alpha = 1.0;
395
+ }
396
+ else if(!strcmp("blue", try_color)) {
397
+ cur_color.red = 0.0; cur_color.green = 0.0; cur_color.blue = 1.0; cur_color.alpha = 1.0;
398
+ }
399
+ else if(!strcmp("black", try_color)) {
400
+ cur_color.red = 0.0; cur_color.green = 0.0; cur_color.blue = 0.0; cur_color.alpha = 1.0;
401
+ }
402
+ else if(!strcmp("white", try_color)) {
403
+ cur_color.red = 1.0; cur_color.green = 1.0; cur_color.blue = 1.0; cur_color.alpha = 1.0;
404
+ }
405
+ else if(!strcmp("purple", try_color)) {
406
+ cur_color.red = 1.0; cur_color.green = 0.0; cur_color.blue = 1.0; cur_color.alpha = 1.0;
407
+ }
408
+ else if(!strcmp("yellow", try_color)) {
409
+ cur_color.red = 1.0; cur_color.green = 1.0; cur_color.blue = 0.0; cur_color.alpha = 1.0;
410
+ }
411
+ else if(!strcmp("cyan", try_color)) {
412
+ cur_color.red = 0.0; cur_color.green = 1.0; cur_color.blue = 1.0; cur_color.alpha = 1.0;
413
+ }
414
+ else if(!strcmp("orange", try_color)) {
415
+ cur_color.red = 1.0; cur_color.green = 0.5; cur_color.blue = 0.0; cur_color.alpha = 1.0;
416
+ }
417
+ else if(!strcmp("brown", try_color)) {
418
+ cur_color.red = 0.39; cur_color.green = 0.26; cur_color.blue = 0.13; cur_color.alpha = 1.0;
419
+ }
420
+ else if(!strcmp("turquoise", try_color)) {
421
+ cur_color.red = 0.1; cur_color.green = 0.6; cur_color.blue = 0.8; cur_color.alpha = 1.0;
422
+ }
423
+ else if(!strcmp("tyrian", try_color)) {
424
+ cur_color.red = 0.4; cur_color.green = 0.007; cur_color.blue = 0.235; cur_color.alpha = 1.0;
425
+ }
426
+ else if(!strcmp("alpha", try_color)) {
427
+ cur_color.red = 0.0; cur_color.green = 0.0; cur_color.blue = 0.0; cur_color.alpha = 0.0;
428
+ }
429
+ else if(!strcmp("transparent", try_color)) {
430
+ cur_color.red = -666; cur_color.green = -666; cur_color.blue = -666; cur_color.alpha = -666;
431
+ }
432
+ else if(!strcmp("none", try_color)) {
433
+ cur_color = not_a_color_v;
434
+ }
435
+ else if(!strcmp("random", try_color) || !strcmp("rand", try_color)) {
436
+ cur_color.red = rand() / (float)RAND_MAX;
437
+ cur_color.green = rand() / (float)RAND_MAX;
438
+ cur_color.blue = rand() / (float)RAND_MAX;
439
+ cur_color.alpha = 1.0;
440
+ }
441
+
442
+ else
443
+ rb_raise(rb_eArgError, "invalid colour specified (no color matches the symbol: %s)\n", try_color);
444
+
445
+ return cur_color;
446
+ }
447
+
448
+ rgba
449
+ convert_gosu_to_rgba_color(VALUE gcolor)
450
+ {
451
+
452
+ return (rgba) {
453
+ FIX2INT(rb_funcall(gcolor, rb_intern("red"), 0)) / 255.0,
454
+ FIX2INT(rb_funcall(gcolor, rb_intern("green"), 0)) / 255.0,
455
+ FIX2INT(rb_funcall(gcolor, rb_intern("blue"), 0)) / 255.0,
456
+ FIX2INT(rb_funcall(gcolor, rb_intern("alpha"), 0)) / 255.0
457
+ };
458
+ }
459
+
460
+
461
+ /* convert C color to Ruby color */
462
+ VALUE
463
+ convert_rgba_to_rb_color(rgba * pix)
464
+ {
465
+ if (not_a_color(*pix)) return Qnil;
466
+
467
+ /* create a new ruby array to store the pixel data */
468
+ VALUE pix_array = rb_ary_new2(4);
469
+
470
+ /* store the pixel data */
471
+ rb_ary_store(pix_array, red, rb_float_new(pix->red));
472
+ rb_ary_store(pix_array, green, rb_float_new(pix->green));
473
+ rb_ary_store(pix_array, blue, rb_float_new(pix->blue));
474
+ rb_ary_store(pix_array, alpha, rb_float_new(pix->alpha));
475
+
476
+ return pix_array;
477
+ }
478
+
479
+ /* convert C color to gosu color */
480
+ VALUE
481
+ convert_rgba_to_gosu_color(rgba * pix)
482
+ {
483
+ if (not_a_color(*pix)) return Qnil;
484
+
485
+ VALUE gosu_color = rb_funcall(gosu_color_class(), rb_intern("new"), 0);
486
+
487
+ rb_funcall(gosu_color, rb_intern("red="), 1, INT2FIX(pix->red * 255));
488
+ rb_funcall(gosu_color, rb_intern("green="), 1, INT2FIX(pix->green * 255));
489
+ rb_funcall(gosu_color, rb_intern("blue="), 1, INT2FIX(pix->blue * 255));
490
+ rb_funcall(gosu_color, rb_intern("alpha="), 1, INT2FIX(pix->alpha * 255));
491
+
492
+ return gosu_color;
493
+ }
494
+
495
+ VALUE
496
+ gosu_color_class()
497
+ {
498
+ static VALUE gcolor_class = 0;
499
+
500
+ if (gcolor_class == 0) {
501
+ VALUE gosu_class = rb_const_get(rb_cObject, rb_intern("Gosu"));
502
+ gcolor_class = rb_const_get(gosu_class, rb_intern("Color"));
503
+ }
504
+
505
+ return gcolor_class;
506
+ }
507
+
508
+ /* convert Ruby color to C color */
509
+ rgba
510
+ convert_rb_color_to_rgba(VALUE cval)
511
+ {
512
+ rgba my_color;
513
+
514
+ if (is_gosu_color(cval)) return convert_gosu_to_rgba_color(cval);
515
+
516
+ /* current color for actions */
517
+ switch(TYPE(cval)) {
518
+ char * try_color;
519
+ case T_SYMBOL:
520
+ try_color = lowercase(sym2string(cval));
521
+
522
+ my_color = find_color_from_string(try_color);
523
+
524
+ break;
525
+ case T_ARRAY:
526
+ my_color.red = NUM2DBL(rb_ary_entry(cval, red));
527
+ my_color.green = NUM2DBL(rb_ary_entry(cval, green));
528
+ my_color.blue = NUM2DBL(rb_ary_entry(cval, blue));
529
+
530
+ if(NUM2INT(rb_funcall(cval, rb_intern("length"), 0)) > 3)
531
+ my_color.alpha = NUM2DBL(rb_ary_entry(cval, alpha));
532
+ else
533
+ my_color.alpha = 1;
534
+
535
+ break;
536
+
537
+ /* hex literals */
538
+ case T_FIXNUM:
539
+ case T_BIGNUM:
540
+ return convert_gosu_to_rgba_color(rb_funcall(gosu_color_class(),
541
+ rb_intern("new"), 1, cval));
542
+ break;
543
+
544
+ default:
545
+ rb_raise(rb_eArgError, "unsupported argument type for color. Got type 0x%x\n", TYPE(cval) );
546
+ }
547
+
548
+ /* a valid color */
549
+ if(is_a_color(my_color))
550
+ return my_color;
551
+
552
+ /* special condition for when color is taken from outside range of bitmap. Color is just ignored */
553
+ else if(not_a_color(my_color))
554
+ return not_a_color_v;
555
+
556
+ /* anything else should fail */
557
+ else
558
+ rb_raise(rb_eArgError, "invalid colour specified (negative value given)\n");
559
+ }
560
+
561
+ /* error checking functions */
562
+ void
563
+ check_mask(VALUE mask)
564
+ {
565
+ char * try_mask;
566
+
567
+ if(TYPE(mask) != T_ARRAY && TYPE(mask) != T_SYMBOL)
568
+ rb_raise(rb_eArgError, "array or symbol parameter required");
569
+
570
+ /* is it a valid mask symbol? */
571
+ if(TYPE(mask) == T_SYMBOL) {
572
+ try_mask = lowercase(sym2string(mask));
573
+ if(*try_mask == '_') try_mask++;
574
+ if(not_a_color(find_color_from_string(try_mask))) {
575
+ rb_raise(rb_eArgError, "unrecognized mask symbol: %s\n", sym2string(mask));
576
+ }
577
+ }
578
+ }
579
+
580
+ void
581
+ check_image(VALUE image)
582
+ {
583
+ if(!rb_respond_to(image, rb_intern("gl_tex_info")))
584
+ rb_raise(rb_eRuntimeError,"must specify a valid source image");
585
+ }
586
+
587
+ bool
588
+ is_gosu_image(VALUE try_image)
589
+ {
590
+ if(rb_respond_to(try_image, rb_intern("gl_tex_info")))
591
+ return true;
592
+
593
+ return false;
594
+ }
595
+
596
+ bool
597
+ is_gosu_color(VALUE try_color)
598
+ {
599
+ if(rb_respond_to(try_color, rb_intern("red")))
600
+ return true;
601
+
602
+ return false;
603
+ }
604
+
605
+
606
+
607
+ /** cohen-sutherland line clipper **/
608
+ #define outcode int
609
+ const int RIGHT = 8; //1000
610
+ const int TOP = 4; //0100
611
+ const int LEFT = 2; //0010
612
+ const int BOTTOM = 1; //0001
613
+
614
+ //Compute the bit code for a point (x, y) using the clip rectangle
615
+ //bounded diagonally by (xmin, ymin), and (xmax, ymax)
616
+ static outcode
617
+ ComputeOutCode (int x, int y, int xmin, int ymin, int xmax, int ymax)
618
+ {
619
+ outcode code = 0;
620
+ if (y > ymax) //above the clip window
621
+ code |= TOP;
622
+ else if (y < ymin) //below the clip window
623
+ code |= BOTTOM;
624
+ if (x > xmax) //to the right of clip window
625
+ code |= RIGHT;
626
+ else if (x < xmin) //to the left of clip window
627
+ code |= LEFT;
628
+ return code;
629
+ }
630
+
631
+ /** Cohen-Sutherland clipping algorithm clips a line from
632
+ P0 = (x0, y0) to P1 = (x1, y1) against a rectangle with
633
+ diagonal from (xmin, ymin) to (xmax, ymax). **/
634
+ void
635
+ cohen_sutherland_clip (int * x0, int * y0,int * x1, int * y1, int xmin, int ymin,
636
+ int xmax, int ymax)
637
+ {
638
+ //Outcodes for P0, P1, and whatever point lies outside the clip rectangle
639
+ outcode outcode0, outcode1, outcodeOut;
640
+ bool accept = false, done = false;
641
+ int tx0 = *x0, ty0 = *y0, tx1 = *x1, ty1 = *y1;
642
+
643
+ //compute outcodes
644
+ outcode0 = ComputeOutCode (tx0, ty0, xmin, ymin, xmax, ymax);
645
+ outcode1 = ComputeOutCode (tx1, ty1, xmin, ymin, xmax, ymax);
646
+
647
+ do{
648
+ if (!(outcode0 | outcode1)) //logical or is 0. Trivially accept and get out of loop
649
+ {
650
+ accept = true;
651
+ done = true;
652
+ }
653
+ else if (outcode0 & outcode1) //logical and is not 0. Trivially reject and get out of loop
654
+ done = true;
655
+ else
656
+ {
657
+ //failed both tests, so calculate the line segment to clip
658
+ //from an outside point to an intersection with clip edge
659
+ double x, y;
660
+ //At least one endpoint is outside the clip rectangle; pick it.
661
+ outcodeOut = outcode0? outcode0: outcode1;
662
+ //Now find the intersection point;
663
+ //use formulas y = y0 + slope * (x - x0), x = x0 + (1/slope)* (y - y0)
664
+ if (outcodeOut & TOP) //point is above the clip rectangle
665
+ {
666
+ x = tx0 + (tx1 - tx0) * (ymax - ty0)/(ty1 - ty0);
667
+ y = ymax;
668
+ }
669
+ else if (outcodeOut & BOTTOM) //point is below the clip rectangle
670
+ {
671
+ x = tx0 + (tx1 - tx0) * (ymin - ty0)/(ty1 - ty0);
672
+ y = ymin;
673
+ }
674
+ else if (outcodeOut & RIGHT) //point is to the right of clip rectangle
675
+ {
676
+ y = ty0 + (ty1 - ty0) * (xmax - tx0)/(tx1 - tx0);
677
+ x = xmax;
678
+ }
679
+ else //point is to the left of clip rectangle
680
+ {
681
+ y = ty0 + (ty1 - ty0) * (xmin - tx0)/(tx1 - tx0);
682
+ x = xmin;
683
+ }
684
+ //Now we move outside point to intersection point to clip
685
+ //and get ready for next pass.
686
+ if (outcodeOut == outcode0)
687
+ {
688
+ tx0 = x;
689
+ ty0 = y;
690
+ outcode0 = ComputeOutCode (tx0, ty0, xmin, ymin, xmax, ymax);
691
+ }
692
+ else
693
+ {
694
+ tx1 = x;
695
+ ty1 = y;
696
+ outcode1 = ComputeOutCode (tx1, ty1, xmin, ymin, xmax, ymax);
697
+ }
698
+ }
699
+ }while (!done);
700
+
701
+ if (accept)
702
+ {
703
+ *x0 = tx0; *x1 = tx1;
704
+ *y0 = ty0; *y1 = ty1;
705
+ }
706
+
707
+ }
708
+ /** end of cohen-sutherland line clipper **/
709
+
710
+
711
+ void
712
+ constrain_boundaries(int * x0, int * y0, int * x1, int * y1, int width, int height)
713
+ {
714
+ if(*y0 < 0) *y0 = 0;
715
+ if(*y1 < 0) *y1 = 0;
716
+
717
+ if(*x0 < 0) *x0 = 0;
718
+ if(*x1 < 0) *x1 = 0;
719
+
720
+ if(*x0 > (width - 1)) *x0 = width - 1;
721
+ if(*x1 > (width - 1)) *x1 = width - 1;
722
+
723
+ if(*y0 > (height - 1)) *y0 = height - 1;
724
+ if(*y1 > (height - 1)) *y1 = height - 1;
725
+
726
+ if(*y0 > *y1) { SWAP(*y0, *y1); }
727
+ if(*x0 > *x1) { SWAP(*x0, *x1); }
728
+ }
729
+
730
+
731
+ /* returns true if point (x, y) is within bounds designated by rect (x0, y0)-(x1, y1)
732
+ and inner thickness: 'inner'
733
+ */
734
+ bool
735
+ bound_by_rect_and_inner(int x, int y, int x0, int y0, int x1, int y1, int inner)
736
+ {
737
+
738
+ return ((x >= x0) && (x <= x1) && (y >= y0) && (y <= y1)) &&
739
+ !((x >= x0 + inner) && (x <= x1 - inner) && (y >= y0 + inner) && (y <= y1 - inner));
740
+ }
741
+
742
+ /* same as above but excluding inner rectangle */
743
+ bool
744
+ bound_by_rect(int x, int y, int x0, int y0, int x1, int y1)
745
+ {
746
+ return bound_by_rect_and_inner(x, y, x0, y0, x1, y1, OOB_VAL);
747
+ }
748
+
749
+ /* calculate the array offset for a given pixel in action context */
750
+ int
751
+ calc_pixel_offset_for_action(action_struct * cur, texture_info * tex, int x, int y)
752
+ {
753
+ int offset = calc_pixel_offset(tex, x + cur->xmin, y + cur->ymin);
754
+
755
+ return offset;
756
+ }
757
+
758
+ /* calculate the array offset for a given pixel */
759
+ int
760
+ calc_pixel_offset(texture_info * tex, int x, int y)
761
+ {
762
+ int offset = 4 * (tex->firstpixel + x + tex->yincr * y);
763
+
764
+ return offset;
765
+ }
766
+
767
+ /* NEWEST version that solves segfault on linux, back
768
+ in action due to availability of MAX_TEXTURE_SIZE constant
769
+ in ruby 1.8 */
770
+ unsigned
771
+ max_quad_size(void)
772
+ {
773
+ static unsigned size = 0;
774
+
775
+ if (size == 0) {
776
+ VALUE gosu = rb_const_get(rb_cObject, rb_intern("Gosu"));
777
+ VALUE rb_size = rb_const_get(gosu, rb_intern("MAX_TEXTURE_SIZE"));
778
+
779
+ size = FIX2INT(rb_size);
780
+ }
781
+
782
+ return size;
783
+ }
784
+
785
+ /* old version for quick update, OUT OF ACTIONN */
786
+ /* unsigned */
787
+ /* max_quad_size(void) */
788
+ /* { */
789
+ /* #ifdef __APPLE__ */
790
+ /* return 1024; */
791
+ /* #else */
792
+ /* static unsigned MIN_SIZE = 256, MAX_SIZE = 1024; */
793
+
794
+ /* static unsigned size = 0; */
795
+ /* if (size == 0) */
796
+ /* { */
797
+ /* GLint width = 1; */
798
+ /* size = MIN_SIZE / 2; */
799
+ /* do { */
800
+ /* size *= 2; */
801
+ /* glTexImage2D(GL_PROXY_TEXTURE_2D, 0, 4, size * 2, size * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); */
802
+ /* glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); */
803
+ /* } while (width != 0 && size < MAX_SIZE); */
804
+ /* } */
805
+
806
+ /* return size; */
807
+ /* #endif */
808
+ /* } */
809
+
810
+ /* point format utilities */
811
+ bool
812
+ is_a_point(VALUE try_point)
813
+ {
814
+ /* if it responds to 'x' it's near enough (technically must respond to x AND y) */
815
+ /* added the is_a_num() check due to WEIRD bug where FIXNUMS were responding to the 'x' method (wtf?) but returning nil when invoked */
816
+ if(rb_respond_to(try_point, rb_intern("x")) && !is_a_num(try_point))
817
+ return true;
818
+
819
+ return false;
820
+ }
821
+
822
+ VALUE
823
+ point_x(VALUE point)
824
+ {
825
+ return rb_funcall(point, rb_intern("x"), 0);
826
+ }
827
+
828
+ VALUE
829
+ point_y(VALUE point)
830
+ {
831
+ return rb_funcall(point, rb_intern("y"), 0);
832
+ }
833
+
834
+ /* mathematical utils, used mainly by bezier curves */
835
+ double
836
+ power(float base, int exp)
837
+ {
838
+ float ans = 1.0;
839
+ if(base == 0.0) {
840
+ if(exp == 0)
841
+ return 1;
842
+ else
843
+ return 0;
844
+ }
845
+ else if(exp == 0) return 1;
846
+ else {
847
+ for(int k = exp; k >= 1; k--) {
848
+ ans = ans * base;
849
+ }
850
+ return ans;
851
+ }
852
+ }
853
+
854
+ unsigned
855
+ fact(int n)
856
+ {
857
+ if (n == 0 || n == 1) return 1;
858
+ else
859
+ return (n * fact(n - 1));
860
+ }
861
+
862
+ unsigned
863
+ comb(int n, int r)
864
+ {
865
+ /* nCr is symmetrical about n / 2 */
866
+ if(r > (n / 2))
867
+ r = n - r;
868
+
869
+ return perm(n, r) / fact(r);
870
+ }
871
+
872
+ unsigned
873
+ perm(int n, int r)
874
+ {
875
+ int val = 1;
876
+ for(int i = n; i > (n - r); i--)
877
+ val *= i;
878
+
879
+ return val;
880
+ }
881
+
882
+ double
883
+ bernstein(int n, int k, float u)
884
+ {
885
+ double temp = comb(n, k) * pow(u, k) * pow(1 - u, n - k);
886
+ return temp;
887
+ }