ruby-miyako 2.1.4 → 2.1.5

Sign up to get free protection for your applications and to get access to all the features.
Files changed (40) hide show
  1. data/README +42 -5
  2. data/lib/Miyako/API/choices.rb +0 -2
  3. data/lib/Miyako/API/collision.rb +0 -4
  4. data/lib/Miyako/API/fixedmap.rb +0 -3
  5. data/lib/Miyako/API/i_yuki.rb +28 -46
  6. data/lib/Miyako/API/layout.rb +0 -1
  7. data/lib/Miyako/API/map.rb +0 -2
  8. data/lib/Miyako/API/map_event.rb +0 -3
  9. data/lib/Miyako/API/map_struct.rb +0 -2
  10. data/lib/Miyako/API/parts.rb +0 -11
  11. data/lib/Miyako/API/screen.rb +3 -4
  12. data/lib/Miyako/API/shape.rb +27 -27
  13. data/lib/Miyako/API/sprite.rb +0 -2
  14. data/lib/Miyako/API/story.rb +0 -2
  15. data/lib/Miyako/API/textbox.rb +9 -11
  16. data/lib/Miyako/API/utility.rb +2 -2
  17. data/lib/Miyako/API/yuki.rb +19 -8
  18. data/lib/Miyako/miyako.rb +3 -0
  19. data/miyako_basicdata.c +52 -5
  20. data/miyako_bitmap.c +351 -342
  21. data/miyako_collision.c +77 -67
  22. data/miyako_diagram.c +22 -21
  23. data/miyako_drawing.c +9 -6
  24. data/miyako_font.c +63 -53
  25. data/miyako_hsv.c +428 -436
  26. data/miyako_input_audio.c +17 -14
  27. data/miyako_layout.c +23 -18
  28. data/miyako_no_katana.c +284 -248
  29. data/miyako_sprite2.c +30 -18
  30. data/miyako_transform.c +95 -93
  31. data/miyako_utility.c +9 -18
  32. data/miyako_yuki.c +10 -6
  33. data/sample/Diagram_sample/diagram_sample_yuki2.rb +2 -2
  34. data/sample/Room3/room3.rb +8 -10
  35. data/sample/ball_action_sample.rb +8 -8
  36. data/sample/map_test/main_scene.rb +1 -1
  37. data/sample/map_test/map_test.rb +8 -8
  38. data/sample/takahashi.rb +14 -14
  39. data/win/miyako_no_katana.so +0 -0
  40. metadata +6 -4
data/miyako_hsv.c CHANGED
@@ -20,8 +20,8 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
20
  */
21
21
 
22
22
  /*
23
- =拡張ライブラリmiyako_no_katana
24
- Authors:: サイロス誠
23
+ =miyako_no_katana
24
+ Authors:: Cyross Makoto
25
25
  Version:: 2.0
26
26
  Copyright:: 2007-2008 Cyross Makoto
27
27
  License:: LGPL2.1
@@ -45,10 +45,10 @@ static volatile int one = Qnil;
45
45
 
46
46
  // from rubysdl_video.c
47
47
  static GLOBAL_DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
48
-
48
+
49
49
  #define MIYAKO_RGB2HSV(RGBSTRUCT, HSVH, HSVS, HSVV) \
50
- Uint32 imax = RGBSTRUCT.r; \
51
- Uint32 imin = imax; \
50
+ imax = RGBSTRUCT.r; \
51
+ imin = imax; \
52
52
  imax = imax < RGBSTRUCT.g ? RGBSTRUCT.g : imax; \
53
53
  imax = imax < RGBSTRUCT.b ? RGBSTRUCT.b : imax; \
54
54
  imin = imin > RGBSTRUCT.g ? RGBSTRUCT.g : imin; \
@@ -57,7 +57,7 @@ static GLOBAL_DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
57
57
  else \
58
58
  { \
59
59
  HSVV = div255[imax]; \
60
- double delta = HSVV - div255[imin]; \
60
+ delta = HSVV - div255[imin]; \
61
61
  HSVS = delta / HSVV; \
62
62
  if(HSVS == 0.0){ HSVH = 0.0; } \
63
63
  else \
@@ -75,7 +75,7 @@ static GLOBAL_DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
75
75
  if(HSVS == 0.0){ RGBSTRUCT.r = RGBSTRUCT.g = RGBSTRUCT.b = (Uint32)(HSVV * 255.0); } \
76
76
  else \
77
77
  { \
78
- double tmp_i = HSVH / 60.0; \
78
+ tmp_i = HSVH / 60.0; \
79
79
  if( tmp_i < 1.0){ i = 0.0; } \
80
80
  else if(tmp_i < 2.0){ i = 1.0; } \
81
81
  else if(tmp_i < 3.0){ i = 2.0; } \
@@ -96,124 +96,121 @@ static GLOBAL_DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
96
96
  RGBSTRUCT.g = (Uint32)(g * 255.0); \
97
97
  RGBSTRUCT.b = (Uint32)(b * 255.0); \
98
98
  }
99
-
99
+
100
100
  static volatile double div255[256];
101
101
 
102
- /*
103
- 画像の色相を変更する
104
- */
105
102
  static VALUE bitmap_miyako_hue(VALUE self, VALUE vsrc, VALUE vdst, VALUE degree)
