[PATCH v3 3/4] gdiplus: Fix hatch brush patterns that require anti-aliasing.
Jeff Smith
whydoubt at gmail.com
Mon Jun 15 09:08:45 CDT 2020
Signed-off-by: Jeff Smith <whydoubt at gmail.com>
---
dlls/gdiplus/brush.c | 12 ++++---
dlls/gdiplus/gdiplus_private.h | 2 +-
dlls/gdiplus/graphics.c | 65 +++++++++++++++++++++++++---------
dlls/gdiplus/tests/brush.c | 10 ++----
4 files changed, 60 insertions(+), 29 deletions(-)
diff --git a/dlls/gdiplus/brush.c b/dlls/gdiplus/brush.c
index aa1cda1990..4b6ccca12a 100644
--- a/dlls/gdiplus/brush.c
+++ b/dlls/gdiplus/brush.c
@@ -197,13 +197,15 @@ GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
return Ok;
}
-static const char HatchBrushes[][8] = {
+/* The first 8 items per entry are bitmaps for each row of the hatch style.
+ * The 9th item of the entry is a flag indicating anti-aliasing. */
+static const unsigned char HatchBrushes[][9] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff }, /* HatchStyleHorizontal */
{ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, /* HatchStyleVertical */
- { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HatchStyleForwardDiagonal */
- { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HatchStyleBackwardDiagonal */
+ { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, TRUE }, /* HatchStyleForwardDiagonal */
+ { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, TRUE }, /* HatchStyleBackwardDiagonal */
{ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff }, /* HatchStyleCross */
- { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 }, /* HatchStyleDiagonalCross */
+ { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81, TRUE }, /* HatchStyleDiagonalCross */
{ 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80 }, /* HatchStyle05Percent */
{ 0x00, 0x08, 0x00, 0x80, 0x00, 0x08, 0x00, 0x80 }, /* HatchStyle10Percent */
{ 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00, 0x88 }, /* HatchStyle20Percent */
@@ -230,7 +232,7 @@ static const char HatchBrushes[][8] = {
{ 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff }, /* HatchStyleDarkHorizontal */
};
-GpStatus get_hatch_data(GpHatchStyle hatchstyle, const char **result)
+GpStatus get_hatch_data(GpHatchStyle hatchstyle, const unsigned char **result)
{
if (hatchstyle < ARRAY_SIZE(HatchBrushes))
{
diff --git a/dlls/gdiplus/gdiplus_private.h b/dlls/gdiplus/gdiplus_private.h
index 9e90a5d28c..d62860360a 100644
--- a/dlls/gdiplus/gdiplus_private.h
+++ b/dlls/gdiplus/gdiplus_private.h
@@ -123,7 +123,7 @@ extern GpStatus trace_path(GpGraphics *graphics, GpPath *path) DECLSPEC_HIDDEN;
typedef struct region_element region_element;
extern void delete_element(region_element *element) DECLSPEC_HIDDEN;
-extern GpStatus get_hatch_data(GpHatchStyle hatchstyle, const char **result) DECLSPEC_HIDDEN;
+extern GpStatus get_hatch_data(GpHatchStyle hatchstyle, const unsigned char **result) DECLSPEC_HIDDEN;
static inline INT gdip_round(REAL x)
{
diff --git a/dlls/gdiplus/graphics.c b/dlls/gdiplus/graphics.c
index 72075e02fb..1ed29d1094 100644
--- a/dlls/gdiplus/graphics.c
+++ b/dlls/gdiplus/graphics.c
@@ -114,6 +114,19 @@ static COLORREF get_gdi_brush_color(const GpBrush *brush)
return ARGB2COLORREF(argb);
}
+static ARGB blend_colors(ARGB start, ARGB end, REAL position);
+
+static void init_hatch_palette(ARGB *hatch_palette, ARGB fore_color, ARGB back_color)
+{
+ /* Pass the center of a 45-degree diagonal line with width of one unit through the
+ * center of a unit square, and the portion of the square that will be covered will
+ * equal sqrt(2) - 1/2. The covered portion for adjacent squares will be 1/4. */
+ hatch_palette[0] = back_color;
+ hatch_palette[1] = blend_colors(back_color, fore_color, 0.25);
+ hatch_palette[2] = blend_colors(back_color, fore_color, sqrt(2.0) - 0.5);
+ hatch_palette[3] = fore_color;
+}
+
static HBITMAP create_hatch_bitmap(const GpHatch *hatch)
{
HBITMAP hbmp;
@@ -132,18 +145,30 @@ static HBITMAP create_hatch_bitmap(const GpHatch *hatch)
hbmp = CreateDIBSection(0, (BITMAPINFO *)&bmih, DIB_RGB_COLORS, (void **)&bits, NULL, 0);
if (hbmp)
{
- const char *hatch_data;
+ const unsigned char *hatch_data;
if (get_hatch_data(hatch->hatchstyle, &hatch_data) == Ok)
{
+ ARGB hatch_palette[4];
+ init_hatch_palette(hatch_palette, hatch->forecol, hatch->backcol);
+
+ /* Anti-aliasing is only specified for diagonal hatch patterns.
+ * This implementation repeats the pattern, shifts as needed,
+ * then uses bitmask 1 to check the pixel value, and the 0x82
+ * bitmask to check the adjacent pixel values, to determine the
+ * degree of shading needed. */
for (y = 0; y < 8; y++)
{
- for (x = 0; x < 8; x++)
+ unsigned int row = 0x101 * hatch_data[y];
+
+ for (x = 0; x < 8; x++, row >>= 1)
{
- if (hatch_data[y] & (0x80 >> x))
- bits[y * 8 + x] = hatch->forecol;
+ int index;
+ if (hatch_data[8])
+ index = (row & 1) ? 2 : (row & 0x82) ? 1 : 0;
else
- bits[y * 8 + x] = hatch->backcol;
+ index = (row & 1) ? 3 : 0;
+ bits[y * 8 + 7 - x] = hatch_palette[index];
}
}
}
@@ -1160,25 +1185,33 @@ static GpStatus brush_fill_pixels(GpGraphics *graphics, GpBrush *brush,
{
int x, y;
GpHatch *fill = (GpHatch*)brush;
- const char *hatch_data;
+ const unsigned char *hatch_data;
+ ARGB hatch_palette[4];
if (get_hatch_data(fill->hatchstyle, &hatch_data) != Ok)
return NotImplemented;
- for (x=0; x<fill_area->Width; x++)
- for (y=0; y<fill_area->Height; y++)
- {
- int hx, hy;
+ init_hatch_palette(hatch_palette, fill->forecol, fill->backcol);
- /* FIXME: Account for the rendering origin */
- hx = (x + fill_area->X) % 8;
- hy = (y + fill_area->Y) % 8;
+ /* See create_hatch_bitmap for an explanation of how index is derived. */
+ for (y = 0; y < fill_area->Height; y++, argb_pixels += cdwStride)
+ {
+ /* FIXME: Account for the rendering origin */
+ const int hy = 7 - ((y + fill_area->Y) % 8);
+ const unsigned int row = 0x101 * hatch_data[hy];
- if ((hatch_data[7-hy] & (0x80 >> hx)) != 0)
- argb_pixels[x + y*cdwStride] = fill->forecol;
+ for (x = 0; x < fill_area->Width; x++)
+ {
+ const unsigned int srow = row >> (7 - ((x + fill_area->X) % 8));
+ int index;
+ if (hatch_data[8])
+ index = (srow & 1) ? 2 : (srow & 0x82) ? 1 : 0;
else
- argb_pixels[x + y*cdwStride] = fill->backcol;
+ index = (srow & 1) ? 3 : 0;
+
+ argb_pixels[x] = hatch_palette[index];
}
+ }
return Ok;
}
diff --git a/dlls/gdiplus/tests/brush.c b/dlls/gdiplus/tests/brush.c
index 2ab27c9de4..2f34712c71 100644
--- a/dlls/gdiplus/tests/brush.c
+++ b/dlls/gdiplus/tests/brush.c
@@ -1650,16 +1650,15 @@ static void test_hatchBrushStyles(void)
{
short pattern[8];
GpHatchStyle hs;
- BOOL todo;
}
styles[] =
{
{ {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xffff}, HatchStyleHorizontal },
{ {0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000}, HatchStyleVertical },
- { {0x4006, 0x0019, 0x0064, 0x0190, 0x0640, 0x1900, 0x6400, 0x9001}, HatchStyleForwardDiagonal, TRUE },
- { {0x9001, 0x6400, 0x1900, 0x0640, 0x0190, 0x0064, 0x0019, 0x4006}, HatchStyleBackwardDiagonal, TRUE },
+ { {0x4006, 0x0019, 0x0064, 0x0190, 0x0640, 0x1900, 0x6400, 0x9001}, HatchStyleForwardDiagonal },
+ { {0x9001, 0x6400, 0x1900, 0x0640, 0x0190, 0x0064, 0x0019, 0x4006}, HatchStyleBackwardDiagonal },
{ {0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xffff}, HatchStyleCross },
- { {0x9006, 0x6419, 0x1964, 0x0690, 0x0690, 0x1964, 0x6419, 0x9006}, HatchStyleDiagonalCross, TRUE },
+ { {0x9006, 0x6419, 0x1964, 0x0690, 0x0690, 0x1964, 0x6419, 0x9006}, HatchStyleDiagonalCross },
{ {0x0000, 0x0000, 0x0000, 0x00c0, 0x0000, 0x0000, 0x0000, 0xc000}, HatchStyle05Percent },
{ {0x0000, 0x00c0, 0x0000, 0xc000, 0x0000, 0x00c0, 0x0000, 0xc000}, HatchStyle10Percent },
{ {0x0000, 0x0c0c, 0x0000, 0xc0c0, 0x0000, 0x0c0c, 0x0000, 0xc0c0}, HatchStyle20Percent },
@@ -1742,11 +1741,8 @@ static void test_hatchBrushStyles(void)
match_image = FALSE;
}
}
- todo_wine_if(styles[i].todo)
- {
ok(match_hdc, "Unexpected pattern for hatch style %#x with hdc.\n", styles[i].hs);
ok(match_image, "Unexpected pattern for hatch style %#x with image.\n", styles[i].hs);
- }
}
status = GdipDeleteGraphics(graphics_image);
--
2.23.0
More information about the wine-devel
mailing list