Mercurial > otakunoraifu
annotate window/render.cc @ 66:d112357a0ec1
Fix a bug with savegames introduced with changeset c7bcc0ec2267.
Warning: savegames created since c7bcc0ec2267 are probably corrupted,
you may have to start the game over.
If you chose not to do so, you should replace all occurrences of 'TextWindow' by 'TextImplWindow',
and 'Text Window' by 'TextImpl Window' in your save files.
| author | Thibaut Girka <thib@sitedethib.com> |
|---|---|
| date | Sat, 11 Dec 2010 18:36:20 +0100 |
| parents | 4416cfac86ae |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * Copyright (c) 2004-2006 Kazunori "jagarl" Ueno | |
| 3 * All rights reserved. | |
| 4 * | |
| 5 * Redistribution and use in source and binary forms, with or without | |
| 6 * modification, are permitted provided that the following conditions | |
| 7 * are met: | |
| 8 * 1. Redistributions of source code must retain the above copyright | |
| 9 * notice, this list of conditions and the following disclaimer. | |
| 10 * 2. Redistributions in binary form must reproduce the above copyright | |
| 11 * notice, this list of conditions and the following disclaimer in the | |
| 12 * documentation and/or other materials provided with the distribution. | |
| 13 * 3. The name of the author may not be used to endorse or promote products | |
| 14 * derived from this software without specific prior written permission. | |
| 15 * | |
| 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR | |
| 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |
| 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |
| 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | |
| 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
| 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
| 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 26 */ | |
| 27 | |
| 52 | 28 #include "font/font.h" |
| 29 #include "font/text.h" | |
|
56
c7bcc0ec2267
* replaced Grp and Text classes by the TextImpl and GrpImpl ones
thib
parents:
52
diff
changeset
|
30 #include "SDL.h" |
|
c7bcc0ec2267
* replaced Grp and Text classes by the TextImpl and GrpImpl ones
thib
parents:
52
diff
changeset
|
31 #include "render.h" |
| 52 | 32 #include "rect.h" |
| 33 #include "surface.h" | |
| 34 #include <stdio.h> | |
| 0 | 35 |
| 36 #ifndef ALPHA_MAX | |
| 37 #define ALPHA_MAX 255 | |
| 38 #endif | |
| 39 | |
| 40 Rect::Rect(const TextGlyph& letter) { | |
| 41 lx = letter.x + letter.glyph->bitmap_left; | |
| 42 rx = lx + letter.glyph->bitmap.width; | |
| 43 | |
| 44 ty = letter.y - letter.glyph->bitmap_top; | |
| 45 by = ty + letter.glyph->bitmap.rows; | |
| 46 } | |
| 47 | |
| 48 Rect::Rect(const class Surface& so) { | |
| 49 SDL_Surface* s = (SDL_Surface*)(&so); | |
| 50 lx = 0; ty = 0; | |
| 51 rx = s->w; by = s->h; | |
| 52 } | |
| 52 | 53 |
| 0 | 54 inline Rect _Rect(const SDL_Rect& r) { |
| 55 return Rect(r.x, r.y, r.x+r.w, r.y+r.h); | |
| 52 | 56 } |
| 57 | |
| 0 | 58 inline SDL_Rect SDLed(const Rect& rect) { |
| 59 SDL_Rect r; | |
| 60 r.x = rect.lx; | |
| 61 r.y = rect.ty; | |
| 62 r.w = rect.rx-rect.lx; | |
| 63 r.h = rect.by-rect.ty; | |
| 64 return r; | |
| 65 } | |
| 66 | |
| 67 Rect DSurfaceRenderText(TextGlyphStream::iterator start, TextGlyphStream::iterator end, const Rect& srcrect, | |
| 68 Surface* dst_o, const Rect& dstrect) { | |
| 69 | |
| 70 SDL_Surface* dst = (SDL_Surface*)dst_o; | |
| 71 Rect confine_to(srcrect); | |
| 72 Rect dst_clip(_Rect(dst->clip_rect)); | |
| 73 Rect drawn_rect(0,0,0,0); | |
| 74 | |
| 75 int dif_x = dstrect.lx - srcrect.lx; | |
| 76 int dif_y = dstrect.ty - srcrect.ty; | |
| 77 | |
| 78 dst_clip.rmove(-dif_x, -dif_y); | |
| 79 confine_to.intersect(dst_clip); | |
| 80 | |
| 81 TextGlyphStream::iterator it; | |
| 82 SDL_PixelFormat& fmt = *dst->format; | |
| 83 int ashift = fmt.Ashift - fmt.Aloss; int amask = fmt.Amask; | |
| 84 int dbpl = dst->pitch; | |
| 85 int dbpp = fmt.BytesPerPixel; | |
| 86 | |
| 87 SDL_LockSurface(dst); | |
| 88 for (it=start; it!=end; it++) { | |
| 89 Rect letter_r(*it); | |
| 90 letter_r.intersect(confine_to); | |
| 91 if (letter_r.empty()) continue; | |
| 92 drawn_rect.join(letter_r); | |
| 93 | |
| 94 int w = letter_r.width(); | |
| 95 int h = letter_r.height(); | |
| 96 int sbpl = it->glyph->bitmap.width; | |
| 97 | |
| 98 unsigned char* smem = it->glyph->bitmap.buffer + | |
| 99 (letter_r.ty - (it->y-it->glyph->bitmap_top)) * sbpl + | |
| 100 (letter_r.lx - (it->x+it->glyph->bitmap_left)); | |
| 101 char* dmem = (char*)dst->pixels + | |
| 102 (letter_r.ty + dif_y) * dbpl + | |
| 103 (letter_r.lx + dif_x) * dbpp; | |
| 104 Uint32 pixel = ((int(it->r)<<fmt.Rshift)&fmt.Rmask) |((int(it->g)<<fmt.Gshift)&fmt.Gmask) |((int(it->b)<<fmt.Bshift)&fmt.Bmask); | |
| 105 int i,j; | |
| 106 if (!it->is_rev) { | |
| 107 if (dbpp == 4) { | |
| 108 for (i=0; i<h; i++) { | |
| 109 for (j=0; j<w; j++) { | |
| 110 int alpha = smem[j]; | |
| 111 ((Uint32*)dmem)[j] = pixel | ((alpha << ashift)&amask); | |
| 112 } | |
| 113 smem += sbpl; dmem += dbpl; | |
| 114 } | |
| 115 } else if (dbpp == 2) { | |
| 116 for (i=0; i<h; i++) { | |
| 117 for (j=0; j<w; j++) { | |
| 118 int alpha = smem[j]; | |
| 119 ((Uint16*)dmem)[j] = pixel | ((alpha << ashift)&amask); | |
| 120 } | |
| 121 smem += sbpl; dmem += dbpl; | |
| 122 } | |
| 123 } else abort(); | |
| 124 } else { /* reversed */ | |
| 125 if (dbpp == 4) { | |
| 126 for (i=0; i<h; i++) { | |
| 127 for (j=0; j<w; j++) { | |
| 128 int alpha = 255 - smem[j]; | |
| 129 ((Uint32*)dmem)[j] = pixel | ((alpha << ashift)&amask); | |
| 130 } | |
| 131 smem += sbpl; dmem += dbpl; | |
| 132 } | |
| 133 } else if (dbpp == 2) { | |
| 134 for (i=0; i<h; i++) { | |
| 135 for (j=0; j<w; j++) { | |
| 136 int alpha = 255 - smem[j]; | |
| 137 ((Uint16*)dmem)[j] = pixel | ((alpha << ashift)&amask); | |
| 138 } | |
| 139 smem += sbpl; dmem += dbpl; | |
| 140 } | |
| 141 } else abort(); | |
| 142 } | |
| 143 } | |
| 144 SDL_UnlockSurface(dst); | |
| 145 drawn_rect.rmove(dif_x, dif_y); | |
| 146 return drawn_rect; | |
| 147 } | |
| 52 | 148 |
| 0 | 149 void DSurfaceFill(Surface* src_o, const Rect& rect, int r, int g, int b, int a) { |
| 150 SDL_Rect sr = SDLed(rect); | |
| 151 SDL_Surface* src = (SDL_Surface*)src_o; | |
| 152 SDL_FillRect( src, &sr, SDL_MapRGBA(src->format, r, g, b, a)); | |
| 153 } | |
| 154 | |
| 155 static void clip_rect(Rect& srcrect, Rect& dstrect, SDL_Surface* dstsurf) { | |
| 156 Rect confine_to(srcrect); | |
| 157 Rect dst_clip(_Rect(dstsurf->clip_rect)); | |
| 158 | |
| 159 int dif_x = dstrect.lx - srcrect.lx; | |
| 160 int dif_y = dstrect.ty - srcrect.ty; | |
| 161 | |
| 162 dst_clip.rmove(-dif_x, -dif_y); | |
| 163 confine_to.intersect(dst_clip); | |
| 164 | |
| 165 srcrect = confine_to; | |
| 166 dstrect = confine_to; | |
| 167 dstrect.rmove(dif_x, dif_y); | |
| 168 } | |
| 169 | |
| 170 void DSurfaceMove(Surface* src_o, const Rect& srcrect_o, Surface* dst_o, const Rect& dstrect_o) { | |
| 171 | |
| 172 SDL_Surface* dst = (SDL_Surface*)dst_o; | |
| 173 SDL_Surface* src = (SDL_Surface*)src_o; | |
| 174 | |
|
65
4416cfac86ae
Convert EUC-JP files to UTF8
Thibaut Girka <thib@sitedethib.com>
parents:
60
diff
changeset
|
175 if (dst->format->BytesPerPixel != src->format->BytesPerPixel) return; // RGB変換はできない |
| 0 | 176 |
| 177 Rect srcrect(srcrect_o), dstrect(dstrect_o); | |
| 178 clip_rect(srcrect, dstrect, dst); | |
| 179 | |
| 180 SDL_LockSurface(dst); SDL_LockSurface(src); | |
| 181 int sbpl = src->pitch; | |
| 182 int dbpl = dst->pitch; | |
| 183 int bpp = dst->format->BytesPerPixel; | |
| 184 int width = bpp * srcrect.width(); | |
| 185 int height = srcrect.height(); | |
| 186 char* smem = src_o->mem(srcrect); | |
| 187 char* dmem = dst_o->mem(dstrect); | |
| 188 char* smem_end = src_o->mem_end(srcrect); | |
| 189 char* dmem_end = dst_o->mem_end(dstrect); | |
| 190 | |
|
65
4416cfac86ae
Convert EUC-JP files to UTF8
Thibaut Girka <thib@sitedethib.com>
parents:
60
diff
changeset
|
191 // メモリに重なりがあり、src が上位側の場合、コピー方向を逆転する |
| 0 | 192 if (smem < dmem && dmem < smem_end) { |
| 193 int i,j; | |
| 194 for (i=0; i<height; i++) { | |
| 195 char* s = smem_end; char* d = dmem_end; | |
| 196 for (j=0; j<width; j++) | |
| 197 *--d = *--s; | |
| 198 dmem_end -= dbpl; smem_end -= sbpl; | |
| 199 } | |
| 200 } else { | |
| 201 int i; | |
| 202 for (i=0; i<height; i++) { | |
| 203 memcpy(dmem, smem, width); | |
| 204 dmem += dbpl; smem += sbpl; | |
| 205 } | |
| 206 } | |
| 207 SDL_UnlockSurface(dst); | |
| 208 SDL_UnlockSurface(src); | |
| 209 } | |
| 210 | |
| 211 void DSurfaceFillA(Surface* dsto, const Rect& rect, int r, int g, int b, int a) { | |
| 212 SDL_Surface* dst = (SDL_Surface*)dsto; | |
| 213 SDL_LockSurface( dst); | |
| 214 int dbpl = dst->pitch; | |
| 215 int bpp = dst->format->BytesPerPixel; | |
| 216 int width = rect.width(); | |
| 217 int height = rect.height(); | |
| 218 int amask = dst->format->Amask; | |
| 219 int ashift = dst->format->Ashift - dst->format->Aloss; | |
| 220 | |
| 221 char* dmem = (char*)(dst->pixels) + rect.ty*dbpl + rect.lx*bpp; | |
| 222 unsigned int pixel = SDL_MapRGBA(dst->format, r, g, b, 0); | |
| 223 unsigned int pixela = SDL_MapRGBA(dst->format, r, g, b, a); | |
|
65
4416cfac86ae
Convert EUC-JP files to UTF8
Thibaut Girka <thib@sitedethib.com>
parents:
60
diff
changeset
|
224 a += a>>7; /* 0-256 にする */ |
| 52 | 225 int i, j; |
| 0 | 226 for (i=0; i<height; i++) { |
| 227 char* d = dmem; | |
| 228 if (bpp == 4) { | |
| 229 for (j=0; j<width; j++) { | |
| 230 int alpha = (*(Uint32*)d)>>ashift; | |
| 231 if (alpha == 0) (*(Uint32*)d) = pixel; | |
| 232 else if (alpha == 255) *((Uint32*)d) = pixela; | |
| 233 else { *((Uint32*)d) = pixel | ((((alpha*a)>>8)<<ashift)&amask); } | |
| 234 d += bpp; | |
| 235 } | |
| 236 } else if (bpp == 2) { | |
| 237 for (j=0; j<width; j++) { | |
| 238 int alpha = (*(Uint16*)d)>>ashift; | |
| 239 if (alpha == 0) *((Uint16*)d) = pixel; | |
| 240 else if (alpha == 255) *((Uint16*)d) = pixela; | |
| 241 else { *((Uint16*)d) = pixel | ((((alpha*a)>>8)<<ashift)&amask); } | |
| 242 d += bpp; | |
| 243 } | |
| 244 } | |
| 245 dmem += dbpl; | |
| 246 } | |
| 247 SDL_UnlockSurface( dst); | |
| 248 } | |
| 249 | |
| 250 #define ASHIFT 24 | |
| 251 #define CMASK1 0xff00ff | |
| 252 #define CMASK2 0x00ff00 | |
| 253 | |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
254 inline void blit_pixel(Uint32* dest, Uint32* src, const unsigned char* alpha, bool use_srcalpha) { |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
255 Uint32 dest_value = *dest; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
256 Uint32 src_value = *src; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
257 Uint32 as = src_value >> ASHIFT; |
| 0 | 258 if (as == 255 || (!use_srcalpha) ) { |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
259 as = *alpha; |
| 0 | 260 } else { |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
261 as += (as >> 7); /* 0-0xff -> 0-0x100 */ |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
262 as *= *alpha; |
| 0 | 263 as >>= 8; |
| 264 } | |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
265 as += as >> 7; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
266 // Isolate Red and Blue components |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
267 Uint32 src_c1 = src_value & CMASK1; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
268 Uint32 dest_c1 = dest_value & CMASK1; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
269 // Blend Red and Blue components |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
270 dest_c1 = (dest_c1 + (((src_c1-dest_c1) * as) >> 8)) & CMASK1; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
271 // Isolate Green component |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
272 src_value &= CMASK2; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
273 dest_value &= CMASK2; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
274 // Blend Green component |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
275 dest_value = (dest_value + (((src_value-dest_value) * as) >> 8)) & CMASK2; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
276 // Put it alltogether |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
277 *dest = dest_c1 | dest_value | 0xff000000; |
| 0 | 278 } |
| 52 | 279 |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
280 static void blit_line(Uint32* dest, Uint32* src, const unsigned char* alpha,int ax0, int ax1, int awidth, int aj0, int aj1, bool use_srcalpha) { |
| 0 | 281 int j; |
| 282 int ax = ax0; | |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
283 const unsigned char* a = alpha + ax0; |
|
65
4416cfac86ae
Convert EUC-JP files to UTF8
Thibaut Girka <thib@sitedethib.com>
parents:
60
diff
changeset
|
284 if (awidth == 1) { // わりとよくあるので最適化 |
| 0 | 285 for (j=aj0; j < aj1; j++) { |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
286 blit_pixel(dest++, src++, alpha, use_srcalpha); |
| 0 | 287 } |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
288 } |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
289 else |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
290 { |
| 0 | 291 for (j=aj0; j < aj1; j++) { |
| 292 for (; ax<awidth; ax++) | |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
293 blit_pixel(dest++, src++, a++, use_srcalpha); |
| 0 | 294 ax = 0; |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
295 a = alpha; |
| 0 | 296 } |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
297 for (; ax < ax1; ax++) |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
298 blit_pixel(dest++, src++, a++, use_srcalpha); |
| 0 | 299 } |
| 300 } | |
| 301 | |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
302 void DSurfaceBlitAlpha(Surface* src_o, const Rect& srcrect_o, Surface* dst_o, const Rect& dstrect_o, const unsigned char* alpha, const Rect& alpharect) |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
303 { |
| 0 | 304 SDL_Surface* dst = (SDL_Surface*)dst_o; |
| 305 SDL_Surface* src = (SDL_Surface*)src_o; | |
| 306 SDL_PixelFormat& fmt = *dst->format; | |
| 307 | |
| 308 Rect srcrect(srcrect_o), dstrect(dstrect_o); | |
| 309 clip_rect(srcrect, dstrect, dst); | |
| 310 | |
| 311 int awidth = alpharect.width(); | |
| 312 int aheight = alpharect.height(); | |
| 313 if (awidth == 0 || aheight == 0) return; | |
| 314 int ax0 = srcrect.lx % awidth; | |
| 315 int ay0 = srcrect.ty % aheight; | |
| 316 int aj0 = srcrect.lx / awidth; | |
| 317 int ai0 = srcrect.ty / aheight; | |
| 318 int ax1 = srcrect.rx % awidth; | |
| 319 int ay1 = srcrect.by % aheight; | |
| 320 int aj1 = srcrect.rx / awidth; | |
| 321 int ai1 = srcrect.by / aheight; | |
| 322 | |
| 323 SDL_LockSurface(dst); | |
| 324 SDL_LockSurface(src); | |
| 325 int dbpl = dst->pitch; | |
| 326 int sbpl = src->pitch; | |
| 327 int bpp = dst->format->BytesPerPixel; | |
| 328 | |
| 329 char* dmem = dst_o->mem(dstrect); | |
| 330 char* smem = src_o->mem(srcrect); | |
| 331 | |
| 332 const unsigned char* amem = alpha + ay0 * awidth; | |
| 333 int i; | |
| 334 int ay = ay0; | |
| 335 for (i = ai0; i < ai1; i++) { | |
| 336 for (; ay < aheight; ay++) { | |
| 337 if (src->format->Amask == 0) | |
| 338 blit_line( (Uint32*)dmem, (Uint32*)smem, amem,ax0, ax1, awidth, aj0, aj1, false); | |
| 339 else | |
| 340 blit_line( (Uint32*)dmem, (Uint32*)smem, amem,ax0, ax1, awidth, aj0, aj1, true); | |
| 341 amem += awidth; dmem += dbpl; smem += sbpl; | |
| 342 } | |
| 343 ay = 0; amem = alpha; | |
| 344 } | |
| 345 for (; ay < ay1; ay++) { | |
| 346 if (src->format->Amask == 0) | |
| 347 blit_line( (Uint32*)dmem, (Uint32*)smem, amem,ax0, ax1, awidth, aj0, aj1, false); | |
| 348 else | |
| 349 blit_line( (Uint32*)dmem, (Uint32*)smem, amem,ax0, ax1, awidth, aj0, aj1, true); | |
| 350 amem += awidth; dmem += dbpl; smem += sbpl; | |
| 351 } | |
| 352 SDL_UnlockSurface(src); | |
| 353 SDL_UnlockSurface(dst); | |
| 354 } | |
| 52 | 355 |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
356 void DSurfaceBlitAdd(Surface* src_o, const Rect& srcrect_o, Surface* dst_o, const Rect& dstrect_o, unsigned char alpha) { |
| 0 | 357 SDL_Surface* dst = (SDL_Surface*)dst_o; |
| 358 SDL_Surface* src = (SDL_Surface*)src_o; | |
| 359 | |
|
65
4416cfac86ae
Convert EUC-JP files to UTF8
Thibaut Girka <thib@sitedethib.com>
parents:
60
diff
changeset
|
360 if (dst->format->BytesPerPixel != src->format->BytesPerPixel) return; // RGB変換はできない |
| 0 | 361 |
| 362 Rect srcrect(srcrect_o), dstrect(dstrect_o); | |
| 363 clip_rect(srcrect, dstrect, dst); | |
| 364 | |
| 365 SDL_LockSurface(dst); SDL_LockSurface(src); | |
| 366 int sbpl = src->pitch; | |
| 367 int dbpl = dst->pitch; | |
| 368 int bpp = dst->format->BytesPerPixel; | |
| 369 int width = srcrect.width(); | |
| 370 int height = srcrect.height(); | |
| 371 char* smem = src_o->mem(srcrect); | |
| 372 char* dmem = dst_o->mem(dstrect); | |
| 373 char* smem_end = src_o->mem_end(srcrect); | |
| 374 char* dmem_end = dst_o->mem_end(dstrect); | |
| 375 | |
| 376 SDL_PixelFormat& fmt = *dst->format; | |
| 377 int rshift = fmt.Rshift - fmt.Rloss; int rmask = fmt.Rmask; | |
| 378 int gshift = fmt.Gshift - fmt.Gloss; int gmask = fmt.Gmask; | |
| 379 int bshift = fmt.Bshift - fmt.Bloss; int bmask = fmt.Bmask; | |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
380 int ashift = src->format->Ashift - src->format->Aloss; int amask = src->format->Amask; |
| 0 | 381 int allmask = rmask | gmask | bmask; |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
382 int i, j; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
383 for (i=0; i < height; i++) { |
| 0 | 384 char* d = dmem; char* s = smem; |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
385 for (j=0; j < width; j++) { |
| 0 | 386 Uint32 sd = *(Uint32*)s; |
| 387 Uint32 dd = *(Uint32*)d; | |
| 388 if (sd&allmask) { | |
| 389 Uint32 sr = (sd&rmask)>>rshift; | |
| 390 Uint32 sg = (sd&gmask)>>gshift; | |
| 391 Uint32 sb = (sd&bmask)>>bshift; | |
|
60
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
392 Uint32 alpha2 = alpha; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
393 if (amask) |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
394 { |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
395 alpha2 = ((sd&amask)>>ashift); |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
396 alpha2 += alpha2 >> 7; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
397 alpha2 *= alpha; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
398 alpha2 >>= 8; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
399 } |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
400 |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
401 if (alpha2 != ALPHA_MAX) { |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
402 sr = (sr*alpha2)>>8; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
403 sg = (sg*alpha2)>>8; |
|
e16e13d8cd68
Replaced SATURATE -> ADD, implemented objComposite, corrected minor things
Thibaut GIRKA <thib@sitedethib.com>
parents:
56
diff
changeset
|
404 sb = (sb*alpha2)>>8; |
| 0 | 405 } |
| 406 Uint32 dr = sr + ((dd&rmask)>>rshift); | |
| 407 Uint32 dg = sg + ((dd&gmask)>>gshift); | |
| 408 Uint32 db = sb + ((dd&bmask)>>bshift); | |
| 409 if (dr > 255) dr = 255; | |
| 410 if (dg > 255) dg = 255; | |
| 411 if (db > 255) db = 255; | |
| 412 *(Uint32*)d = ((dr<<rshift)&rmask)| ((dg<<gshift)&gmask)| ((db<<bshift)&bmask); | |
| 413 } | |
| 414 s += bpp; d += bpp; | |
| 415 } | |
| 416 dmem += dbpl; smem += sbpl; | |
| 417 } | |
| 418 SDL_UnlockSurface(src); | |
| 419 SDL_UnlockSurface(dst); | |
| 420 } | |
| 52 | 421 |
| 0 | 422 void DSurfaceBlitMultiply(Surface* src_o, const Rect& srcrect_o, Surface* dst_o, const Rect& dstrect_o) { |
| 423 SDL_Surface* dst = (SDL_Surface*)dst_o; | |
| 424 SDL_Surface* src = (SDL_Surface*)src_o; | |
| 425 | |
| 426 Rect srcrect(srcrect_o), dstrect(dstrect_o); | |
| 427 clip_rect(srcrect, dstrect, dst); | |
| 428 | |
| 429 SDL_LockSurface(dst); | |
| 430 SDL_LockSurface(src); | |
| 431 int dbpl = dst->pitch; | |
| 432 int sbpl = src->pitch; | |
| 433 int bpp = dst->format->BytesPerPixel; | |
| 434 int width = srcrect.width(); | |
| 435 int height = srcrect.height(); | |
| 436 char* dmem = dst_o->mem(dstrect); | |
| 437 char* smem = src_o->mem(srcrect); | |
| 438 | |
| 439 SDL_PixelFormat& fmt = *dst->format; | |
|
65
4416cfac86ae
Convert EUC-JP files to UTF8
Thibaut Girka <thib@sitedethib.com>
parents:
60
diff
changeset
|
440 /* dst の 0-255 を 0-pixel に変換する（積算） */ |
| 0 | 441 int i; |
| 442 int table1[256], table2[256], table3[256]; | |
| 443 Uint32 src_pixel = *(Uint32*)smem; | |
| 444 src_pixel |= 0xff000000; | |
| 445 int c1=src_pixel&255, c2=(src_pixel>>8)&255, c3=(src_pixel>>16)&255; | |
| 446 for (i=0; i<256; i++) { | |
| 447 int n = i + (i>>7); | |
| 448 table1[i] = (c1*n)>>8; | |
| 449 table2[i] = (c2*n)&0xff00; | |
| 450 table3[i] = ((c3*n)<<8) & 0xff0000; | |
| 451 } | |
| 452 int err_count = 0; | |
| 453 for (i=0; i<height; i++) { | |
| 454 Uint32* d = (Uint32*)dmem; | |
| 455 Uint32* s = (Uint32*)smem; | |
| 456 int j; for (j=0; j<width; j++) { | |
| 457 Uint32 dd = *d; | |
| 458 Uint32 ss = *s; | |
| 459 if (ss == src_pixel) { | |
| 460 *(Uint32*)d = table1[ dd & 0xff] | table2[ (dd>>8) & 0xff] | table3[ (dd>>16) & 0xff]; | |
| 461 } else if ( ((ss^src_pixel) & 0xffffff) == 0) { // r,g,b of ss == src_pixel | |
| 462 Uint32 as = ss>>ASHIFT; | |
| 463 as += as>>7; | |
| 464 ss = table1[ dd & 0xff] | table2[ (dd>>8) & 0xff] | table3[ (dd>>16) & 0xff]; | |
| 465 Uint32 s1 = ss&CMASK1; | |
| 466 Uint32 d1 = dd&CMASK1; | |
| 467 d1 = (d1 + (((s1-d1) * as) >> 8)) & CMASK1; | |
| 468 ss &= CMASK2; | |
| 469 dd &= CMASK2; | |
| 470 dd = (dd + (((ss-dd) * as) >> 8)) & CMASK2; | |
| 471 *(Uint32*)d = d1 | dd | 0xff000000; | |
| 472 } else err_count++; | |
| 473 d++; s++; | |
| 474 } | |
| 475 dmem += dbpl; smem += sbpl; | |
| 476 } | |
| 477 if (err_count) { | |
| 478 fprintf(stderr,"multipy_blit : surface does not have unique color(%08x); %d pixels in width %d, height %d\n", | |
| 479 src_pixel, err_count, width, height); | |
| 480 } | |
| 481 SDL_UnlockSurface(dst); | |
| 482 SDL_UnlockSurface(src); | |
| 483 } |