106
103
  {
107
104
  MiyakoBitmap src, dst;
108
105
  MiyakoSize size;
109
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
110
-
111
- _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
112
-
113
- if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
114
-
115
- int x, y;
106
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
107
+ int x, y, a1, a2;
108
+ Uint32 imax, imin;
116
109
 
110
+ double delta, tmp_i;
117
111
  double deg = NUM2DBL(degree);
118
112
  double d_pi = 360.0;
119
113
  double ph = 0.0, ps = 0.0, pv = 0.0;
120
114
  double r = 0.0, g = 0.0, b = 0.0;
121
115
  double i = 0.0, f, m, n, k;
122
116
 
117
+ _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
118
+
119
+ if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
120
+
123
121
  if(deg <= -360.0 || deg >= 360.0){ return Qnil; }
124
-
125
- SDL_LockSurface(src.surface);
126
- SDL_LockSurface(dst.surface);
127
-
128
- for(y = 0; y < size.h; y++)
129
- {
130
- Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
131
- Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
132
- for(x = 0; x < size.w; x++)
133
- {
122
+
123
+ SDL_LockSurface(src.surface);
124
+ SDL_LockSurface(dst.surface);
125
+
126
+ for(y = 0; y < size.h; y++)
127
+ {
128
+ Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
129
+ Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
130
+ for(x = 0; x < size.w; x++)
131
+ {
134
132
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
135
133
  src.color.r = (*psrc >> 16) & 0xff;
136
134
  src.color.g = (*psrc >> 8) & 0xff;
137
135
  src.color.b = (*psrc ) & 0xff;
138
136
  src.color.a = (*psrc >> 24) & 0xff | src.a255;
139
- if(src.color.a == 0){ psrc++; pdst++; continue; }
137
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
140
138
  dst.color.r = (*pdst >> 16) & 0xff;
141
139
  dst.color.g = (*pdst >> 8) & 0xff;
142
140
  dst.color.b = (*pdst ) & 0xff;
143
141
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
144
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
145
- ph += deg;
146
- if(ph < 0.0){ ph += d_pi; }
147
- if(ph >= d_pi){ ph -= d_pi; }
148
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
149
- if(dst.color.a == 0 || src.color.a == 255){
150
- *pdst = (src.color.r) << 16 |
151
- (src.color.g) << 8 |
152
- (src.color.b) |
153
- (src.color.a) << 24;
154
- psrc++;
155
- pdst++;
156
- continue;
157
- }
158
- int a1 = src.color.a + 1;
159
- int a2 = 256 - src.color.a;
160
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
161
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
162
- ((src.color.b * a1 + dst.color.b * a2) >> 8) |
163
- 0xff << 24;
142
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
143
+ ph += deg;
144
+ if(ph < 0.0){ ph += d_pi; }
145
+ if(ph >= d_pi){ ph -= d_pi; }
146
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
147
+ if(dst.color.a == 0 || src.color.a == 255){
148
+ *pdst = (src.color.r) << 16 |
149
+ (src.color.g) << 8 |
150
+ (src.color.b) |
151
+ (src.color.a) << 24;
152
+ psrc++;
153
+ pdst++;
154
+ continue;
155
+ }
156
+ a1 = src.color.a + 1;
157
+ a2 = 256 - src.color.a;
158
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
159
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
160
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) |
161
+ 0xff << 24;
164
162
  #else
165
163
  src.color.r = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
166
164
  src.color.g = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
167
165
  src.color.b = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
168
166
  src.color.a = (*psrc & src.fmt->Amask) | src.a255;
169
- if(src.color.a == 0){ psrc++; pdst++; continue; }
167
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
170
168
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
171
169
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
172
170
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
173
171
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
174
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
175
- ph += deg;
176
- if(ph < 0.0){ ph += d_pi; }
177
- if(ph >= d_pi){ ph -= d_pi; }
178
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
179
- if(dst.color.a == 0 || src.color.a == 255){
180
- *pdst = src.color.r << dst.fmt->Rshift |
181
- src.color.g << dst.fmt->Gshift |
182
- src.color.b << dst.fmt->Bshift |
183
- src.color.a;
184
- psrc++;
185
- pdst++;
186
- continue;
187
- }
188
- int a1 = src.color.a + 1;
189
- int a2 = 256 - src.color.a;
190
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
191
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
192
- ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
193
- 0xff;
172
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
173
+ ph += deg;
174
+ if(ph < 0.0){ ph += d_pi; }
175
+ if(ph >= d_pi){ ph -= d_pi; }
176
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
177
+ if(dst.color.a == 0 || src.color.a == 255){
178
+ *pdst = src.color.r << dst.fmt->Rshift |
179
+ src.color.g << dst.fmt->Gshift |
180
+ src.color.b << dst.fmt->Bshift |
181
+ src.color.a;
182
+ psrc++;
183
+ pdst++;
184
+ continue;
185
+ }
186
+ a1 = src.color.a + 1;
187
+ a2 = 256 - src.color.a;
188
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
189
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
190
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
191
+ 0xff;
194
192
  #endif
195
193
  psrc++;
196
- pdst++;
197
- }
198
- }
194
+ pdst++;
195
+ }
196
+ }
199
197
 
200
- SDL_UnlockSurface(src.surface);
201
- SDL_UnlockSurface(dst.surface);
198
+ SDL_UnlockSurface(src.surface);
199
+ SDL_UnlockSurface(dst.surface);
202
200
 
203
201
  return vdst;
204
202
  }
205
203
 
206
- /*
207
- 画像の彩度を変更する
208
- */
209
204
  static VALUE bitmap_miyako_saturation(VALUE self, VALUE vsrc, VALUE vdst, VALUE saturation)
