From f71ffba994f501c96aa34bf0b1797e303c69a04a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stephan=20A=C3=9Fmus?= Date: Thu, 20 Jan 2005 23:07:07 +0000 Subject: [PATCH] implemented more drawing modes, refactored a little, still work left to do... git-svn-id: file:///srv/svn/repos/haiku/trunk/current@10918 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- .../Painter/drawing_modes/DrawingModeBlend.h | 215 ++++++++++++++++++ .../drawing_modes/DrawingModeFactory.cpp | 18 ++ .../Painter/drawing_modes/DrawingModeMax.h | 215 ++++++++++++++++++ .../Painter/drawing_modes/DrawingModeMin.h | 215 ++++++++++++++++++ .../drawing_modes/DrawingModeSubtract.h | 215 ++++++++++++++++++ 5 files changed, 878 insertions(+) create mode 100644 src/servers/app/server/Painter/drawing_modes/DrawingModeBlend.h create mode 100644 src/servers/app/server/Painter/drawing_modes/DrawingModeMax.h create mode 100644 src/servers/app/server/Painter/drawing_modes/DrawingModeMin.h create mode 100644 src/servers/app/server/Painter/drawing_modes/DrawingModeSubtract.h diff --git a/src/servers/app/server/Painter/drawing_modes/DrawingModeBlend.h b/src/servers/app/server/Painter/drawing_modes/DrawingModeBlend.h new file mode 100644 index 0000000000..e978faf29b --- /dev/null +++ b/src/servers/app/server/Painter/drawing_modes/DrawingModeBlend.h @@ -0,0 +1,215 @@ +// DrawingModeBlend.h + +#ifndef DRAWING_MODE_BLEND_H +#define DRAWING_MODE_BLEND_H + +#include + +#include "DrawingMode.h" +#include "PatternHandler.h" + + +inline void +blend_blend(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3, uint8 a) +{ + s1 = (*d1 + s1) >> 1; + s2 = (*d2 + s2) >> 1; + s3 = (*d3 + s3) >> 1; + + blend(d1, d2, d3, da, s1, s2, s3, a); +} + +inline void +assign_blend(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3) +{ + *d1 = (*d1 + s1) >> 1; + *d2 = (*d2 + s2) >> 1; + *d3 = (*d3 + s3) >> 1; +} + + +namespace agg +{ + //====================================================DrawingModeBlend + template + class DrawingModeBlend : public DrawingMode + { + public: + typedef Order order_type; + + //-------------------------------------------------------------------- + DrawingModeBlend() + : DrawingMode() + { + } + + //-------------------------------------------------------------------- + virtual void blend_pixel(int x, int y, const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(cover) + { + assign_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + } + } + + //-------------------------------------------------------------------- + virtual void blend_hline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + if(cover == 255) + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + assign_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + + p += 4; + x++; + } + while(--len); + } + else + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + blend_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + + x++; + p += 4; + } + while(--len); + } + } + + //-------------------------------------------------------------------- + virtual void blend_vline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { +printf("DrawingModeBlend::blend_vline()\n"); + } + + //-------------------------------------------------------------------- + virtual void blend_solid_hspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += 4; + x++; + } + while(--len); + } + + + + //-------------------------------------------------------------------- + virtual void blend_solid_vspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += m_rbuf->stride(); + y++; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_hspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + uint8 alpha = covers ? *covers++ : cover; + + if(alpha) + { + if(alpha == 255) + { + assign_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b); + } + else + { + blend_blend(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b, alpha); + } + } + p += 4; + ++colors; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_vspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { +printf("DrawingModeBlend::blend_color_vspan()\n"); + } + + }; + + typedef DrawingModeBlend DrawingModeRGBA32Blend; //----DrawingModeRGBA32Blend + typedef DrawingModeBlend DrawingModeARGB32Blend; //----DrawingModeARGB32Blend + typedef DrawingModeBlend DrawingModeABGR32Blend; //----DrawingModeABGR32Blend + typedef DrawingModeBlend DrawingModeBGRA32Blend; //----DrawingModeBGRA32Blend +} + +#endif // DRAWING_MODE_BLEND_H + diff --git a/src/servers/app/server/Painter/drawing_modes/DrawingModeFactory.cpp b/src/servers/app/server/Painter/drawing_modes/DrawingModeFactory.cpp index 37a895ef7a..543ef94764 100644 --- a/src/servers/app/server/Painter/drawing_modes/DrawingModeFactory.cpp +++ b/src/servers/app/server/Painter/drawing_modes/DrawingModeFactory.cpp @@ -2,9 +2,13 @@ #include "DrawingModeAdd.h" +#include "DrawingModeBlend.h" #include "DrawingModeCopy.h" #include "DrawingModeInvert.h" +#include "DrawingModeMax.h" +#include "DrawingModeMin.h" #include "DrawingModeOver.h" +#include "DrawingModeSubtract.h" #include "DrawingModeFactory.h" @@ -22,9 +26,23 @@ DrawingModeFactory::DrawingModeFor(drawing_mode mode) case B_OP_OVER: return new agg::DrawingModeBGRA32Over(); break; + case B_OP_ADD: return new agg::DrawingModeBGRA32Add(); break; + case B_OP_SUBTRACT: + return new agg::DrawingModeBGRA32Subtract(); + break; + case B_OP_BLEND: + return new agg::DrawingModeBGRA32Blend(); + break; + + case B_OP_MIN: + return new agg::DrawingModeBGRA32Min(); + break; + case B_OP_MAX: + return new agg::DrawingModeBGRA32Max(); + break; default: return new agg::DrawingModeBGRA32Copy(); diff --git a/src/servers/app/server/Painter/drawing_modes/DrawingModeMax.h b/src/servers/app/server/Painter/drawing_modes/DrawingModeMax.h new file mode 100644 index 0000000000..34d6982226 --- /dev/null +++ b/src/servers/app/server/Painter/drawing_modes/DrawingModeMax.h @@ -0,0 +1,215 @@ +// DrawingModeMax.h + +#ifndef DRAWING_MODE_MAX_H +#define DRAWING_MODE_MAX_H + +#include + +#include "DrawingMode.h" +#include "PatternHandler.h" + + +inline void +blend_max(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3, uint8 a) +{ + s1 = max_c(*d1, s1); + s2 = max_c(*d2, s2); + s3 = max_c(*d3, s3); + + blend(d1, d2, d3, da, s1, s2, s3, a); +} + +inline void +assign_max(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3) +{ + *d1 = max_c(*d1, s1); + *d2 = max_c(*d2, s2); + *d3 = max_c(*d3, s3); +} + + +namespace agg +{ + //====================================================DrawingModeMax + template + class DrawingModeMax : public DrawingMode + { + public: + typedef Order order_type; + + //-------------------------------------------------------------------- + DrawingModeMax() + : DrawingMode() + { + } + + //-------------------------------------------------------------------- + virtual void blend_pixel(int x, int y, const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(cover) + { + assign_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + } + } + + //-------------------------------------------------------------------- + virtual void blend_hline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + if(cover == 255) + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + assign_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + + p += 4; + x++; + } + while(--len); + } + else + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + blend_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + + x++; + p += 4; + } + while(--len); + } + } + + //-------------------------------------------------------------------- + virtual void blend_vline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { +printf("DrawingModeMax::blend_vline()\n"); + } + + //-------------------------------------------------------------------- + virtual void blend_solid_hspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += 4; + x++; + } + while(--len); + } + + + + //-------------------------------------------------------------------- + virtual void blend_solid_vspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += m_rbuf->stride(); + y++; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_hspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + uint8 alpha = covers ? *covers++ : cover; + + if(alpha) + { + if(alpha == 255) + { + assign_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b); + } + else + { + blend_max(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b, alpha); + } + } + p += 4; + ++colors; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_vspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { +printf("DrawingModeMax::blend_color_vspan()\n"); + } + + }; + + typedef DrawingModeMax DrawingModeRGBA32Max; //----DrawingModeRGBA32Max + typedef DrawingModeMax DrawingModeARGB32Max; //----DrawingModeARGB32Max + typedef DrawingModeMax DrawingModeABGR32Max; //----DrawingModeABGR32Max + typedef DrawingModeMax DrawingModeBGRA32Max; //----DrawingModeBGRA32Max +} + +#endif // DRAWING_MODE_MAX_H + diff --git a/src/servers/app/server/Painter/drawing_modes/DrawingModeMin.h b/src/servers/app/server/Painter/drawing_modes/DrawingModeMin.h new file mode 100644 index 0000000000..6606044c3d --- /dev/null +++ b/src/servers/app/server/Painter/drawing_modes/DrawingModeMin.h @@ -0,0 +1,215 @@ +// DrawingModeMin.h + +#ifndef DRAWING_MODE_MIN_H +#define DRAWING_MODE_MIN_H + +#include + +#include "DrawingMode.h" +#include "PatternHandler.h" + + +inline void +blend_min(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3, uint8 a) +{ + s1 = min_c(*d1, s1); + s2 = min_c(*d2, s2); + s3 = min_c(*d3, s3); + + blend(d1, d2, d3, da, s1, s2, s3, a); +} + +inline void +assign_min(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3) +{ + *d1 = min_c(*d1, s1); + *d2 = min_c(*d2, s2); + *d3 = min_c(*d3, s3); +} + + +namespace agg +{ + //====================================================DrawingModeMin + template + class DrawingModeMin : public DrawingMode + { + public: + typedef Order order_type; + + //-------------------------------------------------------------------- + DrawingModeMin() + : DrawingMode() + { + } + + //-------------------------------------------------------------------- + virtual void blend_pixel(int x, int y, const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(cover) + { + assign_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + } + } + + //-------------------------------------------------------------------- + virtual void blend_hline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + if(cover == 255) + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + assign_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + + p += 4; + x++; + } + while(--len); + } + else + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + blend_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + + x++; + p += 4; + } + while(--len); + } + } + + //-------------------------------------------------------------------- + virtual void blend_vline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { +printf("DrawingModeMin::blend_vline()\n"); + } + + //-------------------------------------------------------------------- + virtual void blend_solid_hspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += 4; + x++; + } + while(--len); + } + + + + //-------------------------------------------------------------------- + virtual void blend_solid_vspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += m_rbuf->stride(); + y++; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_hspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + uint8 alpha = covers ? *covers++ : cover; + + if(alpha) + { + if(alpha == 255) + { + assign_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b); + } + else + { + blend_min(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b, alpha); + } + } + p += 4; + ++colors; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_vspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { +printf("DrawingModeMin::blend_color_vspan()\n"); + } + + }; + + typedef DrawingModeMin DrawingModeRGBA32Min; //----DrawingModeRGBA32Min + typedef DrawingModeMin DrawingModeARGB32Min; //----DrawingModeARGB32Min + typedef DrawingModeMin DrawingModeABGR32Min; //----DrawingModeABGR32Min + typedef DrawingModeMin DrawingModeBGRA32Min; //----DrawingModeBGRA32Min +} + +#endif // DRAWING_MODE_MIN_H + diff --git a/src/servers/app/server/Painter/drawing_modes/DrawingModeSubtract.h b/src/servers/app/server/Painter/drawing_modes/DrawingModeSubtract.h new file mode 100644 index 0000000000..b71e121dd6 --- /dev/null +++ b/src/servers/app/server/Painter/drawing_modes/DrawingModeSubtract.h @@ -0,0 +1,215 @@ +// DrawingModeSubtract.h + +#ifndef DRAWING_MODE_SUBTRACT_H +#define DRAWING_MODE_SUBTRACT_H + +#include + +#include "DrawingMode.h" +#include "PatternHandler.h" + + +inline void +blend_subtract(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3, uint8 a) +{ + s1 = max_c(0, *d1 - s1); + s2 = max_c(0, *d2 - s2); + s3 = max_c(0, *d3 - s3); + + blend(d1, d2, d3, da, s1, s2, s3, a); +} + +inline void +assign_subtract(uint8* d1, uint8* d2, uint8* d3, uint8* da, + uint8 s1, uint8 s2, uint8 s3) +{ + *d1 = max_c(0, *d1 - s1); + *d2 = max_c(0, *d2 - s2); + *d3 = max_c(0, *d3 - s3); +} + + +namespace agg +{ + //====================================================DrawingModeSubtract + template + class DrawingModeSubtract : public DrawingMode + { + public: + typedef Order order_type; + + //-------------------------------------------------------------------- + DrawingModeSubtract() + : DrawingMode() + { + } + + //-------------------------------------------------------------------- + virtual void blend_pixel(int x, int y, const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(cover) + { + assign_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + } + } + + //-------------------------------------------------------------------- + virtual void blend_hline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + if(cover == 255) + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + assign_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + + p += 4; + x++; + } + while(--len); + } + else + { + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + + blend_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, cover); + + x++; + p += 4; + } + while(--len); + } + } + + //-------------------------------------------------------------------- + virtual void blend_vline(int x, int y, unsigned len, + const color_type& c, int8u cover) + { +printf("DrawingModeSubtract::blend_vline()\n"); + } + + //-------------------------------------------------------------------- + virtual void blend_solid_hspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += 4; + x++; + } + while(--len); + } + + + + //-------------------------------------------------------------------- + virtual void blend_solid_vspan(int x, int y, unsigned len, + const color_type& c, const int8u* covers) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + rgb_color color = fPatternHandler->R5ColorAt(x, y); + if(*covers) + { + if(*covers == 255) + { + assign_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue); + } + else + { + blend_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + color.red, color.green, color.blue, *covers); + } + } + covers++; + p += m_rbuf->stride(); + y++; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_hspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { + int8u* p = m_rbuf->row(y) + (x << 2); + do + { + uint8 alpha = covers ? *covers++ : cover; + + if(alpha) + { + if(alpha == 255) + { + assign_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b); + } + else + { + blend_subtract(&p[Order::R], &p[Order::G], &p[Order::B], &p[Order::A], + colors->r, colors->g, colors->b, alpha); + } + } + p += 4; + ++colors; + } + while(--len); + } + + + //-------------------------------------------------------------------- + virtual void blend_color_vspan(int x, int y, unsigned len, + const color_type* colors, + const int8u* covers, + int8u cover) + { +printf("DrawingModeSubtract::blend_color_vspan()\n"); + } + + }; + + typedef DrawingModeSubtract DrawingModeRGBA32Subtract; //----DrawingModeRGBA32Subtract + typedef DrawingModeSubtract DrawingModeARGB32Subtract; //----DrawingModeARGB32Subtract + typedef DrawingModeSubtract DrawingModeABGR32Subtract; //----DrawingModeABGR32Subtract + typedef DrawingModeSubtract DrawingModeBGRA32Subtract; //----DrawingModeBGRA32Subtract +} + +#endif // DRAWING_MODE_SUBTRACT_H +