ruby-miyako 2.1.0 → 2.1.1
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.
- data/README +275 -20
- data/extern.h +21 -1
- data/install_miyako.rb +5 -3
- data/lib/Miyako/API/audio.rb +11 -6
- data/lib/Miyako/API/basic_data.rb +0 -985
- data/lib/Miyako/API/bitmap.rb +19 -22
- data/lib/Miyako/API/choices.rb +203 -69
- data/lib/Miyako/API/collision.rb +451 -9
- data/lib/Miyako/API/color.rb +177 -0
- data/lib/Miyako/API/diagram.rb +18 -20
- data/lib/Miyako/API/fixedmap.rb +207 -73
- data/lib/Miyako/API/font.rb +111 -18
- data/lib/Miyako/API/i_yuki.rb +1201 -0
- data/lib/Miyako/API/input.rb +65 -0
- data/lib/Miyako/API/layout.rb +41 -29
- data/lib/Miyako/API/map.rb +202 -157
- data/lib/Miyako/API/map_event.rb +86 -19
- data/lib/Miyako/API/map_struct.rb +268 -0
- data/lib/Miyako/API/modules.rb +136 -37
- data/lib/Miyako/API/movie.rb +8 -8
- data/lib/Miyako/API/parts.rb +63 -20
- data/lib/Miyako/API/plane.rb +4 -4
- data/lib/Miyako/API/screen.rb +16 -8
- data/lib/Miyako/API/sprite.rb +290 -23
- data/lib/Miyako/API/sprite_animation.rb +23 -11
- data/lib/Miyako/API/sprite_list.rb +406 -183
- data/lib/Miyako/API/story.rb +4 -65
- data/lib/Miyako/API/struct_point.rb +157 -0
- data/lib/Miyako/API/struct_rect.rb +233 -0
- data/lib/Miyako/API/struct_segment.rb +641 -0
- data/lib/Miyako/API/struct_size.rb +158 -0
- data/lib/Miyako/API/struct_square.rb +253 -0
- data/lib/Miyako/API/textbox.rb +49 -35
- data/lib/Miyako/API/viewport.rb +5 -5
- data/lib/Miyako/API/wait_counter.rb +350 -0
- data/lib/Miyako/API/yuki.rb +95 -60
- data/lib/Miyako/EXT/raster_scroll.rb +30 -8
- data/lib/Miyako/EXT/slides.rb +6 -6
- data/lib/Miyako/miyako.rb +25 -11
- data/lib/miyako.rb +28 -0
- data/lib/miyako_require_only.rb +35 -0
- data/miyako_basicdata.c +201 -17
- data/miyako_collision.c +315 -6
- data/miyako_diagram.c +331 -0
- data/miyako_drawing.c +26 -7
- data/miyako_font.c +259 -129
- data/miyako_input_audio.c +24 -14
- data/miyako_layout.c +106 -8
- data/miyako_no_katana.c +398 -171
- data/miyako_sprite2.c +275 -38
- data/miyako_transform.c +113 -107
- data/miyako_utility.c +34 -48
- data/miyako_yuki.c +241 -0
- data/sample/Diagram_sample/diagram_sample_yuki2.rb +30 -30
- data/sample/Room3/blue.rb +19 -19
- data/sample/Room3/green.rb +9 -9
- data/sample/Room3/main.rb +12 -12
- data/sample/Room3/red.rb +12 -12
- data/sample/Room3/title.rb +15 -10
- data/sample/collision_test2.rb +2 -1
- data/sample/fixed_map_test/fixed_map_sample.rb +7 -6
- data/sample/map_test/main_scene.rb +12 -10
- data/sample/map_test/map_manager.rb +14 -13
- data/sample/rasterscroll.rb +5 -5
- data/sample/takahashi.rb +3 -3
- data/sample/textbox_sample.rb +7 -6
- data/sample/transform.rb +2 -1
- data/uninstall_miyako.rb +4 -1
- data/win/miyako_no_katana.so +0 -0
- metadata +15 -4
- data/lib/Miyako/EXT/miyako_cairo.rb +0 -62
- data/sample/cairo_sample.rb +0 -25
data/miyako_transform.c
CHANGED
@@ -60,9 +60,9 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
|
|
60
60
|
|
61
61
|
size.w = dst.rect.w;
|
62
62
|
size.h = dst.rect.h;
|
63
|
-
|
63
|
+
|
64
64
|
if(src.surface == dst.surface){ return Qnil; }
|
65
|
-
|
65
|
+
|
66
66
|
if(dst.rect.w >= 32768 || dst.rect.h >= 32768){ return Qnil; }
|
67
67
|
|
68
68
|
double rad = NUM2DBL(radian) * -1.0;
|
@@ -77,6 +77,8 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
|
|
77
77
|
int qy = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+8)));
|
78
78
|
int qr = dst.rect.w + qx;
|
79
79
|
int qb = dst.rect.h + qy;
|
80
|
+
Uint32 sr, sg, sb, sa;
|
81
|
+
Uint32 dr, dg, db, da;
|
80
82
|
|
81
83
|
SDL_LockSurface(src.surface);
|
82
84
|
SDL_LockSurface(dst.surface);
|
@@ -92,50 +94,50 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
|
|
92
94
|
int ny = (x*isin+y*icos) >> 12;
|
93
95
|
if(ny < py || ny >= pb){ tp++; continue; }
|
94
96
|
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
95
|
-
|
96
|
-
|
97
|
-
|
98
|
-
|
99
|
-
|
100
|
-
src.color.a = (*psrc >> 24) & 0xff | src.a255;
|
101
|
-
if(src.color.a == 0){ tp++; continue; }
|
102
|
-
if(dst.color.a == 0 || src.color.a == 255)
|
97
|
+
da = (*tp >> 24) | dst.a255;
|
98
|
+
Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
|
99
|
+
sa = (*psrc >> 24) | src.a255;
|
100
|
+
if(sa == 0){ tp++; continue; }
|
101
|
+
if(da == 0 || sa == 255)
|
103
102
|
{
|
104
103
|
*tp = *psrc;
|
105
104
|
tp++;
|
106
105
|
continue;
|
107
106
|
}
|
108
|
-
int a1 =
|
109
|
-
int a2 = 256 -
|
110
|
-
|
111
|
-
|
112
|
-
|
113
|
-
|
114
|
-
|
115
|
-
|
116
|
-
|
107
|
+
int a1 = sa + 1;
|
108
|
+
int a2 = 256 - sa;
|
109
|
+
dr = *tp & 0xff0000;
|
110
|
+
dg = *tp & 0xff00;
|
111
|
+
db = *tp & 0xff;
|
112
|
+
sr = *psrc & 0xff0000;
|
113
|
+
sg = *psrc & 0xff00;
|
114
|
+
sb = *psrc & 0xff;
|
115
|
+
*tp = ((sr * a1 + dr * a2) & 0xff000000 |
|
116
|
+
(sg * a1 + dg * a2) & 0xff0000 |
|
117
|
+
(sb * a1 + db * a2)) >> 8 |
|
118
|
+
0xff000000;
|
117
119
|
#else
|
118
|
-
|
119
|
-
|
120
|
-
|
121
|
-
|
120
|
+
dr = (*tp & dst.fmt->Rmask) >> dst.fmt->Rshift;
|
121
|
+
dg = (*tp & dst.fmt->Gmask) >> dst.fmt->Gshift;
|
122
|
+
db = (*tp & dst.fmt->Bmask) >> dst.fmt->Bshift;
|
123
|
+
da = (*tp & dst.fmt->Amask) | dst.a255;
|
122
124
|
Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
|
123
|
-
|
124
|
-
if(
|
125
|
-
if(
|
125
|
+
sa = (*psrc & src.fmt->Amask) | src.a255;
|
126
|
+
if(sa == 0){ tp++; continue; }
|
127
|
+
if(da == 0 || sa == 255)
|
126
128
|
{
|
127
129
|
*tp = *psrc;
|
128
130
|
tp++;
|
129
131
|
continue;
|
130
132
|
}
|
131
|
-
int a1 =
|
132
|
-
int a2 = 256 -
|
133
|
-
|
134
|
-
|
135
|
-
|
136
|
-
*tp = (((
|
137
|
-
(((
|
138
|
-
(((
|
133
|
+
int a1 = sa + 1;
|
134
|
+
int a2 = 256 - sa;
|
135
|
+
sr = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
|
136
|
+
sg = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
|
137
|
+
sb = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
|
138
|
+
*tp = (((sr * a1 + dr * a2) >> 8)) << dst.fmt->Rshift |
|
139
|
+
(((sg * a1 + dg * a2) >> 8)) << dst.fmt->Gshift |
|
140
|
+
(((sb * a1 + db * a2) >> 8)) << dst.fmt->Bshift |
|
139
141
|
0xff;
|
140
142
|
#endif
|
141
143
|
tp++;
|
@@ -144,7 +146,7 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
|
|
144
146
|
|
145
147
|
SDL_UnlockSurface(src.surface);
|
146
148
|
SDL_UnlockSurface(dst.surface);
|
147
|
-
|
149
|
+
|
148
150
|
return vdst;
|
149
151
|
}
|
150
152
|
|
@@ -156,13 +158,15 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
|
|
156
158
|
MiyakoBitmap src, dst;
|
157
159
|
MiyakoSize size;
|
158
160
|
SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
|
161
|
+
Uint32 sr, sg, sb, sa;
|
162
|
+
Uint32 dr, dg, db, da;
|
159
163
|
|
160
164
|
_miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
|
161
165
|
|
162
166
|
if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
|
163
|
-
|
167
|
+
|
164
168
|
if(src.surface == dst.surface){ return Qnil; }
|
165
|
-
|
169
|
+
|
166
170
|
if(dst.rect.w >= 32768 || dst.rect.h >= 32768){ return Qnil; }
|
167
171
|
|
168
172
|
double tscx = NUM2DBL(xscale);
|
@@ -199,50 +203,50 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
|
|
199
203
|
int ny = (y*scy) >> 12 - off_y;
|
200
204
|
if(ny < py || ny >= pb){ tp++; continue; }
|
201
205
|
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
202
|
-
|
203
|
-
dst.color.g = (*tp >> 8) & 0xff;
|
204
|
-
dst.color.b = (*tp ) & 0xff;
|
205
|
-
dst.color.a = (*tp >> 24) & 0xff | dst.a255;
|
206
|
+
da = (*tp >> 24) | dst.a255;
|
206
207
|
Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
|
207
|
-
|
208
|
-
if(
|
209
|
-
if(
|
208
|
+
sa = (*psrc >> 24) | src.a255;
|
209
|
+
if(sa == 0){ tp++; continue; }
|
210
|
+
if(da == 0 || sa == 255)
|
210
211
|
{
|
211
212
|
*tp = *psrc;
|
212
213
|
tp++;
|
213
214
|
continue;
|
214
215
|
}
|
215
|
-
int a1 =
|
216
|
-
int a2 = 256 -
|
217
|
-
|
218
|
-
|
219
|
-
|
220
|
-
|
221
|
-
|
222
|
-
|
223
|
-
|
216
|
+
int a1 = sa + 1;
|
217
|
+
int a2 = 256 - sa;
|
218
|
+
dr = *tp & 0xff0000;
|
219
|
+
dg = *tp & 0xff00;
|
220
|
+
db = *tp & 0xff;
|
221
|
+
sr = *psrc & 0xff0000;
|
222
|
+
sg = *psrc & 0xff00;
|
223
|
+
sb = *psrc & 0xff;
|
224
|
+
*tp = ((sr * a1 + dr * a2) & 0xff000000 |
|
225
|
+
(sg * a1 + dg * a2) & 0xff0000 |
|
226
|
+
(sb * a1 + db * a2)) >> 8 |
|
227
|
+
0xff000000;
|
224
228
|
#else
|
225
|
-
|
226
|
-
|
227
|
-
|
228
|
-
|
229
|
+
dr = (*tp & dst.fmt->Rmask) >> dst.fmt->Rshift;
|
230
|
+
dg = (*tp & dst.fmt->Gmask) >> dst.fmt->Gshift;
|
231
|
+
db = (*tp & dst.fmt->Bmask) >> dst.fmt->Bshift;
|
232
|
+
da = (*tp & dst.fmt->Amask) | dst.a255;
|
229
233
|
Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
|
230
|
-
|
231
|
-
if(
|
232
|
-
if(
|
234
|
+
sa = (*psrc & src.fmt->Amask) | src.a255;
|
235
|
+
if(sa == 0){ tp++; continue; }
|
236
|
+
if(da == 0 || sa == 255)
|
233
237
|
{
|
234
238
|
*tp = *psrc;
|
235
239
|
tp++;
|
236
240
|
continue;
|
237
241
|
}
|
238
|
-
int a1 =
|
239
|
-
int a2 = 256 -
|
240
|
-
|
241
|
-
|
242
|
-
|
243
|
-
*tp = ((
|
244
|
-
((
|
245
|
-
((
|
242
|
+
int a1 = sa + 1;
|
243
|
+
int a2 = 256 - sa;
|
244
|
+
sr = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
|
245
|
+
sg = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
|
246
|
+
sb = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
|
247
|
+
*tp = ((sr * a1 + dr * a2) >> 8) << dst.fmt->Rshift |
|
248
|
+
((sg * a1 + dg * a2) >> 8) << dst.fmt->Gshift |
|
249
|
+
((sb * a1 + db * a2) >> 8) << dst.fmt->Bshift |
|
246
250
|
0xff;
|
247
251
|
#endif
|
248
252
|
tp++;
|
@@ -251,7 +255,7 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
|
|
251
255
|
|
252
256
|
SDL_UnlockSurface(src.surface);
|
253
257
|
SDL_UnlockSurface(dst.surface);
|
254
|
-
|
258
|
+
|
255
259
|
return vdst;
|
256
260
|
}
|
257
261
|
|
@@ -265,7 +269,7 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
|
|
265
269
|
MiyakoSize size;
|
266
270
|
|
267
271
|
if(_miyako_init_rect(src, dst, &size) == 0) return;
|
268
|
-
|
272
|
+
|
269
273
|
double rad = NUM2DBL(radian) * -1.0;
|
270
274
|
long isin = (long)(sin(rad)*4096.0);
|
271
275
|
long icos = (long)(cos(rad)*4096.0);
|
@@ -289,6 +293,8 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
|
|
289
293
|
int qy = -(NUM2INT(*(RSTRUCT_PTR(dst->unit)+8)));
|
290
294
|
int qr = dst->rect.w + qx;
|
291
295
|
int qb = dst->rect.h + qy;
|
296
|
+
Uint32 sr, sg, sb, sa;
|
297
|
+
Uint32 dr, dg, db, da;
|
292
298
|
|
293
299
|
SDL_LockSurface(src->surface);
|
294
300
|
SDL_LockSurface(dst->surface);
|
@@ -304,50 +310,50 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
|
|
304
310
|
int ny = (((x*isin+y*icos) >> 12) * scy) >> 12 - off_y;
|
305
311
|
if(ny < py || ny >= pb){ tp++; continue; }
|
306
312
|
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
307
|
-
|
308
|
-
|
309
|
-
|
310
|
-
|
311
|
-
|
312
|
-
src->color.a = (*psrc >> 24) & 0xff | src->a255;
|
313
|
-
if(src->color.a == 0){ tp++; continue; }
|
314
|
-
if(dst->color.a == 0 || src->color.a == 255)
|
313
|
+
da = (*tp >> 24) | dst->a255;
|
314
|
+
Uint32 *psrc = src->ptr + (src->rect.x + ny - py) * src->surface->w + src->rect.x + nx - px;
|
315
|
+
sa = (*psrc >> 24) | src->a255;
|
316
|
+
if(sa == 0){ tp++; continue; }
|
317
|
+
if(da == 0 || sa == 255)
|
315
318
|
{
|
316
319
|
*tp = *psrc;
|
317
320
|
tp++;
|
318
321
|
continue;
|
319
322
|
}
|
320
|
-
int a1 =
|
321
|
-
int a2 = 256 -
|
322
|
-
|
323
|
-
|
324
|
-
|
325
|
-
|
326
|
-
|
327
|
-
|
328
|
-
|
323
|
+
int a1 = sa + 1;
|
324
|
+
int a2 = 256 - sa;
|
325
|
+
dr = *tp & 0xff0000;
|
326
|
+
dg = *tp & 0xff00;
|
327
|
+
db = *tp & 0xff;
|
328
|
+
sr = *psrc & 0xff0000;
|
329
|
+
sg = *psrc & 0xff00;
|
330
|
+
sb = *psrc & 0xff;
|
331
|
+
*tp = ((sr * a1 + dr * a2) & 0xff000000 |
|
332
|
+
(sg * a1 + dg * a2) & 0xff0000 |
|
333
|
+
(sb * a1 + db * a2)) >> 8 |
|
334
|
+
0xff000000;
|
329
335
|
#else
|
330
|
-
|
331
|
-
|
332
|
-
|
333
|
-
|
336
|
+
dr = (*tp & dst->fmt->Rmask) >> dst->fmt->Rshift;
|
337
|
+
dg = (*tp & dst->fmt->Gmask) >> dst->fmt->Gshift;
|
338
|
+
db = (*tp & dst->fmt->Bmask) >> dst->fmt->Bshift;
|
339
|
+
da = (*tp & dst->fmt->Amask) | dst->a255;
|
334
340
|
Uint32 *psrc = src->ptr + (src->rect.x + ny - py) * src->surface->w + src->rect.x + nx - px;
|
335
|
-
|
336
|
-
if(
|
337
|
-
if(
|
341
|
+
sa = (*psrc & src->fmt->Amask) | src->a255;
|
342
|
+
if(sa == 0){ tp++; continue; }
|
343
|
+
if(da == 0 || sa == 255)
|
338
344
|
{
|
339
345
|
*tp = *psrc;
|
340
346
|
tp++;
|
341
347
|
continue;
|
342
348
|
}
|
343
|
-
int a1 =
|
344
|
-
int a2 = 256 -
|
345
|
-
|
346
|
-
|
347
|
-
|
348
|
-
*tp = ((
|
349
|
-
((
|
350
|
-
((
|
349
|
+
int a1 = sa + 1;
|
350
|
+
int a2 = 256 - sa;
|
351
|
+
sr = (*psrc & src->fmt->Rmask) >> src->fmt->Rshift;
|
352
|
+
sg = (*psrc & src->fmt->Gmask) >> src->fmt->Gshift;
|
353
|
+
sb = (*psrc & src->fmt->Bmask) >> src->fmt->Bshift;
|
354
|
+
*tp = ((sr * a1 + dr * a2) >> 8) << dst->fmt->Rshift |
|
355
|
+
((sg * a1 + dg * a2) >> 8) << dst->fmt->Gshift |
|
356
|
+
((sb * a1 + db * a2) >> 8) << dst->fmt->Bshift |
|
351
357
|
0xff;
|
352
358
|
#endif
|
353
359
|
tp++;
|
@@ -369,7 +375,7 @@ static VALUE bitmap_miyako_transform(VALUE self, VALUE vsrc, VALUE vdst, VALUE r
|
|
369
375
|
_miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
|
370
376
|
|
371
377
|
if(src.surface == dst.surface){ return Qnil; }
|
372
|
-
|
378
|
+
|
373
379
|
transform_inner(&src, &dst, radian, xscale, yscale);
|
374
380
|
return vdst;
|
375
381
|
}
|
@@ -387,7 +393,7 @@ static VALUE sprite_render_transform(VALUE self, VALUE radian, VALUE xscale, VAL
|
|
387
393
|
_miyako_setup_unit_2(self, mScreen, scr, &src, &dst, Qnil, Qnil, 1);
|
388
394
|
|
389
395
|
if(src.surface == dst.surface){ return Qnil; }
|
390
|
-
|
396
|
+
|
391
397
|
transform_inner(&src, &dst, radian, xscale, yscale);
|
392
398
|
return self;
|
393
399
|
}
|
@@ -403,9 +409,9 @@ static VALUE sprite_render_to_sprite_transform(VALUE self, VALUE vdst, VALUE rad
|
|
403
409
|
SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
|
404
410
|
|
405
411
|
_miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
|
406
|
-
|
412
|
+
|
407
413
|
if(src.surface == dst.surface){ return Qnil; }
|
408
|
-
|
414
|
+
|
409
415
|
transform_inner(&src, &dst, radian, xscale, yscale);
|
410
416
|
return self;
|
411
417
|
}
|
@@ -421,7 +427,7 @@ void Init_miyako_transform()
|
|
421
427
|
|
422
428
|
rb_define_method(cSprite, "render_transform", sprite_render_transform, 3);
|
423
429
|
rb_define_method(cSprite, "render_to_transform", sprite_render_to_sprite_transform, 4);
|
424
|
-
|
430
|
+
|
425
431
|
id_update = rb_intern("update");
|
426
432
|
id_kakko = rb_intern("[]");
|
427
433
|
id_render = rb_intern("render");
|
data/miyako_utility.c
CHANGED
@@ -37,22 +37,7 @@ static VALUE sSpriteUnit = Qnil;
|
|
37
37
|
// from rubysdl_video.c
|
38
38
|
static GLOBAL_DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
|
39
39
|
|
40
|
-
void
|
41
|
-
{
|
42
|
-
if(rb_block_given_p() == Qtrue){ src->unit = rb_obj_dup(src->unit); rb_yield(src->unit); }
|
43
|
-
}
|
44
|
-
|
45
|
-
void _miyako_yield_unit_2(MiyakoBitmap *src, MiyakoBitmap *dst)
|
46
|
-
{
|
47
|
-
if(rb_block_given_p() == Qtrue)
|
48
|
-
{
|
49
|
-
src->unit = rb_obj_dup(src->unit);
|
50
|
-
dst->unit = rb_obj_dup(dst->unit);
|
51
|
-
rb_yield_values(2, src->unit, dst->unit);
|
52
|
-
}
|
53
|
-
}
|
54
|
-
|
55
|
-
void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE x, VALUE y, int use_yield)
|
40
|
+
void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE x, VALUE y)
|
56
41
|
{
|
57
42
|
mb->unit = unit;
|
58
43
|
if(rb_obj_is_kind_of(mb->unit, sSpriteUnit) == Qfalse){
|
@@ -60,13 +45,13 @@ void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE
|
|
60
45
|
if(mb->unit == Qnil){ rb_raise(eMiyakoError, "Source instance has not SpriteUnit!"); }
|
61
46
|
}
|
62
47
|
|
63
|
-
|
48
|
+
VALUE *mb_p = RSTRUCT_PTR(mb->unit);
|
49
|
+
|
50
|
+
mb->rect.x = NUM2INT(*(mb_p + 1));
|
51
|
+
mb->rect.y = NUM2INT(*(mb_p + 2));
|
52
|
+
mb->rect.w = NUM2INT(*(mb_p + 3));
|
53
|
+
mb->rect.h = NUM2INT(*(mb_p + 4));
|
64
54
|
|
65
|
-
mb->rect.x = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 1));
|
66
|
-
mb->rect.y = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 2));
|
67
|
-
mb->rect.w = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 3));
|
68
|
-
mb->rect.h = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 4));
|
69
|
-
|
70
55
|
mb->surface = GetSurface(*(RSTRUCT_PTR(mb->unit)))->surface;
|
71
56
|
mb->ptr = (Uint32 *)(mb->surface->pixels);
|
72
57
|
mb->fmt = mb->surface->format;
|
@@ -92,17 +77,17 @@ void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE
|
|
92
77
|
if(mb->rect.y + mb->rect.h > mb->surface->h)
|
93
78
|
mb->rect.h = mb->surface->h - mb->rect.y;
|
94
79
|
}
|
95
|
-
|
80
|
+
|
96
81
|
mb->a255 = (mb->surface == screen) ? 0xff : 0;
|
97
|
-
|
98
|
-
mb->x = (x == Qnil ? NUM2INT(*(
|
99
|
-
mb->y = (y == Qnil ? NUM2INT(*(
|
82
|
+
|
83
|
+
mb->x = (x == Qnil ? NUM2INT(*(mb_p + 5)) : NUM2INT(x));
|
84
|
+
mb->y = (y == Qnil ? NUM2INT(*(mb_p+ 6)) : NUM2INT(y));
|
100
85
|
}
|
101
86
|
|
102
|
-
void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
|
87
|
+
void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
|
103
88
|
SDL_Surface *screen,
|
104
89
|
MiyakoBitmap *mb_s, MiyakoBitmap *mb_d,
|
105
|
-
VALUE x, VALUE y
|
90
|
+
VALUE x, VALUE y)
|
106
91
|
{
|
107
92
|
mb_s->unit = unit_s;
|
108
93
|
if(rb_obj_is_kind_of(mb_s->unit, sSpriteUnit) == Qfalse){
|
@@ -116,16 +101,17 @@ void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
|
|
116
101
|
if(mb_d->unit == Qnil){ rb_raise(eMiyakoError, "Source instance has not SpriteUnit!"); }
|
117
102
|
}
|
118
103
|
|
119
|
-
if(use_yield) _miyako_yield_unit_2(mb_s, mb_d);
|
120
|
-
|
121
104
|
mb_s->surface = GetSurface(*(RSTRUCT_PTR(mb_s->unit)))->surface;
|
122
105
|
mb_s->ptr = (Uint32 *)(mb_s->surface->pixels);
|
123
106
|
mb_s->fmt = mb_s->surface->format;
|
124
107
|
|
125
|
-
|
126
|
-
|
127
|
-
|
128
|
-
mb_s->rect.
|
108
|
+
VALUE *ms_p = RSTRUCT_PTR(mb_s->unit);
|
109
|
+
VALUE *md_p = RSTRUCT_PTR(mb_d->unit);
|
110
|
+
|
111
|
+
mb_s->rect.x = NUM2INT(*(ms_p + 1));
|
112
|
+
mb_s->rect.y = NUM2INT(*(ms_p + 2));
|
113
|
+
mb_s->rect.w = NUM2INT(*(ms_p + 3));
|
114
|
+
mb_s->rect.h = NUM2INT(*(ms_p + 4));
|
129
115
|
|
130
116
|
// adjust clip_rect
|
131
117
|
if(mb_s->surface == screen)
|
@@ -150,18 +136,18 @@ void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
|
|
150
136
|
}
|
151
137
|
|
152
138
|
mb_s->a255 = (mb_s->surface == screen) ? 0xff : 0;
|
153
|
-
|
154
|
-
mb_s->x = (x == Qnil ? NUM2INT(*(
|
155
|
-
mb_s->y = (y == Qnil ? NUM2INT(*(
|
139
|
+
|
140
|
+
mb_s->x = (x == Qnil ? NUM2INT(*(ms_p + 5)) : NUM2INT(x));
|
141
|
+
mb_s->y = (y == Qnil ? NUM2INT(*(ms_p + 6)) : NUM2INT(y));
|
156
142
|
|
157
143
|
mb_d->surface = GetSurface(*(RSTRUCT_PTR(mb_d->unit)))->surface;
|
158
144
|
mb_d->ptr = (Uint32 *)(mb_d->surface->pixels);
|
159
145
|
mb_d->fmt = mb_d->surface->format;
|
160
146
|
|
161
|
-
mb_d->rect.x = NUM2INT(*(
|
162
|
-
mb_d->rect.y = NUM2INT(*(
|
163
|
-
mb_d->rect.w = NUM2INT(*(
|
164
|
-
mb_d->rect.h = NUM2INT(*(
|
147
|
+
mb_d->rect.x = NUM2INT(*(md_p + 1));
|
148
|
+
mb_d->rect.y = NUM2INT(*(md_p + 2));
|
149
|
+
mb_d->rect.w = NUM2INT(*(md_p + 3));
|
150
|
+
mb_d->rect.h = NUM2INT(*(md_p + 4));
|
165
151
|
|
166
152
|
// adjust clip_rect
|
167
153
|
if(mb_d->surface == screen)
|
@@ -186,7 +172,7 @@ void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
|
|
186
172
|
}
|
187
173
|
|
188
174
|
mb_d->a255 = (mb_d->surface == screen) ? 0xff : 0;
|
189
|
-
|
175
|
+
|
190
176
|
mb_d->x = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 5));
|
191
177
|
mb_d->y = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 6));
|
192
178
|
}
|
@@ -199,13 +185,13 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
|
|
199
185
|
int dh = dst->rect.h;
|
200
186
|
|
201
187
|
// ox(oy)が画像のw(h)以上の時は転送不可
|
202
|
-
|
188
|
+
|
203
189
|
if(src->rect.x >= src->surface->w || src->rect.y >= src->surface->h) return 0;
|
204
190
|
if(dst->rect.x >= dst->surface->w || dst->rect.y >= dst->surface->h) return 0;
|
205
191
|
|
206
192
|
// ox(oy)がマイナスの時は、ow(oh)を減らしておいて、ox, oyをゼロにしておく
|
207
193
|
// 0以下になったら転送不可
|
208
|
-
|
194
|
+
|
209
195
|
if(src->rect.x < 0){
|
210
196
|
sw += src->rect.x;
|
211
197
|
src->rect.x = 0;
|
@@ -229,7 +215,7 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
|
|
229
215
|
|
230
216
|
// ox(oy)+ow(oh)が、w(h)を越える場合は、ow(oh)を減らしておく
|
231
217
|
// 0以下になったら転送不可
|
232
|
-
|
218
|
+
|
233
219
|
if(src->rect.x + sw > src->surface->w)
|
234
220
|
{
|
235
221
|
sw += (src->surface->w - src->rect.x - sw);
|
@@ -252,13 +238,13 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
|
|
252
238
|
}
|
253
239
|
|
254
240
|
// ox(oy)が画像のw(h)以上、-w(-h)以下の時は転送不可
|
255
|
-
|
241
|
+
|
256
242
|
if(src->x >= dw || src->x <= -dw) return 0;
|
257
243
|
if(src->y >= dh || src->y <= -dh) return 0;
|
258
244
|
|
259
245
|
// x(y)がマイナスの時は、ow(oh)を減らしておいて、x, yをゼロにしておく
|
260
246
|
// 0以下になったら転送不可
|
261
|
-
|
247
|
+
|
262
248
|
if(src->x < 0){
|
263
249
|
dw += src->x;
|
264
250
|
src->x = 0;
|
@@ -274,7 +260,7 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
|
|
274
260
|
|
275
261
|
size->w = (dw > sw ? sw : dw);
|
276
262
|
size->h = (dh > sh ? sh : dh);
|
277
|
-
|
263
|
+
|
278
264
|
return 1;
|
279
265
|
}
|
280
266
|
|