210
205
  {
211
206
  MiyakoBitmap src, dst;
212
207
  MiyakoSize size;
213
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
208
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
209
+ Uint32 imax, imin;
214
210
 
215
- int x, y;
211
+ int x, y, a1, a2;
216
212
 
213
+ double delta, tmp_i;
217
214
  double sat = NUM2DBL(saturation);
218
215
  double ph = 0.0, ps = 0.0, pv = 0.0;
219
216
  double r = 0.0, g = 0.0, b = 0.0;
@@ -222,101 +219,100 @@ static VALUE bitmap_miyako_saturation(VALUE self, VALUE vsrc, VALUE vdst, VALUE
222
219
  _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
223
220
 
224
221
  if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
225
-
226
- SDL_LockSurface(src.surface);
227
- SDL_LockSurface(dst.surface);
228
-
229
- for(y = 0; y < size.h; y++)
230
- {
231
- Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
232
- Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
233
- for(x = 0; x < size.w; x++)
234
- {
222
+
223
+ SDL_LockSurface(src.surface);
224
+ SDL_LockSurface(dst.surface);
225
+
226
+ for(y = 0; y < size.h; y++)
227
+ {
228
+ Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
229
+ Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
230
+ for(x = 0; x < size.w; x++)
231
+ {
235
232
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
236
233
  src.color.r = (*psrc >> 16) & 0xff;
237
234
  src.color.g = (*psrc >> 8) & 0xff;
238
235
  src.color.b = (*psrc ) & 0xff;
239
236
  src.color.a = (*psrc >> 24) & 0xff | src.a255;
240
- if(src.color.a == 0){ psrc++; pdst++; continue; }
237
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
241
238
  dst.color.r = (*pdst >> 16) & 0xff;
242
239
  dst.color.g = (*pdst >> 8) & 0xff;
243
240
  dst.color.b = (*pdst ) & 0xff;
244
241
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
245
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
246
- ps += sat;
247
- if(ps < 0.0){ ps = 0.0; }
248
- if(ps > 1.0){ ps = 1.0; }
249
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
250
- if(dst.color.a == 0 || src.color.a == 255){
251
- *pdst = (src.color.r) << 16 |
252
- (src.color.g) << 8 |
253
- (src.color.b) |
254
- (src.color.a) << 24;
255
- psrc++;
256
- pdst++;
257
- continue;
258
- }
259
- int a1 = src.color.a + 1;
260
- int a2 = 256 - src.color.a;
261
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
262
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
263
- ((src.color.b * a1 + dst.color.b * a2) >> 8) |
264
- 0xff << 24;
265
- psrc++;
266
- pdst++;
242
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
243
+ ps += sat;
244
+ if(ps < 0.0){ ps = 0.0; }
245
+ if(ps > 1.0){ ps = 1.0; }
246
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
247
+ if(dst.color.a == 0 || src.color.a == 255){
248
+ *pdst = (src.color.r) << 16 |
249
+ (src.color.g) << 8 |
250
+ (src.color.b) |
251
+ (src.color.a) << 24;
252
+ psrc++;
253
+ pdst++;
254
+ continue;
255
+ }
256
+ a1 = src.color.a + 1;
257
+ a2 = 256 - src.color.a;
258
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
259
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
260
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) |
261
+ 0xff << 24;
262
+ psrc++;
263
+ pdst++;
267
264
  #else
268
265
  src.color.r = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
269
266
  src.color.g = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
270
267
  src.color.b = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
271
268
  src.color.a = (*psrc & src.fmt->Amask) | src.a255;
272
- if(src.color.a == 0){ psrc++; pdst++; continue; }
269
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
273
270
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
274
271
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
275
272
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
276
273
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
277
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
278
- ps += sat;
279
- if(ps < 0.0){ ps = 0.0; }
280
- if(ps > 1.0){ ps = 1.0; }
281
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
282
- if(dst.color.a == 0 || src.color.a == 255){
283
- *pdst = src.color.r << dst.fmt->Rshift |
284
- src.color.g << dst.fmt->Gshift |
285
- src.color.b << dst.fmt->Bshift |
286
- src.color.a;
287
- psrc++;
288
- pdst++;
289
- continue;
290
- }
291
- int a1 = src.color.a + 1;
292
- int a2 = 256 - src.color.a;
293
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
294
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
295
- ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
296
- 0xff;
297
- psrc++;
298
- pdst++;
274
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
275
+ ps += sat;
276
+ if(ps < 0.0){ ps = 0.0; }
277
+ if(ps > 1.0){ ps = 1.0; }
278
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
279
+ if(dst.color.a == 0 || src.color.a == 255){
280
+ *pdst = src.color.r << dst.fmt->Rshift |
281
+ src.color.g << dst.fmt->Gshift |
282
+ src.color.b << dst.fmt->Bshift |
283
+ src.color.a;
284
+ psrc++;
285
+ pdst++;
286
+ continue;
287
+ }
288
+ a1 = src.color.a + 1;
289
+ a2 = 256 - src.color.a;
290
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
291
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
292
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
293
+ 0xff;
294
+ psrc++;
295
+ pdst++;
299
296
  #endif
300
297
  }
301
- }
298
+ }
302
299
 
303
- SDL_UnlockSurface(src.surface);
304
- SDL_UnlockSurface(dst.surface);
300
+ SDL_UnlockSurface(src.surface);
301
+ SDL_UnlockSurface(dst.surface);
305
302
 
306
303
  return vdst;
307
304
  }
308
305
 
309
- /*
310
- 画像の明度を変更する
311
- */
312
306
  static VALUE bitmap_miyako_value(VALUE self, VALUE vsrc, VALUE vdst, VALUE value)
313
307
  {
314
308
  MiyakoBitmap src, dst;
315
309
  MiyakoSize size;
316
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
310
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
317
311
  double val = NUM2DBL(value);
318
-
319
- int x, y;
312
+ Uint32 imax, imin;
313
+
314
+ int x, y, a1, a2;
315
+ double delta, tmp_i;
320
316
  double ph = 0.0, ps = 0.0, pv = 0.0;
321
317
  double r = 0.0, g = 0.0, b = 0.0;
322
318
  double i = 0.0, f, m, n, k;
@@ -324,99 +320,98 @@ static VALUE bitmap_miyako_value(VALUE self, VALUE vsrc, VALUE vdst, VALUE value
324
320
  _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
325
321
 
326
322
  if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
327
-
323
+
328
324
  SDL_LockSurface(src.surface);
329
- SDL_LockSurface(dst.surface);
330
-
331
- for(y = 0; y < size.h; y++)
332
- {
333
- Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
334
- Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
335
- for(x = 0; x < size.w; x++)
336
- {
325
+ SDL_LockSurface(dst.surface);
326
+
327
+ for(y = 0; y < size.h; y++)
328
+ {
329
+ Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
330
+ Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
331
+ for(x = 0; x < size.w; x++)
332
+ {
337
333
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
338
334
  src.color.r = (*psrc >> 16) & 0xff;
339
335
  src.color.g = (*psrc >> 8) & 0xff;
340
336
  src.color.b = (*psrc ) & 0xff;
341
337
  src.color.a = (*psrc >> 24) & 0xff | src.a255;
342
- if(src.color.a == 0){ psrc++; pdst++; continue; }
338
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
343
339
  dst.color.r = (*pdst >> 16) & 0xff;
344
340
  dst.color.g = (*pdst >> 8) & 0xff;
345
341
  dst.color.b = (*pdst ) & 0xff;
346
342
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
347
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
348
- pv += val;
349
- if(pv < 0.0){ pv = 0.0; }
350
- if(pv > 1.0){ pv = 1.0; }
351
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
352
- if(dst.color.a == 0 || src.color.a == 255){
353
- *pdst = (src.color.r) << 16 |
354
- (src.color.g) << 8 |
355
- (src.color.b) |
356
- (src.color.a) << 24;
357
- psrc++;
358
- pdst++;
359
- continue;
360
- }
361
- int a1 = src.color.a + 1;
362
- int a2 = 256 - src.color.a;
363
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
364
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
365
- ((src.color.b * a1 + dst.color.b * a2) >> 8) |
366
- 0xff << 24;
343
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
344
+ pv += val;
345
+ if(pv < 0.0){ pv = 0.0; }
346
+ if(pv > 1.0){ pv = 1.0; }
347
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
348
+ if(dst.color.a == 0 || src.color.a == 255){
349
+ *pdst = (src.color.r) << 16 |
350
+ (src.color.g) << 8 |
351
+ (src.color.b) |
352
+ (src.color.a) << 24;
353
+ psrc++;
354
+ pdst++;
355
+ continue;
356
+ }
357
+ a1 = src.color.a + 1;
358
+ a2 = 256 - src.color.a;
359
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
360
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
361
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) |
362
+ 0xff << 24;
367
363
  #else
368
364
  src.color.r = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
369
365
  src.color.g = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
370
366
  src.color.b = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
371
367
  src.color.a = (*psrc & src.fmt->Amask) | src.a255;
372
- if(src.color.a == 0){ psrc++; pdst++; continue; }
368
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
373
369
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
374
370
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
375
371
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
376
372
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
377
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
378
- pv += val;
379
- if(pv < 0.0){ pv = 0.0; }
380
- if(pv > 1.0){ pv = 1.0; }
381
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
382
- if(dst.color.a == 0 || src.color.a == 255){
383
- *pdst = src.color.r << dst.fmt->Rshift |
384
- src.color.g << dst.fmt->Gshift |
385
- src.color.b << dst.fmt->Bshift |
386
- src.color.a;
387
- psrc++;
388
- pdst++;
389
- continue;
390
- }
391
- int a1 = src.color.a + 1;
392
- int a2 = 256 - src.color.a;
393
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
394
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
395
- ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
396
- 0xff;
373
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
374
+ pv += val;
375
+ if(pv < 0.0){ pv = 0.0; }
376
+ if(pv > 1.0){ pv = 1.0; }
377
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
378
+ if(dst.color.a == 0 || src.color.a == 255){
379
+ *pdst = src.color.r << dst.fmt->Rshift |
380
+ src.color.g << dst.fmt->Gshift |
381
+ src.color.b << dst.fmt->Bshift |
382
+ src.color.a;
383
+ psrc++;
384
+ pdst++;
385
+ continue;
386
+ }
387
+ a1 = src.color.a + 1;
388
+ a2 = 256 - src.color.a;
389
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
390
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
391
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
392
+ 0xff;
397
393
  #endif
398
394
  psrc++;
399
- pdst++;
400
- }
401
- }
395
+ pdst++;
396
+ }
397
+ }
402
398
 
403
- SDL_UnlockSurface(src.surface);
404
- SDL_UnlockSurface(dst.surface);
399
+ SDL_UnlockSurface(src.surface);
400
+ SDL_UnlockSurface(dst.surface);
405
401
 
406
- return vdst;
402
+ return vdst;
407
403
  }
408
404
 
409
- /*
410
- 画像の色相・彩度・明度を変更する
411
- */
412
405
  static VALUE bitmap_miyako_hsv(VALUE self, VALUE vsrc, VALUE vdst, VALUE degree, VALUE saturation, VALUE value)
413
406
  {
414
407
  MiyakoBitmap src, dst;
415
408
  MiyakoSize size;
416
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
417
-
418
- int x, y;
409
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
410
+ Uint32 imax, imin;
419
411
 
412
+ int x, y, a1, a2;
413
+
414
+ double delta, tmp_i;
420
415
  double deg = NUM2DBL(degree);
421
416
  double sat = NUM2DBL(saturation);
422
417
  double val = NUM2DBL(value);
@@ -430,304 +425,299 @@ static VALUE bitmap_miyako_hsv(VALUE self, VALUE vsrc, VALUE vdst, VALUE degree,
430
425
  _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
431
426
 
432
427
  if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
433
-
434
- SDL_LockSurface(src.surface);
435
- SDL_LockSurface(dst.surface);
436
-
437
- for(y = 0; y < size.h; y++)
438
- {
439
- Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
440
- Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
441
- for(x = 0; x < size.w; x++)
442
- {
428
+
429
+ SDL_LockSurface(src.surface);
430
+ SDL_LockSurface(dst.surface);
431
+
432
+ for(y = 0; y < size.h; y++)
433
+ {
434
+ Uint32 *psrc = src.ptr + (src.rect.y + y) * src.rect.w + src.rect.x;
435
+ Uint32 *pdst = dst.ptr + (dst.rect.y + src.y + y) * dst.rect.w + dst.rect.x + src.x;
436
+ for(x = 0; x < size.w; x++)
437
+ {
443
438
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
444
439
  src.color.r = (*psrc >> 16) & 0xff;
445
440
  src.color.g = (*psrc >> 8) & 0xff;
446
441
  src.color.b = (*psrc ) & 0xff;
447
442
  src.color.a = (*psrc >> 24) & 0xff | src.a255;
448
- if(src.color.a == 0){ psrc++; pdst++; continue; }
443
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
449
444
  dst.color.r = (*pdst >> 16) & 0xff;
450
445
  dst.color.g = (*pdst >> 8) & 0xff;
451
446
  dst.color.b = (*pdst ) & 0xff;
452
447
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
453
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
454
- ph += deg;
455
- if(ph < 0.0){ ph += d_pi; }
456
- if(ph >= d_pi){ ph -= d_pi; }
457
- ps += sat;
458
- if(ps < 0.0){ ps = 0.0; }
459
- if(ps > 1.0){ ps = 1.0; }
460
- pv += val;
461
- if(pv < 0.0){ pv = 0.0; }
462
- if(pv > 1.0){ pv = 1.0; }
463
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
464
- if(dst.color.a == 0 || src.color.a == 255){
465
- *pdst = (src.color.r) << 16 |
466
- (src.color.g) << 8 |
467
- (src.color.b) |
468
- (src.color.a) << 24;
469
- psrc++;
470
- pdst++;
471
- continue;
472
- }
473
- int a1 = src.color.a + 1;
474
- int a2 = 256 - src.color.a;
475
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
476
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
477
- ((src.color.b * a1 + dst.color.b * a2) >> 8) |
478
- 0xff << 24;
479
- psrc++;
480
- pdst++;
448
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
449
+ ph += deg;
450
+ if(ph < 0.0){ ph += d_pi; }
451
+ if(ph >= d_pi){ ph -= d_pi; }
452
+ ps += sat;
453
+ if(ps < 0.0){ ps = 0.0; }
454
+ if(ps > 1.0){ ps = 1.0; }
455
+ pv += val;
456
+ if(pv < 0.0){ pv = 0.0; }
457
+ if(pv > 1.0){ pv = 1.0; }
458
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
459
+ if(dst.color.a == 0 || src.color.a == 255){
460
+ *pdst = (src.color.r) << 16 |
461
+ (src.color.g) << 8 |
462
+ (src.color.b) |
463
+ (src.color.a) << 24;
464
+ psrc++;
465
+ pdst++;
466
+ continue;
467
+ }
468
+ a1 = src.color.a + 1;
469
+ a2 = 256 - src.color.a;
470
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
471
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << 8 |
472
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) |
473
+ 0xff << 24;
474
+ psrc++;
475
+ pdst++;
481
476
  #else
482
477
  src.color.r = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
483
478
  src.color.g = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
484
479
  src.color.b = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
485
480
  src.color.a = (*psrc & src.fmt->Amask) | src.a255;
486
- if(src.color.a == 0){ psrc++; pdst++; continue; }
481
+ if(src.color.a == 0){ psrc++; pdst++; continue; }
487
482
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
488
483
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
489
484
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
490
485
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
491
- MIYAKO_RGB2HSV(src.color, ph, ps, pv);
492
- ph += deg;
493
- if(ph < 0.0){ ph += d_pi; }
494
- if(ph >= d_pi){ ph -= d_pi; }
495
- ps += sat;
496
- if(ps < 0.0){ ps = 0.0; }
497
- if(ps > 1.0){ ps = 1.0; }
498
- pv += val;
499
- if(pv < 0.0){ pv = 0.0; }
500
- if(pv > 1.0){ pv = 1.0; }
501
- MIYAKO_HSV2RGB(ph, ps, pv, src.color);
502
- if(dst.color.a == 0 || src.color.a == 255){
503
- *pdst = src.color.r << dst.fmt->Rshift |
504
- src.color.g << dst.fmt->Gshift |
505
- src.color.b << dst.fmt->Bshift |
506
- src.color.a;
507
- psrc++;
508
- pdst++;
509
- continue;
510
- }
511
- int a1 = src.color.a + 1;
512
- int a2 = 256 - src.color.a;
513
- *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
514
- ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
515
- ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
516
- 0xff;
517
- psrc++;
518
- pdst++;
486
+ MIYAKO_RGB2HSV(src.color, ph, ps, pv);
487
+ ph += deg;
488
+ if(ph < 0.0){ ph += d_pi; }
489
+ if(ph >= d_pi){ ph -= d_pi; }
490
+ ps += sat;
491
+ if(ps < 0.0){ ps = 0.0; }
492
+ if(ps > 1.0){ ps = 1.0; }
493
+ pv += val;
494
+ if(pv < 0.0){ pv = 0.0; }
495
+ if(pv > 1.0){ pv = 1.0; }
496
+ MIYAKO_HSV2RGB(ph, ps, pv, src.color);
497
+ if(dst.color.a == 0 || src.color.a == 255){
498
+ *pdst = src.color.r << dst.fmt->Rshift |
499
+ src.color.g << dst.fmt->Gshift |
500
+ src.color.b << dst.fmt->Bshift |
501
+ src.color.a;
502
+ psrc++;
503
+ pdst++;
504
+ continue;
505
+ }
506
+ a1 = src.color.a + 1;
507
+ a2 = 256 - src.color.a;
508
+ *pdst = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
509
+ ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
510
+ ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
511
+ 0xff;
512
+ psrc++;
513
+ pdst++;
519
514
  #endif
520
515
  }
521
- }
516
+ }
522
517
 
523
- SDL_UnlockSurface(src.surface);
524
- SDL_UnlockSurface(dst.surface);
518
+ SDL_UnlockSurface(src.surface);
519
+ SDL_UnlockSurface(dst.surface);
525
520
 
526
- return vdst;
521
+ return vdst;
527
522
  }
528
523
 
529
- /*
530
- 画像の色相を変更する
531
- */
532
524
  static VALUE bitmap_miyako_hue_self(VALUE self, VALUE vdst, VALUE degree)
533
525
  {
534
526
  MiyakoBitmap dst;
535
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
527
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
528
+ Uint32 imax, imin;
536
529
 
537
- _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
538
-
539
- int x, y;
530
+ int x, y;
531
+ double delta, tmp_i;
540
532
  double deg = NUM2DBL(degree);
541
533
  double d_pi = 360.0;
542
534
  double ph = 0.0, ps = 0.0, pv = 0.0;
543
535
  double r = 0.0, g = 0.0, b = 0.0;
544
536
  double i = 0.0, f, m, n, k;
545
537
 
538
+ _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
539
+
546
540
  if(deg <= -360.0 || deg >= 360.0){ return Qnil; }
547
-
548
- SDL_LockSurface(dst.surface);
549
-
550
- for(y = 0; y < dst.rect.h; y++)
551
- {
552
- Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
553
- for(x = 0; x < dst.rect.w; x++)
554
- {
541
+
542
+ SDL_LockSurface(dst.surface);
543
+
544
+ for(y = 0; y < dst.rect.h; y++)
545
+ {
546
+ Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
547
+ for(x = 0; x < dst.rect.w; x++)
548
+ {
555
549
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
556
550
  dst.color.r = (*pdst >> 16) & 0xff;
557
551
  dst.color.g = (*pdst >> 8) & 0xff;
558
552
  dst.color.b = (*pdst ) & 0xff;
559
553
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
560
- if(dst.color.a == 0){ pdst++; continue; }
561
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
562
- ph += deg;
563
- if(ph < 0.0){ ph += d_pi; }
564
- if(ph >= d_pi){ ph -= d_pi; }
565
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
566
- *pdst = (dst.color.r) << 16 |
567
- (dst.color.g) << 8 |
568
- (dst.color.b) |
569
- (dst.color.a) << 24;
554
+ if(dst.color.a == 0){ pdst++; continue; }
555
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
556
+ ph += deg;
557
+ if(ph < 0.0){ ph += d_pi; }
558
+ if(ph >= d_pi){ ph -= d_pi; }
559
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
560
+ *pdst = (dst.color.r) << 16 |
561
+ (dst.color.g) << 8 |
562
+ (dst.color.b) |
563
+ (dst.color.a) << 24;
570
564
  #else
571
565
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
572
566
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
573
567
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
574
568
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
575
- if(dst.color.a == 0){ pdst++; continue; }
576
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
577
- ph += deg;
578
- if(ph < 0.0){ ph += d_pi; }
579
- if(ph >= d_pi){ ph -= d_pi; }
580
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
581
- *pdst = dst.color.r << dst.fmt->Rshift |
582
- dst.color.g << dst.fmt->Gshift |
583
- dst.color.b << dst.fmt->Bshift |
584
- dst.color.a;
569
+ if(dst.color.a == 0){ pdst++; continue; }
570
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
571
+ ph += deg;
572
+ if(ph < 0.0){ ph += d_pi; }
573
+ if(ph >= d_pi){ ph -= d_pi; }
574
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
575
+ *pdst = dst.color.r << dst.fmt->Rshift |
576
+ dst.color.g << dst.fmt->Gshift |
577
+ dst.color.b << dst.fmt->Bshift |
578
+ dst.color.a;
585
579
  #endif
586
580
  pdst++;
587
- }
588
- }
581
+ }
582
+ }
589
583
 
590
- SDL_UnlockSurface(dst.surface);
584
+ SDL_UnlockSurface(dst.surface);
591
585
 
592
586
  return vdst;
593
587
  }
594
588
 
595
- /*
596
- 画像の彩度を変更する
597
- */
598
589
  static VALUE bitmap_miyako_saturation_self(VALUE self, VALUE vdst, VALUE saturation)
599
590
  {
600
591
  MiyakoBitmap dst;
601
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
602
-
603
- _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
592
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
593
+ Uint32 imax, imin;
604
594
 
595
+ int x, y;
596
+ double delta, tmp_i;
605
597
  double sat = NUM2DBL(saturation);
606
598
  double ph = 0.0, ps = 0.0, pv = 0.0;
607
599
  double r = 0.0, g = 0.0, b = 0.0;
608
600
  double i = 0.0, f, m, n, k;
609
601
 
610
- SDL_LockSurface(dst.surface);
602
+ _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
603
+
604
+ SDL_LockSurface(dst.surface);
611
605
 
612
- int x, y;
613
- for(y = 0; y < dst.rect.h; y++)
614
- {
615
- Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
616
- for(x = 0; x < dst.rect.w; x++)
617
- {
606
+ for(y = 0; y < dst.rect.h; y++)
607
+ {
608
+ Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
609
+ for(x = 0; x < dst.rect.w; x++)
610
+ {
618
611
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
619
612
  dst.color.r = (*pdst >> 16) & 0xff;
620
613
  dst.color.g = (*pdst >> 8) & 0xff;
621
614
  dst.color.b = (*pdst ) & 0xff;
622
615
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
623
- if(dst.color.a == 0){ pdst++; continue; }
624
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
625
- ps += sat;
626
- if(ps < 0.0){ ps = 0.0; }
627
- if(ps > 1.0){ ps = 1.0; }
628
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
616
+ if(dst.color.a == 0){ pdst++; continue; }
617
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
618
+ ps += sat;
619
+ if(ps < 0.0){ ps = 0.0; }
620
+ if(ps > 1.0){ ps = 1.0; }
621
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
629
622
  *pdst = (dst.color.r) << 16 |
630
623
  (dst.color.g) << 8 |
631
- (dst.color.b) |
632
- (dst.color.a) << 24;
624
+ (dst.color.b) |
625
+ (dst.color.a) << 24;
633
626
  #else
634
627
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
635
628
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
636
629
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
637
630
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
638
- if(dst.color.a == 0){ pdst++; continue; }
639
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
640
- ps += sat;
641
- if(ps < 0.0){ ps = 0.0; }
642
- if(ps > 1.0){ ps = 1.0; }
643
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
644
- *pdst = dst.color.r << dst.fmt->Rshift |
645
- dst.color.g << dst.fmt->Gshift |
646
- dst.color.b << dst.fmt->Bshift |
647
- dst.color.a;
631
+ if(dst.color.a == 0){ pdst++; continue; }
632
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
633
+ ps += sat;
634
+ if(ps < 0.0){ ps = 0.0; }
635
+ if(ps > 1.0){ ps = 1.0; }
636
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
637
+ *pdst = dst.color.r << dst.fmt->Rshift |
638
+ dst.color.g << dst.fmt->Gshift |
639
+ dst.color.b << dst.fmt->Bshift |
640
+ dst.color.a;
648
641
  #endif
649
642
  pdst++;
650
- }
651
- }
643
+ }
644
+ }
652
645
 
653
- SDL_UnlockSurface(dst.surface);
646
+ SDL_UnlockSurface(dst.surface);
654
647
 
655
648
  return vdst;
656
649
  }
657
650
 
658
- /*
659
- 画像の明度を変更する
660
- */
661
651
  static VALUE bitmap_miyako_value_self(VALUE self, VALUE vdst, VALUE value)
662
652
  {
663
653
  MiyakoBitmap dst;
664
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
665
-
666
- _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
654
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
655
+ Uint32 imax, imin;
667
656
 
657
+ int x, y;
658
+ double delta, tmp_i;
668
659
  double val = NUM2DBL(value);
669
660
  double ph = 0.0, ps = 0.0, pv = 0.0;
670
661
  double r = 0.0, g = 0.0, b = 0.0;
671
662
  double i = 0.0, f, m, n, k;
672
663
 
673
- SDL_LockSurface(dst.surface);
664
+ _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
665
+
666
+ SDL_LockSurface(dst.surface);
674
667
 
675
- int x, y;
676
- for(y = 0; y < dst.rect.h; y++)
677
- {
678
- Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
679
- for(x = 0; x < dst.rect.w; x++)
680
- {
668
+ for(y = 0; y < dst.rect.h; y++)
669
+ {
670
+ Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
671
+ for(x = 0; x < dst.rect.w; x++)
672
+ {
681
673
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
682
674
  dst.color.r = (*pdst >> 16) & 0xff;
683
675
  dst.color.g = (*pdst >> 8) & 0xff;
684
676
  dst.color.b = (*pdst ) & 0xff;
685
677
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
686
- if(dst.color.a == 0){ pdst++; continue; }
687
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
688
- pv += val;
689
- if(pv < 0.0){ pv = 0.0; }
690
- if(pv > 1.0){ pv = 1.0; }
691
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
678
+ if(dst.color.a == 0){ pdst++; continue; }
679
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
680
+ pv += val;
681
+ if(pv < 0.0){ pv = 0.0; }
682
+ if(pv > 1.0){ pv = 1.0; }
683
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
692
684
  *pdst = (dst.color.r) << 16 |
693
685
  (dst.color.g) << 8 |
694
- (dst.color.b) |
695
- (dst.color.a) << 24;
686
+ (dst.color.b) |
687
+ (dst.color.a) << 24;
696
688
  #else
697
689
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
698
690
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
699
691
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
700
692
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
701
- if(dst.color.a == 0){ pdst++; continue; }
702
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
703
- pv += val;
704
- if(pv < 0.0){ pv = 0.0; }
705
- if(pv > 1.0){ pv = 1.0; }
706
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
707
- *pdst = dst.color.r << dst.fmt->Rshift |
708
- dst.color.g << dst.fmt->Gshift |
709
- dst.color.b << dst.fmt->Bshift |
710
- dst.color.a;
693
+ if(dst.color.a == 0){ pdst++; continue; }
694
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
695
+ pv += val;
696
+ if(pv < 0.0){ pv = 0.0; }
697
+ if(pv > 1.0){ pv = 1.0; }
698
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
699
+ *pdst = dst.color.r << dst.fmt->Rshift |
700
+ dst.color.g << dst.fmt->Gshift |
701
+ dst.color.b << dst.fmt->Bshift |
702
+ dst.color.a;
711
703
  #endif
712
704
  pdst++;
713
- }
714
- }
705
+ }
706
+ }
715
707
 
716
- SDL_UnlockSurface(dst.surface);
708
+ SDL_UnlockSurface(dst.surface);
717
709
 
718
710
  return vdst;
719
711
  }
720
712
 
721
- /*
722
- 画像の色相・彩度・明度を変更する
723
- */
724
713
  static VALUE bitmap_miyako_hsv_self(VALUE self, VALUE vdst, VALUE degree, VALUE saturation, VALUE value)
725
714
  {
726
715
  MiyakoBitmap dst;
727
- SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
728
-
729
- _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
716
+ SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
717
+ Uint32 imax, imin;
730
718
 
719
+ int x, y;
720
+ double delta, tmp_i;
731
721
  double deg = NUM2DBL(degree);
732
722
  double sat = NUM2DBL(saturation);
733
723
  double val = NUM2DBL(value);
@@ -736,70 +726,73 @@ static VALUE bitmap_miyako_hsv_self(VALUE self, VALUE vdst, VALUE degree, VALUE
736
726
  double r = 0.0, g = 0.0, b = 0.0;
737
727
  double i = 0.0, f, m, n, k;
738
728
 
729
+ _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
730
+
739
731
  if(deg <= -360.0 || deg >= 360.0){ return Qnil; }
740
732
 
741
- SDL_LockSurface(dst.surface);
733
+ SDL_LockSurface(dst.surface);
742
734
 
743
- int x, y;
744
- for(y = 0; y < dst.rect.h; y++)
745
- {
746
- Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
747
- for(x = 0; x < dst.rect.w; x++)
748
- {
735
+ for(y = 0; y < dst.rect.h; y++)
736
+ {
737
+ Uint32 *pdst = dst.ptr + (dst.rect.y + y) * dst.rect.w + dst.rect.x;
738
+ for(x = 0; x < dst.rect.w; x++)
739
+ {
749
740
  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
750
741
  dst.color.r = (*pdst >> 16) & 0xff;
751
742
  dst.color.g = (*pdst >> 8) & 0xff;
752
743
  dst.color.b = (*pdst ) & 0xff;
753
744
  dst.color.a = (*pdst >> 24) & 0xff | dst.a255;
754
- if(dst.color.a == 0){ pdst++; continue; }
755
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
756
- ph += deg;
757
- if(ph < 0.0){ ph += d_pi; }
758
- if(ph >= d_pi){ ph -= d_pi; }
759
- ps += sat;
760
- if(ps < 0.0){ ps = 0.0; }
761
- if(ps > 1.0){ ps = 1.0; }
762
- pv += val;
763
- if(pv < 0.0){ pv = 0.0; }
764
- if(pv > 1.0){ pv = 1.0; }
765
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
766
- *pdst = (dst.color.r) << 16 |
767
- (dst.color.g) << 8 |
768
- (dst.color.b) |
769
- (dst.color.a) << 24;
745
+ if(dst.color.a == 0){ pdst++; continue; }
746
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
747
+ ph += deg;
748
+ if(ph < 0.0){ ph += d_pi; }
749
+ if(ph >= d_pi){ ph -= d_pi; }
750
+ ps += sat;
751
+ if(ps < 0.0){ ps = 0.0; }
752
+ if(ps > 1.0){ ps = 1.0; }
753
+ pv += val;
754
+ if(pv < 0.0){ pv = 0.0; }
755
+ if(pv > 1.0){ pv = 1.0; }
756
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
757
+ *pdst = (dst.color.r) << 16 |
758
+ (dst.color.g) << 8 |
759
+ (dst.color.b) |
760
+ (dst.color.a) << 24;
770
761
  #else
771
762
  dst.color.r = (*pdst & dst.fmt->Rmask) >> dst.fmt->Rshift);
772
763
  dst.color.g = (*pdst & dst.fmt->Gmask) >> dst.fmt->Gshift);
773
764
  dst.color.b = (*pdst & dst.fmt->Bmask) >> dst.fmt->Bshift);
774
765
  dst.color.a = (*pdst & dst.fmt->Amask) | dst.a255;
775
- if(dst.color.a == 0){ pdst++; continue; }
776
- MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
777
- ph += deg;
778
- if(ph < 0.0){ ph += d_pi; }
779
- if(ph >= d_pi){ ph -= d_pi; }
780
- ps += sat;
781
- if(ps < 0.0){ ps = 0.0; }
782
- if(ps > 1.0){ ps = 1.0; }
783
- pv += val;
784
- if(pv < 0.0){ pv = 0.0; }
785
- if(pv > 1.0){ pv = 1.0; }
786
- MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
787
- *pdst = dst.color.r << dst.fmt->Rshift |
788
- dst.color.g << dst.fmt->Gshift |
789
- dst.color.b << dst.fmt->Bshift |
790
- dst.color.a;
766
+ if(dst.color.a == 0){ pdst++; continue; }
767
+ MIYAKO_RGB2HSV(dst.color, ph, ps, pv);
768
+ ph += deg;
769
+ if(ph < 0.0){ ph += d_pi; }
770
+ if(ph >= d_pi){ ph -= d_pi; }
771
+ ps += sat;
772
+ if(ps < 0.0){ ps = 0.0; }
773
+ if(ps > 1.0){ ps = 1.0; }
774
+ pv += val;
775
+ if(pv < 0.0){ pv = 0.0; }
776
+ if(pv > 1.0){ pv = 1.0; }
777
+ MIYAKO_HSV2RGB(ph, ps, pv, dst.color);
778
+ *pdst = dst.color.r << dst.fmt->Rshift |
779
+ dst.color.g << dst.fmt->Gshift |
780
+ dst.color.b << dst.fmt->Bshift |
781
+ dst.color.a;
791
782
  #endif
792
783
  pdst++;
793
- }
794
- }
784
+ }
785
+ }
795
786
 
796
- SDL_UnlockSurface(dst.surface);
787
+ SDL_UnlockSurface(dst.surface);
797
788
 
798
789
  return vdst;
799
790
  }
800
791
 
801
792
  void Init_miyako_hsv()
802
793
  {
794
+ int i;
795
+
803
796
  mSDL = rb_define_module("SDL");
804
797
  mMiyako = rb_define_module("Miyako");
805
798
  mScreen = rb_define_module_under(mMiyako, "Screen");
@@ -824,7 +817,6 @@ void Init_miyako_hsv()
824
817
  rb_define_singleton_method(cBitmap, "saturation!", bitmap_miyako_saturation_self, 2);
825
818
  rb_define_singleton_method(cBitmap, "value!", bitmap_miyako_value_self, 2);
826
819
  rb_define_singleton_method(cBitmap, "hsv!", bitmap_miyako_hsv_self, 4);
827
-
828
- int i;
820
+
829
821
  for(i=0; i<256; i++){ div255[i] = (double)i / 255.0; }
830
822
  }