Anti-Grain Geometry - AGG (libagg)
2.5
|
00001 //---------------------------------------------------------------------------- 00002 // Anti-Grain Geometry (AGG) - Version 2.5 00003 // A high quality rendering engine for C++ 00004 // Copyright (C) 2002-2006 Maxim Shemanarev 00005 // Contact: mcseem@antigrain.com 00006 // mcseemagg@yahoo.com 00007 // http://antigrain.com 00008 // 00009 // AGG is free software; you can redistribute it and/or 00010 // modify it under the terms of the GNU General Public License 00011 // as published by the Free Software Foundation; either version 2 00012 // of the License, or (at your option) any later version. 00013 // 00014 // AGG is distributed in the hope that it will be useful, 00015 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 // GNU General Public License for more details. 00018 // 00019 // You should have received a copy of the GNU General Public License 00020 // along with AGG; if not, write to the Free Software 00021 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 00022 // MA 02110-1301, USA. 00023 //---------------------------------------------------------------------------- 00024 // 00025 // Adaptation for high precision colors has been sponsored by 00026 // Liberty Technology Systems, Inc., visit http://lib-sys.com 00027 // 00028 // Liberty Technology Systems, Inc. is the provider of 00029 // PostScript and PDF technology for software developers. 00030 // 00031 //---------------------------------------------------------------------------- 00032 00033 #ifndef AGG_PIXFMT_RGB_PACKED_INCLUDED 00034 #define AGG_PIXFMT_RGB_PACKED_INCLUDED 00035 00036 #include <string.h> 00037 #include "agg_basics.h" 00038 #include "agg_color_rgba.h" 00039 #include "agg_rendering_buffer.h" 00040 00041 namespace agg 00042 { 00043 //=========================================================blender_rgb555 00044 struct blender_rgb555 00045 { 00046 typedef rgba8 color_type; 00047 typedef color_type::value_type value_type; 00048 typedef color_type::calc_type calc_type; 00049 typedef int16u pixel_type; 00050 00051 static AGG_INLINE void blend_pix(pixel_type* p, 00052 unsigned cr, unsigned cg, unsigned cb, 00053 unsigned alpha, 00054 unsigned) 00055 { 00056 pixel_type rgb = *p; 00057 calc_type r = (rgb >> 7) & 0xF8; 00058 calc_type g = (rgb >> 2) & 0xF8; 00059 calc_type b = (rgb << 3) & 0xF8; 00060 *p = (pixel_type) 00061 (((((cr - r) * alpha + (r << 8)) >> 1) & 0x7C00) | 00062 ((((cg - g) * alpha + (g << 8)) >> 6) & 0x03E0) | 00063 (((cb - b) * alpha + (b << 8)) >> 11) | 0x8000); 00064 } 00065 00066 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00067 { 00068 return (pixel_type)(((r & 0xF8) << 7) | 00069 ((g & 0xF8) << 2) | 00070 (b >> 3) | 0x8000); 00071 } 00072 00073 static AGG_INLINE color_type make_color(pixel_type p) 00074 { 00075 return color_type((p >> 7) & 0xF8, 00076 (p >> 2) & 0xF8, 00077 (p << 3) & 0xF8); 00078 } 00079 }; 00080 00081 00082 //=====================================================blender_rgb555_pre 00083 struct blender_rgb555_pre 00084 { 00085 typedef rgba8 color_type; 00086 typedef color_type::value_type value_type; 00087 typedef color_type::calc_type calc_type; 00088 typedef int16u pixel_type; 00089 00090 static AGG_INLINE void blend_pix(pixel_type* p, 00091 unsigned cr, unsigned cg, unsigned cb, 00092 unsigned alpha, 00093 unsigned cover) 00094 { 00095 alpha = color_type::base_mask - alpha; 00096 pixel_type rgb = *p; 00097 calc_type r = (rgb >> 7) & 0xF8; 00098 calc_type g = (rgb >> 2) & 0xF8; 00099 calc_type b = (rgb << 3) & 0xF8; 00100 *p = (pixel_type) 00101 ((((r * alpha + cr * cover) >> 1) & 0x7C00) | 00102 (((g * alpha + cg * cover) >> 6) & 0x03E0) | 00103 ((b * alpha + cb * cover) >> 11) | 0x8000); 00104 } 00105 00106 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00107 { 00108 return (pixel_type)(((r & 0xF8) << 7) | 00109 ((g & 0xF8) << 2) | 00110 (b >> 3) | 0x8000); 00111 } 00112 00113 static AGG_INLINE color_type make_color(pixel_type p) 00114 { 00115 return color_type((p >> 7) & 0xF8, 00116 (p >> 2) & 0xF8, 00117 (p << 3) & 0xF8); 00118 } 00119 }; 00120 00121 00122 00123 00124 //=====================================================blender_rgb555_gamma 00125 template<class Gamma> class blender_rgb555_gamma 00126 { 00127 public: 00128 typedef rgba8 color_type; 00129 typedef color_type::value_type value_type; 00130 typedef color_type::calc_type calc_type; 00131 typedef int16u pixel_type; 00132 typedef Gamma gamma_type; 00133 00134 blender_rgb555_gamma() : m_gamma(0) {} 00135 void gamma(const gamma_type& g) { m_gamma = &g; } 00136 00137 AGG_INLINE void blend_pix(pixel_type* p, 00138 unsigned cr, unsigned cg, unsigned cb, 00139 unsigned alpha, 00140 unsigned) 00141 { 00142 pixel_type rgb = *p; 00143 calc_type r = m_gamma->dir((rgb >> 7) & 0xF8); 00144 calc_type g = m_gamma->dir((rgb >> 2) & 0xF8); 00145 calc_type b = m_gamma->dir((rgb << 3) & 0xF8); 00146 *p = (pixel_type) 00147 (((m_gamma->inv(((m_gamma->dir(cr) - r) * alpha + (r << 8)) >> 8) << 7) & 0x7C00) | 00148 ((m_gamma->inv(((m_gamma->dir(cg) - g) * alpha + (g << 8)) >> 8) << 2) & 0x03E0) | 00149 (m_gamma->inv(((m_gamma->dir(cb) - b) * alpha + (b << 8)) >> 8) >> 3) | 0x8000); 00150 } 00151 00152 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00153 { 00154 return (pixel_type)(((r & 0xF8) << 7) | 00155 ((g & 0xF8) << 2) | 00156 (b >> 3) | 0x8000); 00157 } 00158 00159 static AGG_INLINE color_type make_color(pixel_type p) 00160 { 00161 return color_type((p >> 7) & 0xF8, 00162 (p >> 2) & 0xF8, 00163 (p << 3) & 0xF8); 00164 } 00165 00166 private: 00167 const Gamma* m_gamma; 00168 }; 00169 00170 00171 00172 00173 00174 //=========================================================blender_rgb565 00175 struct blender_rgb565 00176 { 00177 typedef rgba8 color_type; 00178 typedef color_type::value_type value_type; 00179 typedef color_type::calc_type calc_type; 00180 typedef int16u pixel_type; 00181 00182 static AGG_INLINE void blend_pix(pixel_type* p, 00183 unsigned cr, unsigned cg, unsigned cb, 00184 unsigned alpha, 00185 unsigned) 00186 { 00187 pixel_type rgb = *p; 00188 calc_type r = (rgb >> 8) & 0xF8; 00189 calc_type g = (rgb >> 3) & 0xFC; 00190 calc_type b = (rgb << 3) & 0xF8; 00191 *p = (pixel_type) 00192 (((((cr - r) * alpha + (r << 8)) ) & 0xF800) | 00193 ((((cg - g) * alpha + (g << 8)) >> 5) & 0x07E0) | 00194 (((cb - b) * alpha + (b << 8)) >> 11)); 00195 } 00196 00197 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00198 { 00199 return (pixel_type)(((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3)); 00200 } 00201 00202 static AGG_INLINE color_type make_color(pixel_type p) 00203 { 00204 return color_type((p >> 8) & 0xF8, 00205 (p >> 3) & 0xFC, 00206 (p << 3) & 0xF8); 00207 } 00208 }; 00209 00210 00211 00212 //=====================================================blender_rgb565_pre 00213 struct blender_rgb565_pre 00214 { 00215 typedef rgba8 color_type; 00216 typedef color_type::value_type value_type; 00217 typedef color_type::calc_type calc_type; 00218 typedef int16u pixel_type; 00219 00220 static AGG_INLINE void blend_pix(pixel_type* p, 00221 unsigned cr, unsigned cg, unsigned cb, 00222 unsigned alpha, 00223 unsigned cover) 00224 { 00225 alpha = color_type::base_mask - alpha; 00226 pixel_type rgb = *p; 00227 calc_type r = (rgb >> 8) & 0xF8; 00228 calc_type g = (rgb >> 3) & 0xFC; 00229 calc_type b = (rgb << 3) & 0xF8; 00230 *p = (pixel_type) 00231 ((((r * alpha + cr * cover) ) & 0xF800) | 00232 (((g * alpha + cg * cover) >> 5 ) & 0x07E0) | 00233 ((b * alpha + cb * cover) >> 11)); 00234 } 00235 00236 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00237 { 00238 return (pixel_type)(((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3)); 00239 } 00240 00241 static AGG_INLINE color_type make_color(pixel_type p) 00242 { 00243 return color_type((p >> 8) & 0xF8, 00244 (p >> 3) & 0xFC, 00245 (p << 3) & 0xF8); 00246 } 00247 }; 00248 00249 00250 00251 //=====================================================blender_rgb565_gamma 00252 template<class Gamma> class blender_rgb565_gamma 00253 { 00254 public: 00255 typedef rgba8 color_type; 00256 typedef color_type::value_type value_type; 00257 typedef color_type::calc_type calc_type; 00258 typedef int16u pixel_type; 00259 typedef Gamma gamma_type; 00260 00261 blender_rgb565_gamma() : m_gamma(0) {} 00262 void gamma(const gamma_type& g) { m_gamma = &g; } 00263 00264 AGG_INLINE void blend_pix(pixel_type* p, 00265 unsigned cr, unsigned cg, unsigned cb, 00266 unsigned alpha, 00267 unsigned) 00268 { 00269 pixel_type rgb = *p; 00270 calc_type r = m_gamma->dir((rgb >> 8) & 0xF8); 00271 calc_type g = m_gamma->dir((rgb >> 3) & 0xFC); 00272 calc_type b = m_gamma->dir((rgb << 3) & 0xF8); 00273 *p = (pixel_type) 00274 (((m_gamma->inv(((m_gamma->dir(cr) - r) * alpha + (r << 8)) >> 8) << 8) & 0xF800) | 00275 ((m_gamma->inv(((m_gamma->dir(cg) - g) * alpha + (g << 8)) >> 8) << 3) & 0x07E0) | 00276 (m_gamma->inv(((m_gamma->dir(cb) - b) * alpha + (b << 8)) >> 8) >> 3)); 00277 } 00278 00279 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00280 { 00281 return (pixel_type)(((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3)); 00282 } 00283 00284 static AGG_INLINE color_type make_color(pixel_type p) 00285 { 00286 return color_type((p >> 8) & 0xF8, 00287 (p >> 3) & 0xFC, 00288 (p << 3) & 0xF8); 00289 } 00290 00291 private: 00292 const Gamma* m_gamma; 00293 }; 00294 00295 00296 00297 //=====================================================blender_rgbAAA 00298 struct blender_rgbAAA 00299 { 00300 typedef rgba16 color_type; 00301 typedef color_type::value_type value_type; 00302 typedef color_type::calc_type calc_type; 00303 typedef int32u pixel_type; 00304 00305 static AGG_INLINE void blend_pix(pixel_type* p, 00306 unsigned cr, unsigned cg, unsigned cb, 00307 unsigned alpha, 00308 unsigned) 00309 { 00310 pixel_type rgb = *p; 00311 calc_type r = (rgb >> 14) & 0xFFC0; 00312 calc_type g = (rgb >> 4) & 0xFFC0; 00313 calc_type b = (rgb << 6) & 0xFFC0; 00314 *p = (pixel_type) 00315 (((((cr - r) * alpha + (r << 16)) >> 2) & 0x3FF00000) | 00316 ((((cg - g) * alpha + (g << 16)) >> 12) & 0x000FFC00) | 00317 (((cb - b) * alpha + (b << 16)) >> 22) | 0xC0000000); 00318 } 00319 00320 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00321 { 00322 return (pixel_type)(((r & 0xFFC0) << 14) | 00323 ((g & 0xFFC0) << 4) | 00324 (b >> 6) | 0xC0000000); 00325 } 00326 00327 static AGG_INLINE color_type make_color(pixel_type p) 00328 { 00329 return color_type((p >> 14) & 0xFFC0, 00330 (p >> 4) & 0xFFC0, 00331 (p << 6) & 0xFFC0); 00332 } 00333 }; 00334 00335 00336 00337 //==================================================blender_rgbAAA_pre 00338 struct blender_rgbAAA_pre 00339 { 00340 typedef rgba16 color_type; 00341 typedef color_type::value_type value_type; 00342 typedef color_type::calc_type calc_type; 00343 typedef int32u pixel_type; 00344 00345 static AGG_INLINE void blend_pix(pixel_type* p, 00346 unsigned cr, unsigned cg, unsigned cb, 00347 unsigned alpha, 00348 unsigned cover) 00349 { 00350 alpha = color_type::base_mask - alpha; 00351 cover = (cover + 1) << (color_type::base_shift - 8); 00352 pixel_type rgb = *p; 00353 calc_type r = (rgb >> 14) & 0xFFC0; 00354 calc_type g = (rgb >> 4) & 0xFFC0; 00355 calc_type b = (rgb << 6) & 0xFFC0; 00356 *p = (pixel_type) 00357 ((((r * alpha + cr * cover) >> 2) & 0x3FF00000) | 00358 (((g * alpha + cg * cover) >> 12) & 0x000FFC00) | 00359 ((b * alpha + cb * cover) >> 22) | 0xC0000000); 00360 } 00361 00362 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00363 { 00364 return (pixel_type)(((r & 0xFFC0) << 14) | 00365 ((g & 0xFFC0) << 4) | 00366 (b >> 6) | 0xC0000000); 00367 } 00368 00369 static AGG_INLINE color_type make_color(pixel_type p) 00370 { 00371 return color_type((p >> 14) & 0xFFC0, 00372 (p >> 4) & 0xFFC0, 00373 (p << 6) & 0xFFC0); 00374 } 00375 }; 00376 00377 00378 00379 //=================================================blender_rgbAAA_gamma 00380 template<class Gamma> class blender_rgbAAA_gamma 00381 { 00382 public: 00383 typedef rgba16 color_type; 00384 typedef color_type::value_type value_type; 00385 typedef color_type::calc_type calc_type; 00386 typedef int32u pixel_type; 00387 typedef Gamma gamma_type; 00388 00389 blender_rgbAAA_gamma() : m_gamma(0) {} 00390 void gamma(const gamma_type& g) { m_gamma = &g; } 00391 00392 AGG_INLINE void blend_pix(pixel_type* p, 00393 unsigned cr, unsigned cg, unsigned cb, 00394 unsigned alpha, 00395 unsigned) 00396 { 00397 pixel_type rgb = *p; 00398 calc_type r = m_gamma->dir((rgb >> 14) & 0xFFC0); 00399 calc_type g = m_gamma->dir((rgb >> 4) & 0xFFC0); 00400 calc_type b = m_gamma->dir((rgb << 6) & 0xFFC0); 00401 *p = (pixel_type) 00402 (((m_gamma->inv(((m_gamma->dir(cr) - r) * alpha + (r << 16)) >> 16) << 14) & 0x3FF00000) | 00403 ((m_gamma->inv(((m_gamma->dir(cg) - g) * alpha + (g << 16)) >> 16) << 4 ) & 0x000FFC00) | 00404 (m_gamma->inv(((m_gamma->dir(cb) - b) * alpha + (b << 16)) >> 16) >> 6 ) | 0xC0000000); 00405 } 00406 00407 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00408 { 00409 return (pixel_type)(((r & 0xFFC0) << 14) | 00410 ((g & 0xFFC0) << 4) | 00411 (b >> 6) | 0xC0000000); 00412 } 00413 00414 static AGG_INLINE color_type make_color(pixel_type p) 00415 { 00416 return color_type((p >> 14) & 0xFFC0, 00417 (p >> 4) & 0xFFC0, 00418 (p << 6) & 0xFFC0); 00419 } 00420 private: 00421 const Gamma* m_gamma; 00422 }; 00423 00424 00425 //=====================================================blender_bgrAAA 00426 struct blender_bgrAAA 00427 { 00428 typedef rgba16 color_type; 00429 typedef color_type::value_type value_type; 00430 typedef color_type::calc_type calc_type; 00431 typedef int32u pixel_type; 00432 00433 static AGG_INLINE void blend_pix(pixel_type* p, 00434 unsigned cr, unsigned cg, unsigned cb, 00435 unsigned alpha, 00436 unsigned) 00437 { 00438 pixel_type bgr = *p; 00439 calc_type b = (bgr >> 14) & 0xFFC0; 00440 calc_type g = (bgr >> 4) & 0xFFC0; 00441 calc_type r = (bgr << 6) & 0xFFC0; 00442 *p = (pixel_type) 00443 (((((cb - b) * alpha + (b << 16)) >> 2) & 0x3FF00000) | 00444 ((((cg - g) * alpha + (g << 16)) >> 12) & 0x000FFC00) | 00445 (((cr - r) * alpha + (r << 16)) >> 22) | 0xC0000000); 00446 } 00447 00448 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00449 { 00450 return (pixel_type)(((b & 0xFFC0) << 14) | 00451 ((g & 0xFFC0) << 4) | 00452 (r >> 6) | 0xC0000000); 00453 } 00454 00455 static AGG_INLINE color_type make_color(pixel_type p) 00456 { 00457 return color_type((p << 6) & 0xFFC0, 00458 (p >> 4) & 0xFFC0, 00459 (p >> 14) & 0xFFC0); 00460 } 00461 }; 00462 00463 00464 00465 //=================================================blender_bgrAAA_pre 00466 struct blender_bgrAAA_pre 00467 { 00468 typedef rgba16 color_type; 00469 typedef color_type::value_type value_type; 00470 typedef color_type::calc_type calc_type; 00471 typedef int32u pixel_type; 00472 00473 static AGG_INLINE void blend_pix(pixel_type* p, 00474 unsigned cr, unsigned cg, unsigned cb, 00475 unsigned alpha, 00476 unsigned cover) 00477 { 00478 alpha = color_type::base_mask - alpha; 00479 cover = (cover + 1) << (color_type::base_shift - 8); 00480 pixel_type bgr = *p; 00481 calc_type b = (bgr >> 14) & 0xFFC0; 00482 calc_type g = (bgr >> 4) & 0xFFC0; 00483 calc_type r = (bgr << 6) & 0xFFC0; 00484 *p = (pixel_type) 00485 ((((b * alpha + cb * cover) >> 2) & 0x3FF00000) | 00486 (((g * alpha + cg * cover) >> 12) & 0x000FFC00) | 00487 ((r * alpha + cr * cover) >> 22) | 0xC0000000); 00488 } 00489 00490 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00491 { 00492 return (pixel_type)(((b & 0xFFC0) << 14) | 00493 ((g & 0xFFC0) << 4) | 00494 (r >> 6) | 0xC0000000); 00495 } 00496 00497 static AGG_INLINE color_type make_color(pixel_type p) 00498 { 00499 return color_type((p << 6) & 0xFFC0, 00500 (p >> 4) & 0xFFC0, 00501 (p >> 14) & 0xFFC0); 00502 } 00503 }; 00504 00505 00506 00507 //=================================================blender_bgrAAA_gamma 00508 template<class Gamma> class blender_bgrAAA_gamma 00509 { 00510 public: 00511 typedef rgba16 color_type; 00512 typedef color_type::value_type value_type; 00513 typedef color_type::calc_type calc_type; 00514 typedef int32u pixel_type; 00515 typedef Gamma gamma_type; 00516 00517 blender_bgrAAA_gamma() : m_gamma(0) {} 00518 void gamma(const gamma_type& g) { m_gamma = &g; } 00519 00520 AGG_INLINE void blend_pix(pixel_type* p, 00521 unsigned cr, unsigned cg, unsigned cb, 00522 unsigned alpha, 00523 unsigned) 00524 { 00525 pixel_type bgr = *p; 00526 calc_type b = m_gamma->dir((bgr >> 14) & 0xFFC0); 00527 calc_type g = m_gamma->dir((bgr >> 4) & 0xFFC0); 00528 calc_type r = m_gamma->dir((bgr << 6) & 0xFFC0); 00529 *p = (pixel_type) 00530 (((m_gamma->inv(((m_gamma->dir(cb) - b) * alpha + (b << 16)) >> 16) << 14) & 0x3FF00000) | 00531 ((m_gamma->inv(((m_gamma->dir(cg) - g) * alpha + (g << 16)) >> 16) << 4 ) & 0x000FFC00) | 00532 (m_gamma->inv(((m_gamma->dir(cr) - r) * alpha + (r << 16)) >> 16) >> 6 ) | 0xC0000000); 00533 } 00534 00535 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00536 { 00537 return (pixel_type)(((b & 0xFFC0) << 14) | 00538 ((g & 0xFFC0) << 4) | 00539 (r >> 6) | 0xC0000000); 00540 } 00541 00542 static AGG_INLINE color_type make_color(pixel_type p) 00543 { 00544 return color_type((p << 6) & 0xFFC0, 00545 (p >> 4) & 0xFFC0, 00546 (p >> 14) & 0xFFC0); 00547 } 00548 00549 private: 00550 const Gamma* m_gamma; 00551 }; 00552 00553 00554 00555 //=====================================================blender_rgbBBA 00556 struct blender_rgbBBA 00557 { 00558 typedef rgba16 color_type; 00559 typedef color_type::value_type value_type; 00560 typedef color_type::calc_type calc_type; 00561 typedef int32u pixel_type; 00562 00563 static AGG_INLINE void blend_pix(pixel_type* p, 00564 unsigned cr, unsigned cg, unsigned cb, 00565 unsigned alpha, 00566 unsigned) 00567 { 00568 pixel_type rgb = *p; 00569 calc_type r = (rgb >> 16) & 0xFFE0; 00570 calc_type g = (rgb >> 5) & 0xFFE0; 00571 calc_type b = (rgb << 6) & 0xFFC0; 00572 *p = (pixel_type) 00573 (((((cr - r) * alpha + (r << 16)) ) & 0xFFE00000) | 00574 ((((cg - g) * alpha + (g << 16)) >> 11) & 0x001FFC00) | 00575 (((cb - b) * alpha + (b << 16)) >> 22)); 00576 } 00577 00578 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00579 { 00580 return (pixel_type)(((r & 0xFFE0) << 16) | ((g & 0xFFE0) << 5) | (b >> 6)); 00581 } 00582 00583 static AGG_INLINE color_type make_color(pixel_type p) 00584 { 00585 return color_type((p >> 16) & 0xFFE0, 00586 (p >> 5) & 0xFFE0, 00587 (p << 6) & 0xFFC0); 00588 } 00589 }; 00590 00591 00592 //=================================================blender_rgbBBA_pre 00593 struct blender_rgbBBA_pre 00594 { 00595 typedef rgba16 color_type; 00596 typedef color_type::value_type value_type; 00597 typedef color_type::calc_type calc_type; 00598 typedef int32u pixel_type; 00599 00600 static AGG_INLINE void blend_pix(pixel_type* p, 00601 unsigned cr, unsigned cg, unsigned cb, 00602 unsigned alpha, 00603 unsigned cover) 00604 { 00605 alpha = color_type::base_mask - alpha; 00606 cover = (cover + 1) << (color_type::base_shift - 8); 00607 pixel_type rgb = *p; 00608 calc_type r = (rgb >> 16) & 0xFFE0; 00609 calc_type g = (rgb >> 5) & 0xFFE0; 00610 calc_type b = (rgb << 6) & 0xFFC0; 00611 *p = (pixel_type) 00612 ((((r * alpha + cr * cover) ) & 0xFFE00000) | 00613 (((g * alpha + cg * cover) >> 11) & 0x001FFC00) | 00614 ((b * alpha + cb * cover) >> 22)); 00615 } 00616 00617 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00618 { 00619 return (pixel_type)(((r & 0xFFE0) << 16) | ((g & 0xFFE0) << 5) | (b >> 6)); 00620 } 00621 00622 static AGG_INLINE color_type make_color(pixel_type p) 00623 { 00624 return color_type((p >> 16) & 0xFFE0, 00625 (p >> 5) & 0xFFE0, 00626 (p << 6) & 0xFFC0); 00627 } 00628 }; 00629 00630 00631 00632 //=================================================blender_rgbBBA_gamma 00633 template<class Gamma> class blender_rgbBBA_gamma 00634 { 00635 public: 00636 typedef rgba16 color_type; 00637 typedef color_type::value_type value_type; 00638 typedef color_type::calc_type calc_type; 00639 typedef int32u pixel_type; 00640 typedef Gamma gamma_type; 00641 00642 blender_rgbBBA_gamma() : m_gamma(0) {} 00643 void gamma(const gamma_type& g) { m_gamma = &g; } 00644 00645 AGG_INLINE void blend_pix(pixel_type* p, 00646 unsigned cr, unsigned cg, unsigned cb, 00647 unsigned alpha, 00648 unsigned) 00649 { 00650 pixel_type rgb = *p; 00651 calc_type r = m_gamma->dir((rgb >> 16) & 0xFFE0); 00652 calc_type g = m_gamma->dir((rgb >> 5) & 0xFFE0); 00653 calc_type b = m_gamma->dir((rgb << 6) & 0xFFC0); 00654 *p = (pixel_type) 00655 (((m_gamma->inv(((m_gamma->dir(cr) - r) * alpha + (r << 16)) >> 16) << 16) & 0xFFE00000) | 00656 ((m_gamma->inv(((m_gamma->dir(cg) - g) * alpha + (g << 16)) >> 16) << 5 ) & 0x001FFC00) | 00657 (m_gamma->inv(((m_gamma->dir(cb) - b) * alpha + (b << 16)) >> 16) >> 6 )); 00658 } 00659 00660 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00661 { 00662 return (pixel_type)(((r & 0xFFE0) << 16) | ((g & 0xFFE0) << 5) | (b >> 6)); 00663 } 00664 00665 static AGG_INLINE color_type make_color(pixel_type p) 00666 { 00667 return color_type((p >> 16) & 0xFFE0, 00668 (p >> 5) & 0xFFE0, 00669 (p << 6) & 0xFFC0); 00670 } 00671 00672 private: 00673 const Gamma* m_gamma; 00674 }; 00675 00676 00677 //=====================================================blender_bgrABB 00678 struct blender_bgrABB 00679 { 00680 typedef rgba16 color_type; 00681 typedef color_type::value_type value_type; 00682 typedef color_type::calc_type calc_type; 00683 typedef int32u pixel_type; 00684 00685 static AGG_INLINE void blend_pix(pixel_type* p, 00686 unsigned cr, unsigned cg, unsigned cb, 00687 unsigned alpha, 00688 unsigned) 00689 { 00690 pixel_type bgr = *p; 00691 calc_type b = (bgr >> 16) & 0xFFC0; 00692 calc_type g = (bgr >> 6) & 0xFFE0; 00693 calc_type r = (bgr << 5) & 0xFFE0; 00694 *p = (pixel_type) 00695 (((((cb - b) * alpha + (b << 16)) ) & 0xFFC00000) | 00696 ((((cg - g) * alpha + (g << 16)) >> 10) & 0x003FF800) | 00697 (((cr - r) * alpha + (r << 16)) >> 21)); 00698 } 00699 00700 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00701 { 00702 return (pixel_type)(((b & 0xFFC0) << 16) | ((g & 0xFFE0) << 6) | (r >> 5)); 00703 } 00704 00705 static AGG_INLINE color_type make_color(pixel_type p) 00706 { 00707 return color_type((p << 5) & 0xFFE0, 00708 (p >> 6) & 0xFFE0, 00709 (p >> 16) & 0xFFC0); 00710 } 00711 }; 00712 00713 00714 //=================================================blender_bgrABB_pre 00715 struct blender_bgrABB_pre 00716 { 00717 typedef rgba16 color_type; 00718 typedef color_type::value_type value_type; 00719 typedef color_type::calc_type calc_type; 00720 typedef int32u pixel_type; 00721 00722 static AGG_INLINE void blend_pix(pixel_type* p, 00723 unsigned cr, unsigned cg, unsigned cb, 00724 unsigned alpha, 00725 unsigned cover) 00726 { 00727 alpha = color_type::base_mask - alpha; 00728 cover = (cover + 1) << (color_type::base_shift - 8); 00729 pixel_type bgr = *p; 00730 calc_type b = (bgr >> 16) & 0xFFC0; 00731 calc_type g = (bgr >> 6) & 0xFFE0; 00732 calc_type r = (bgr << 5) & 0xFFE0; 00733 *p = (pixel_type) 00734 ((((b * alpha + cb * cover) ) & 0xFFC00000) | 00735 (((g * alpha + cg * cover) >> 10) & 0x003FF800) | 00736 ((r * alpha + cr * cover) >> 21)); 00737 } 00738 00739 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00740 { 00741 return (pixel_type)(((b & 0xFFC0) << 16) | ((g & 0xFFE0) << 6) | (r >> 5)); 00742 } 00743 00744 static AGG_INLINE color_type make_color(pixel_type p) 00745 { 00746 return color_type((p << 5) & 0xFFE0, 00747 (p >> 6) & 0xFFE0, 00748 (p >> 16) & 0xFFC0); 00749 } 00750 }; 00751 00752 00753 00754 //=================================================blender_bgrABB_gamma 00755 template<class Gamma> class blender_bgrABB_gamma 00756 { 00757 public: 00758 typedef rgba16 color_type; 00759 typedef color_type::value_type value_type; 00760 typedef color_type::calc_type calc_type; 00761 typedef int32u pixel_type; 00762 typedef Gamma gamma_type; 00763 00764 blender_bgrABB_gamma() : m_gamma(0) {} 00765 void gamma(const gamma_type& g) { m_gamma = &g; } 00766 00767 AGG_INLINE void blend_pix(pixel_type* p, 00768 unsigned cr, unsigned cg, unsigned cb, 00769 unsigned alpha, 00770 unsigned) 00771 { 00772 pixel_type bgr = *p; 00773 calc_type b = m_gamma->dir((bgr >> 16) & 0xFFC0); 00774 calc_type g = m_gamma->dir((bgr >> 6) & 0xFFE0); 00775 calc_type r = m_gamma->dir((bgr << 5) & 0xFFE0); 00776 *p = (pixel_type) 00777 (((m_gamma->inv(((m_gamma->dir(cb) - b) * alpha + (b << 16)) >> 16) << 16) & 0xFFC00000) | 00778 ((m_gamma->inv(((m_gamma->dir(cg) - g) * alpha + (g << 16)) >> 16) << 6 ) & 0x003FF800) | 00779 (m_gamma->inv(((m_gamma->dir(cr) - r) * alpha + (r << 16)) >> 16) >> 5 )); 00780 } 00781 00782 static AGG_INLINE pixel_type make_pix(unsigned r, unsigned g, unsigned b) 00783 { 00784 return (pixel_type)(((b & 0xFFC0) << 16) | ((g & 0xFFE0) << 6) | (r >> 5)); 00785 } 00786 00787 static AGG_INLINE color_type make_color(pixel_type p) 00788 { 00789 return color_type((p << 5) & 0xFFE0, 00790 (p >> 6) & 0xFFE0, 00791 (p >> 16) & 0xFFC0); 00792 } 00793 00794 private: 00795 const Gamma* m_gamma; 00796 }; 00797 00798 00799 00800 //===========================================pixfmt_alpha_blend_rgb_packed 00801 template<class Blender, class RenBuf> class pixfmt_alpha_blend_rgb_packed 00802 { 00803 public: 00804 typedef RenBuf rbuf_type; 00805 typedef typename rbuf_type::row_data row_data; 00806 typedef Blender blender_type; 00807 typedef typename blender_type::color_type color_type; 00808 typedef typename blender_type::pixel_type pixel_type; 00809 typedef int order_type; // A fake one 00810 typedef typename color_type::value_type value_type; 00811 typedef typename color_type::calc_type calc_type; 00812 enum base_scale_e 00813 { 00814 base_shift = color_type::base_shift, 00815 base_scale = color_type::base_scale, 00816 base_mask = color_type::base_mask, 00817 pix_width = sizeof(pixel_type) 00818 }; 00819 00820 private: 00821 //-------------------------------------------------------------------- 00822 AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover) 00823 { 00824 if (c.a) 00825 { 00826 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8; 00827 if(alpha == base_mask) 00828 { 00829 *p = m_blender.make_pix(c.r, c.g, c.b); 00830 } 00831 else 00832 { 00833 m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover); 00834 } 00835 } 00836 } 00837 00838 public: 00839 //-------------------------------------------------------------------- 00840 explicit pixfmt_alpha_blend_rgb_packed(rbuf_type& rb) : m_rbuf(&rb) {} 00841 void attach(rbuf_type& rb) { m_rbuf = &rb; } 00842 00843 //-------------------------------------------------------------------- 00844 template<class PixFmt> 00845 bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2) 00846 { 00847 rect_i r(x1, y1, x2, y2); 00848 if(r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1))) 00849 { 00850 int stride = pixf.stride(); 00851 m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 00852 (r.x2 - r.x1) + 1, 00853 (r.y2 - r.y1) + 1, 00854 stride); 00855 return true; 00856 } 00857 return false; 00858 } 00859 00860 Blender& blender() { return m_blender; } 00861 00862 //-------------------------------------------------------------------- 00863 AGG_INLINE unsigned width() const { return m_rbuf->width(); } 00864 AGG_INLINE unsigned height() const { return m_rbuf->height(); } 00865 AGG_INLINE int stride() const { return m_rbuf->stride(); } 00866 00867 //-------------------------------------------------------------------- 00868 AGG_INLINE int8u* row_ptr(int y) { return m_rbuf->row_ptr(y); } 00869 AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); } 00870 AGG_INLINE row_data row(int y) const { return m_rbuf->row(y); } 00871 00872 //-------------------------------------------------------------------- 00873 AGG_INLINE int8u* pix_ptr(int x, int y) 00874 { 00875 return m_rbuf->row_ptr(y) + x * pix_width; 00876 } 00877 00878 AGG_INLINE const int8u* pix_ptr(int x, int y) const 00879 { 00880 return m_rbuf->row_ptr(y) + x * pix_width; 00881 } 00882 00883 //-------------------------------------------------------------------- 00884 AGG_INLINE void make_pix(int8u* p, const color_type& c) 00885 { 00886 *(pixel_type*)p = m_blender.make_pix(c.r, c.g, c.b); 00887 } 00888 00889 //-------------------------------------------------------------------- 00890 AGG_INLINE color_type pixel(int x, int y) const 00891 { 00892 return m_blender.make_color(((pixel_type*)m_rbuf->row_ptr(y))[x]); 00893 } 00894 00895 //-------------------------------------------------------------------- 00896 AGG_INLINE void copy_pixel(int x, int y, const color_type& c) 00897 { 00898 ((pixel_type*) 00899 m_rbuf->row_ptr(x, y, 1))[x] = 00900 m_blender.make_pix(c.r, c.g, c.b); 00901 } 00902 00903 //-------------------------------------------------------------------- 00904 AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover) 00905 { 00906 copy_or_blend_pix((pixel_type*)m_rbuf->row_ptr(x, y, 1) + x, c, cover); 00907 } 00908 00909 //-------------------------------------------------------------------- 00910 AGG_INLINE void copy_hline(int x, int y, 00911 unsigned len, 00912 const color_type& c) 00913 { 00914 pixel_type* p = (pixel_type*)m_rbuf->row_ptr(x, y, len) + x; 00915 pixel_type v = m_blender.make_pix(c.r, c.g, c.b); 00916 do 00917 { 00918 *p++ = v; 00919 } 00920 while(--len); 00921 } 00922 00923 //-------------------------------------------------------------------- 00924 AGG_INLINE void copy_vline(int x, int y, 00925 unsigned len, 00926 const color_type& c) 00927 { 00928 pixel_type v = m_blender.make_pix(c.r, c.g, c.b); 00929 do 00930 { 00931 pixel_type* p = (pixel_type*)m_rbuf->row_ptr(x, y++, 1) + x; 00932 *p = v; 00933 } 00934 while(--len); 00935 } 00936 00937 //-------------------------------------------------------------------- 00938 void blend_hline(int x, int y, 00939 unsigned len, 00940 const color_type& c, 00941 int8u cover) 00942 { 00943 if (c.a) 00944 { 00945 pixel_type* p = (pixel_type*)m_rbuf->row_ptr(x, y, len) + x; 00946 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8; 00947 if(alpha == base_mask) 00948 { 00949 pixel_type v = m_blender.make_pix(c.r, c.g, c.b); 00950 do 00951 { 00952 *p++ = v; 00953 } 00954 while(--len); 00955 } 00956 else 00957 { 00958 do 00959 { 00960 m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover); 00961 ++p; 00962 } 00963 while(--len); 00964 } 00965 } 00966 } 00967 00968 //-------------------------------------------------------------------- 00969 void blend_vline(int x, int y, 00970 unsigned len, 00971 const color_type& c, 00972 int8u cover) 00973 { 00974 if (c.a) 00975 { 00976 calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8; 00977 if(alpha == base_mask) 00978 { 00979 pixel_type v = m_blender.make_pix(c.r, c.g, c.b); 00980 do 00981 { 00982 ((pixel_type*)m_rbuf->row_ptr(x, y++, 1))[x] = v; 00983 } 00984 while(--len); 00985 } 00986 else 00987 { 00988 do 00989 { 00990 m_blender.blend_pix( 00991 (pixel_type*)m_rbuf->row_ptr(x, y++, 1), 00992 c.r, c.g, c.b, alpha, cover); 00993 } 00994 while(--len); 00995 } 00996 } 00997 } 00998 00999 //-------------------------------------------------------------------- 01000 void blend_solid_hspan(int x, int y, 01001 unsigned len, 01002 const color_type& c, 01003 const int8u* covers) 01004 { 01005 pixel_type* p = (pixel_type*)m_rbuf->row_ptr(x, y, len) + x; 01006 do 01007 { 01008 copy_or_blend_pix(p, c, *covers++); 01009 ++p; 01010 } 01011 while(--len); 01012 } 01013 01014 //-------------------------------------------------------------------- 01015 void blend_solid_vspan(int x, int y, 01016 unsigned len, 01017 const color_type& c, 01018 const int8u* covers) 01019 { 01020 do 01021 { 01022 copy_or_blend_pix((pixel_type*)m_rbuf->row_ptr(x, y++, 1) + x, 01023 c, *covers++); 01024 } 01025 while(--len); 01026 } 01027 01028 //-------------------------------------------------------------------- 01029 void copy_color_hspan(int x, int y, 01030 unsigned len, 01031 const color_type* colors) 01032 { 01033 pixel_type* p = (pixel_type*)m_rbuf->row_ptr(x, y, len) + x; 01034 do 01035 { 01036 *p++ = m_blender.make_pix(colors->r, colors->g, colors->b); 01037 ++colors; 01038 } 01039 while(--len); 01040 } 01041 01042 //-------------------------------------------------------------------- 01043 void copy_color_vspan(int x, int y, 01044 unsigned len, 01045 const color_type* colors) 01046 { 01047 do 01048 { 01049 pixel_type* p = (pixel_type*)m_rbuf->row_ptr(x, y++, 1) + x; 01050 *p = m_blender.make_pix(colors->r, colors->g, colors->b); 01051 ++colors; 01052 } 01053 while(--len); 01054 } 01055 01056 //-------------------------------------------------------------------- 01057 void blend_color_hspan(int x, int y, 01058 unsigned len, 01059 const color_type* colors, 01060 const int8u* covers, 01061 int8u cover) 01062 { 01063 pixel_type* p = (pixel_type*)m_rbuf->row_ptr(x, y, len) + x; 01064 do 01065 { 01066 copy_or_blend_pix(p++, *colors++, covers ? *covers++ : cover); 01067 } 01068 while(--len); 01069 } 01070 01071 //-------------------------------------------------------------------- 01072 void blend_color_vspan(int x, int y, 01073 unsigned len, 01074 const color_type* colors, 01075 const int8u* covers, 01076 int8u cover) 01077 { 01078 do 01079 { 01080 copy_or_blend_pix((pixel_type*)m_rbuf->row_ptr(x, y++, 1) + x, 01081 *colors++, covers ? *covers++ : cover); 01082 } 01083 while(--len); 01084 } 01085 01086 //-------------------------------------------------------------------- 01087 template<class RenBuf2> 01088 void copy_from(const RenBuf2& from, 01089 int xdst, int ydst, 01090 int xsrc, int ysrc, 01091 unsigned len) 01092 { 01093 const int8u* p = from.row_ptr(ysrc); 01094 if(p) 01095 { 01096 memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 01097 p + xsrc * pix_width, 01098 len * pix_width); 01099 } 01100 } 01101 01102 //-------------------------------------------------------------------- 01103 template<class SrcPixelFormatRenderer> 01104 void blend_from(const SrcPixelFormatRenderer& from, 01105 int xdst, int ydst, 01106 int xsrc, int ysrc, 01107 unsigned len, 01108 int8u cover) 01109 { 01110 typedef typename SrcPixelFormatRenderer::order_type src_order; 01111 01112 const value_type* psrc = (const value_type*)from.row_ptr(ysrc); 01113 if(psrc) 01114 { 01115 psrc += xsrc * 4; 01116 pixel_type* pdst = 01117 (pixel_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst; 01118 do 01119 { 01120 value_type alpha = psrc[src_order::A]; 01121 if(alpha) 01122 { 01123 if(alpha == base_mask && cover == 255) 01124 { 01125 *pdst = m_blender.make_pix(psrc[src_order::R], 01126 psrc[src_order::G], 01127 psrc[src_order::B]); 01128 } 01129 else 01130 { 01131 m_blender.blend_pix(pdst, 01132 psrc[src_order::R], 01133 psrc[src_order::G], 01134 psrc[src_order::B], 01135 alpha, 01136 cover); 01137 } 01138 } 01139 psrc += 4; 01140 ++pdst; 01141 } 01142 while(--len); 01143 } 01144 } 01145 01146 //-------------------------------------------------------------------- 01147 template<class SrcPixelFormatRenderer> 01148 void blend_from_color(const SrcPixelFormatRenderer& from, 01149 const color_type& color, 01150 int xdst, int ydst, 01151 int xsrc, int ysrc, 01152 unsigned len, 01153 int8u cover) 01154 { 01155 typedef typename SrcPixelFormatRenderer::value_type src_value_type; 01156 const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc); 01157 if(psrc) 01158 { 01159 pixel_type* pdst = 01160 (pixel_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst; 01161 01162 do 01163 { 01164 m_blender.blend_pix(pdst, 01165 color.r, color.g, color.b, color.a, 01166 cover); 01167 ++psrc; 01168 ++pdst; 01169 } 01170 while(--len); 01171 } 01172 } 01173 01174 //-------------------------------------------------------------------- 01175 template<class SrcPixelFormatRenderer> 01176 void blend_from_lut(const SrcPixelFormatRenderer& from, 01177 const color_type* color_lut, 01178 int xdst, int ydst, 01179 int xsrc, int ysrc, 01180 unsigned len, 01181 int8u cover) 01182 { 01183 typedef typename SrcPixelFormatRenderer::value_type src_value_type; 01184 const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc); 01185 if(psrc) 01186 { 01187 pixel_type* pdst = 01188 (pixel_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst; 01189 01190 do 01191 { 01192 const color_type& color = color_lut[*psrc]; 01193 m_blender.blend_pix(pdst, 01194 color.r, color.g, color.b, color.a, 01195 cover); 01196 ++psrc; 01197 ++pdst; 01198 } 01199 while(--len); 01200 } 01201 } 01202 01203 01204 01205 private: 01206 rbuf_type* m_rbuf; 01207 Blender m_blender; 01208 }; 01209 01210 typedef pixfmt_alpha_blend_rgb_packed<blender_rgb555, rendering_buffer> pixfmt_rgb555; //----pixfmt_rgb555 01211 typedef pixfmt_alpha_blend_rgb_packed<blender_rgb565, rendering_buffer> pixfmt_rgb565; //----pixfmt_rgb565 01212 01213 typedef pixfmt_alpha_blend_rgb_packed<blender_rgb555_pre, rendering_buffer> pixfmt_rgb555_pre; //----pixfmt_rgb555_pre 01214 typedef pixfmt_alpha_blend_rgb_packed<blender_rgb565_pre, rendering_buffer> pixfmt_rgb565_pre; //----pixfmt_rgb565_pre 01215 01216 typedef pixfmt_alpha_blend_rgb_packed<blender_rgbAAA, rendering_buffer> pixfmt_rgbAAA; //----pixfmt_rgbAAA 01217 typedef pixfmt_alpha_blend_rgb_packed<blender_bgrAAA, rendering_buffer> pixfmt_bgrAAA; //----pixfmt_bgrAAA 01218 typedef pixfmt_alpha_blend_rgb_packed<blender_rgbBBA, rendering_buffer> pixfmt_rgbBBA; //----pixfmt_rgbBBA 01219 typedef pixfmt_alpha_blend_rgb_packed<blender_bgrABB, rendering_buffer> pixfmt_bgrABB; //----pixfmt_bgrABB 01220 01221 typedef pixfmt_alpha_blend_rgb_packed<blender_rgbAAA_pre, rendering_buffer> pixfmt_rgbAAA_pre; //----pixfmt_rgbAAA_pre 01222 typedef pixfmt_alpha_blend_rgb_packed<blender_bgrAAA_pre, rendering_buffer> pixfmt_bgrAAA_pre; //----pixfmt_bgrAAA_pre 01223 typedef pixfmt_alpha_blend_rgb_packed<blender_rgbBBA_pre, rendering_buffer> pixfmt_rgbBBA_pre; //----pixfmt_rgbBBA_pre 01224 typedef pixfmt_alpha_blend_rgb_packed<blender_bgrABB_pre, rendering_buffer> pixfmt_bgrABB_pre; //----pixfmt_bgrABB_pre 01225 01226 01227 //-----------------------------------------------------pixfmt_rgb555_gamma 01228 template<class Gamma> class pixfmt_rgb555_gamma : 01229 public pixfmt_alpha_blend_rgb_packed<blender_rgb555_gamma<Gamma>, 01230 rendering_buffer> 01231 { 01232 public: 01233 pixfmt_rgb555_gamma(rendering_buffer& rb, const Gamma& g) : 01234 pixfmt_alpha_blend_rgb_packed<blender_rgb555_gamma<Gamma>, 01235 rendering_buffer>(rb) 01236 { 01237 this->blender().gamma(g); 01238 } 01239 }; 01240 01241 01242 //-----------------------------------------------------pixfmt_rgb565_gamma 01243 template<class Gamma> class pixfmt_rgb565_gamma : 01244 public pixfmt_alpha_blend_rgb_packed<blender_rgb565_gamma<Gamma>, rendering_buffer> 01245 { 01246 public: 01247 pixfmt_rgb565_gamma(rendering_buffer& rb, const Gamma& g) : 01248 pixfmt_alpha_blend_rgb_packed<blender_rgb565_gamma<Gamma>, rendering_buffer>(rb) 01249 { 01250 this->blender().gamma(g); 01251 } 01252 }; 01253 01254 01255 //-----------------------------------------------------pixfmt_rgbAAA_gamma 01256 template<class Gamma> class pixfmt_rgbAAA_gamma : 01257 public pixfmt_alpha_blend_rgb_packed<blender_rgbAAA_gamma<Gamma>, 01258 rendering_buffer> 01259 { 01260 public: 01261 pixfmt_rgbAAA_gamma(rendering_buffer& rb, const Gamma& g) : 01262 pixfmt_alpha_blend_rgb_packed<blender_rgbAAA_gamma<Gamma>, 01263 rendering_buffer>(rb) 01264 { 01265 this->blender().gamma(g); 01266 } 01267 }; 01268 01269 01270 //-----------------------------------------------------pixfmt_bgrAAA_gamma 01271 template<class Gamma> class pixfmt_bgrAAA_gamma : 01272 public pixfmt_alpha_blend_rgb_packed<blender_bgrAAA_gamma<Gamma>, 01273 rendering_buffer> 01274 { 01275 public: 01276 pixfmt_bgrAAA_gamma(rendering_buffer& rb, const Gamma& g) : 01277 pixfmt_alpha_blend_rgb_packed<blender_bgrAAA_gamma<Gamma>, 01278 rendering_buffer>(rb) 01279 { 01280 this->blender().gamma(g); 01281 } 01282 }; 01283 01284 01285 //-----------------------------------------------------pixfmt_rgbBBA_gamma 01286 template<class Gamma> class pixfmt_rgbBBA_gamma : 01287 public pixfmt_alpha_blend_rgb_packed<blender_rgbBBA_gamma<Gamma>, 01288 rendering_buffer> 01289 { 01290 public: 01291 pixfmt_rgbBBA_gamma(rendering_buffer& rb, const Gamma& g) : 01292 pixfmt_alpha_blend_rgb_packed<blender_rgbBBA_gamma<Gamma>, 01293 rendering_buffer>(rb) 01294 { 01295 this->blender().gamma(g); 01296 } 01297 }; 01298 01299 01300 //-----------------------------------------------------pixfmt_bgrABB_gamma 01301 template<class Gamma> class pixfmt_bgrABB_gamma : 01302 public pixfmt_alpha_blend_rgb_packed<blender_bgrABB_gamma<Gamma>, 01303 rendering_buffer> 01304 { 01305 public: 01306 pixfmt_bgrABB_gamma(rendering_buffer& rb, const Gamma& g) : 01307 pixfmt_alpha_blend_rgb_packed<blender_bgrABB_gamma<Gamma>, 01308 rendering_buffer>(rb) 01309 { 01310 this->blender().gamma(g); 01311 } 01312 }; 01313 01314 01315 } 01316 01317 #endif 01318