- Wine-Devel - list.winehq.org

[PATCH 3/6] winevulkan: Use KeUserModeCallback for debug callbacks.
by Jacek Caban Dec. 9, 2021

Dec. 9, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/user32/user_main.c | 2 +- dlls/winevulkan/loader.c | 19 +++++++++++++- dlls/winevulkan/vulkan.c | 46 +++++++++++++++++++++++---------- dlls/winevulkan/vulkan_loader.h | 26 +++++++++++++++++++ include/ntuser.h | 3 +++ 5 files changed, 81 insertions(+), 15 deletions(-)

1 0

[PATCH 2/6] ntdll: Temporarily allow KeUserModeCallback calls from client stack.
by Jacek Caban Dec. 9, 2021

Dec. 9, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- In winevulkan, we can't predict how we will be called until the conversion in fully complete. dlls/ntdll/unix/signal_arm.c | 8 ++++++++ dlls/ntdll/unix/signal_arm64.c | 8 ++++++++ dlls/ntdll/unix/signal_i386.c | 8 ++++++++ dlls/ntdll/unix/signal_x86_64.c | 8 ++++++++ include/wine/unixlib.h | 2 ++ 5 files changed, 34 insertions(+)

1 0

[PATCH 1/2] msvcrt: Add DECLSPEC_HOTPATCH to strlen and strrchr.
by Roman Pišl Dec. 8, 2021

Dec. 8, 2021

I see no other way how to make Clang ASAN work. ASAN recognizes first instruction(s) and inserts trampoline, but the loop in the function body jumps back to the start of the function (and hangs) or somewhere inside the trampoline (that leads to invalid instruction). Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50993 Signed-off-by: Roman Pišl <rpisl(a)seznam.cz> --- dlls/msvcrt/string.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/msvcrt/string.c b/dlls/msvcrt/string.c index d92b7a38d12..9fa8700da3d 100644 --- a/dlls/msvcrt/string.c +++ b/dlls/msvcrt/string.c @@ -1510,7 +1510,7 @@ int CDECL _atoldbl(_LDOUBLE *value, char *str) /********************************************************************* * strlen (MSVCRT.@) */ -size_t __cdecl strlen(const char *str) +size_t __cdecl DECLSPEC_HOTPATCH strlen(const char *str) { const char *s = str; while (*s) s++; @@ -3160,7 +3160,7 @@ char* __cdecl strchr(const char *str, int c) /********************************************************************* * strrchr (MSVCRT.@) */ -char* __cdecl strrchr(const char *str, int c) +char* __cdecl DECLSPEC_HOTPATCH strrchr(const char *str, int c) { char *ret = NULL; do { if (*str == (char)c) ret = (char*)str; } while (*str++); -- 2.30.2

1 1

[PATCH] wininet: Fix misleading indentation
by Alistair Leslie-Hughes Dec. 8, 2021

Dec. 8, 2021

../wine/dlls/wininet/internet.c: In function ‘InternetSetOptionW’: ../wine/dlls/wininet/internet.c:2890:11: warning: this ‘else’ clause does not guard... [-Wmisleading-indentation] 2890 | } else | ^~~~ ../wine/dlls/wininet/internet.c:2892:13: note: ...this statement, but the latter is misleadingly indented as if it were guard ed by the ‘else’ 2892 | lpwhh->ErrorMask = *(ULONG*)lpBuffer; | ^~~~~ Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/wininet/internet.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/wininet/internet.c b/dlls/wininet/internet.c index b0fe8a5e3fb..59fae2fbc95 100644 --- a/dlls/wininet/internet.c +++ b/dlls/wininet/internet.c @@ -2887,9 +2887,10 @@ BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption, } else if(dwBufferLength != sizeof(ULONG)) { SetLastError(ERROR_INTERNET_BAD_OPTION_LENGTH); ret = FALSE; - } else + } else { TRACE("INTERNET_OPTION_ERROR_MASK: %x\n", *(ULONG*)lpBuffer); lpwhh->ErrorMask = *(ULONG*)lpBuffer; + } } break; case INTERNET_OPTION_PROXY: -- 2.33.0

1 0

[PATCH] dbghelp: Fix use after freed
by Alistair Leslie-Hughes Dec. 8, 2021

Dec. 8, 2021

module_remove frees the module passed in. Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/dbghelp/module.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/dbghelp/module.c b/dlls/dbghelp/module.c index 5614c575cd0..894c713b3ce 100644 --- a/dlls/dbghelp/module.c +++ b/dlls/dbghelp/module.c @@ -1058,7 +1058,6 @@ BOOL WINAPI SymUnloadModule64(HANDLE hProcess, DWORD64 BaseOfDll) if (!pcs) return FALSE; module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN); if (!module) return FALSE; - if (!module_remove(pcs, module)) return FALSE; /* remove local scope if defined inside this module */ if (pcs->localscope_pc >= module->module.BaseOfImage && pcs->localscope_pc < module->module.BaseOfImage + module->module.ImageSize) @@ -1066,6 +1065,7 @@ BOOL WINAPI SymUnloadModule64(HANDLE hProcess, DWORD64 BaseOfDll) pcs->localscope_pc = 0; pcs->localscope_symt = NULL; } + if (!module_remove(pcs, module)) return FALSE; return TRUE; } -- 2.33.0

1 0

[PATCH] dbghelp: Fix possible memory leak (Coverity)
by Alistair Leslie-Hughes Dec. 8, 2021

Dec. 8, 2021

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/dbghelp/dwarf.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dlls/dbghelp/dwarf.c b/dlls/dbghelp/dwarf.c index 67440e97fe8..7515e540778 100644 --- a/dlls/dbghelp/dwarf.c +++ b/dlls/dbghelp/dwarf.c @@ -2314,7 +2314,10 @@ static struct symt* dwarf2_parse_subprogram(dwarf2_debug_info_t* di) * Actual thunks will be created in elf_module from the symbol table */ if (elf_is_in_thunk_area(di->unit_ctx->module_ctx->load_offset + addr_ranges[0].low, di->unit_ctx->module_ctx->thunks) >= 0) + { + free(addr_ranges); return NULL; + } ret_type = dwarf2_lookup_type(di); /* FIXME: assuming C source code */ -- 2.33.0

1 0

[PATCH 3/4] d2d1: Implement path_geometry_StrokeContainsPoint() for line segments.
by Henri Verbeet Dec. 8, 2021

Dec. 8, 2021

From: David White <dwhite(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d2d1/geometry.c | 69 ++++++++++++++++++++++++++++++++++++++++-- dlls/d2d1/tests/d2d1.c | 57 ++++++++++++++++++++++++++++++++++ 2 files changed, 123 insertions(+), 3 deletions(-) diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c index af92df4f6c5..d5a430e1f74 100644 --- a/dlls/d2d1/geometry.c +++ b/dlls/d2d1/geometry.c @@ -3409,11 +3409,74 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1Path D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) { - FIXME("iface %p, point %s, stroke_width %.8e, stroke_style %p, " - "transform %p, tolerance %.8e, contains %p stub!\n", + struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry(iface); + enum d2d_vertex_type type = D2D_VERTEX_TYPE_NONE; + D2D1_POINT_2F p, p1; + unsigned int i, j; + + TRACE("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); - return E_NOTIMPL; + if (stroke_style) + FIXME("Ignoring stroke style %p.\n", stroke_style); + + if (!transform) + transform = &identity; + + if (tolerance <= 0.0f) + tolerance = D2D1_DEFAULT_FLATTENING_TOLERANCE; + + *contains = FALSE; + for (i = 0; i < geometry->u.path.figure_count; ++i) + { + const struct d2d_figure *figure = &geometry->u.path.figures[i]; + + for (j = 0; j < figure->vertex_count; ++j) + { + if (figure->vertex_types[j] == D2D_VERTEX_TYPE_NONE) + continue; + + p = figure->vertices[j]; + type = figure->vertex_types[j]; + break; + } + + for (++j; j < figure->vertex_count; ++j) + { + if (figure->vertex_types[j] == D2D_VERTEX_TYPE_NONE + || d2d_vertex_type_is_split_bezier(figure->vertex_types[j])) + continue; + + switch (type) + { + case D2D_VERTEX_TYPE_LINE: + p1 = figure->vertices[j]; + *contains = d2d_point_on_line_segment(&point, &p, &p1, transform, stroke_width * 0.5f, tolerance); + p = p1; + break; + + default: + FIXME("Unhandled vertex type %#x.\n", type); + p = figure->vertices[j]; + break; + } + if (*contains) + return S_OK; + type = figure->vertex_types[j]; + } + + if (figure->flags & D2D_FIGURE_FLAG_CLOSED && (!*contains) && type == D2D_VERTEX_TYPE_LINE) + { + p1 = figure->vertices[0]; + *contains = d2d_point_on_line_segment(&point, &p, &p1, transform, stroke_width * 0.5f, tolerance); + p = p1; + } + + if (*contains) + return S_OK; + } + + return S_OK; } static HRESULT STDMETHODCALLTYPE d2d_path_geometry_FillContainsPoint(ID2D1PathGeometry *iface, diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index 22381ca3782..15088d679df 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -10137,7 +10137,10 @@ static void test_effect_crop(BOOL d3d11) static void test_stroke_contains_point(BOOL d3d11) { ID2D1RectangleGeometry *rectangle; + ID2D1GeometrySink *sink; + ID2D1PathGeometry *path; ID2D1Factory *factory; + D2D1_POINT_2F point; D2D1_RECT_F rect; unsigned int i; BOOL contains; @@ -10220,6 +10223,27 @@ static void test_stroke_contains_point(BOOL d3d11) {{{{1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 21.0f}}}, {10.0f, 31.0f}, 0.0f, 1.0f, TRUE, TRUE}, {{{{1.0f, 0.0f, 0.0f, 1.0f, 11.0f, 0.0f}}}, {16.0f, 0.0f}, 0.0f, 1.0f, TRUE, TRUE}, {{{{1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -21.0f}}}, { 0.0f, -11.0f}, 0.0f, 1.0f, TRUE, TRUE}, + }, + path_tests[] = + { + /* 0. Stroked area hittesting. Edge. */ + {{{{0.0f}}}, {160.0f, 600.0f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {239.24f, 600.0f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {239.26f, 600.0f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {240.74f, 600.0f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {240.76f, 600.0f}, 0.0f, 1.0f, FALSE, FALSE}, + + /* 5. Negative tolerance. */ + {{{{0.0f}}}, {239.24f, 600.0f}, -1.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {239.26f, 600.0f}, -1.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {240.74f, 600.0f}, -1.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {240.76f, 600.0f}, -1.0f, 1.0f, FALSE, FALSE}, + + /* 9. Less than default tolerance. */ + {{{{0.0f}}}, {239.39f, 600.0f}, 0.1f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {239.41f, 600.0f}, 0.1f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {240.59f, 600.0f}, 0.1f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {240.61f, 600.0f}, 0.1f, 1.0f, FALSE, FALSE}, }; hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &IID_ID2D1Factory, NULL, (void **)&factory); @@ -10244,6 +10268,39 @@ static void test_stroke_contains_point(BOOL d3d11) } ID2D1RectangleGeometry_Release(rectangle); + hr = ID2D1Factory_CreatePathGeometry(factory, &path); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + hr = ID2D1PathGeometry_Open(path, &sink); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + set_point(&point, 160.0f, 240.0f); + ID2D1GeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED); + line_to(sink, 240.0f, 240.0f); + line_to(sink, 240.0f, 720.0f); + line_to(sink, 160.0f, 720.0f); + ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_OPEN); + + hr = ID2D1GeometrySink_Close(sink); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ID2D1GeometrySink_Release(sink); + + for (i = 0; i < ARRAY_SIZE(path_tests); ++i) + { + const struct contains_point_test *test = &path_tests[i]; + + winetest_push_context("Test %u", i); + + contains = !test->contains; + hr = ID2D1PathGeometry_StrokeContainsPoint(path, test->point, test->stroke_width, + NULL, test->matrix ? &test->transform : NULL, test->tolerance, &contains); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ok(contains == test->contains, "Got unexpected result %#x.\n", contains); + + winetest_pop_context(); + } + + ID2D1PathGeometry_Release(path); + ID2D1Factory_Release(factory); } -- 2.30.2

2 1

[PATCH 2/4] d2d1: Implement d2d_rectangle_geometry_StrokeContainsPoint().
by Henri Verbeet Dec. 8, 2021

Dec. 8, 2021

From: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d2d1/geometry.c | 154 ++++++++++++++++++++++++++++++++++++++++- dlls/d2d1/tests/d2d1.c | 114 ++++++++++++++++++++++++++++++ 2 files changed, 265 insertions(+), 3 deletions(-) diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c index 49e4393ffec..af92df4f6c5 100644 --- a/dlls/d2d1/geometry.c +++ b/dlls/d2d1/geometry.c @@ -402,11 +402,16 @@ static void d2d_point_calculate_bezier(D2D1_POINT_2F *out, const D2D1_POINT_2F * out->y = t_c * (t_c * p0->y + t * p1->y) + t * (t_c * p1->y + t * p2->y); } +static float d2d_point_length(const D2D1_POINT_2F *p) +{ + return sqrtf(d2d_point_dot(p, p)); +} + static void d2d_point_normalise(D2D1_POINT_2F *p) { float l; - if ((l = sqrtf(d2d_point_dot(p, p))) != 0.0f) + if ((l = d2d_point_length(p)) != 0.0f) d2d_point_scale(p, 1.0f / l); } @@ -504,6 +509,83 @@ static float d2d_point_ccw(const D2D1_POINT_2F *a, const D2D1_POINT_2F *b, const return det_d[det_d_len - 1]; } +/* Determine whether the point q is within the given tolerance of the line + * segment defined by p0 and p1, with the given stroke width and transform. + * Note that we don't care about the tolerance with respect to end-points or + * joins here; those are handled separately. */ +static BOOL d2d_point_on_line_segment(const D2D1_POINT_2F *q, const D2D1_POINT_2F *p0, + const D2D1_POINT_2F *p1, const D2D1_MATRIX_3X2_F *transform, float stroke_width, float tolerance) +{ + D2D1_POINT_2F v_n, v_p, v_q, v_r; + float l; + + d2d_point_subtract(&v_p, p1, p0); + if ((l = d2d_point_length(&v_p)) == 0.0f) + return FALSE; + + /* After (shear) transformation, the line segment is a parallelogram + * defined by p⃑' and n⃑': + * + * p⃑ = P₁ - P₀ + * n⃑ = wp̂⟂ + * p⃑' = p⃑T + * n⃑' = n⃑T */ + l = stroke_width / l; + d2d_point_set(&v_r, transform->_31, transform->_32); + d2d_point_transform(&v_n, transform, -v_p.y * l, v_p.x * l); + d2d_point_subtract(&v_n, &v_n, &v_r); + d2d_point_transform(&v_p, transform, v_p.x, v_p.y); + d2d_point_subtract(&v_p, &v_p, &v_r); + + /* Decompose the vector q⃑ = Q - P₀T into a linear combination of + * p⃑' and n⃑': + * + * lq⃑ = xp⃑' + yn⃑' */ + d2d_point_transform(&v_q, transform, p0->x, p0->y); + d2d_point_subtract(&v_q, q, &v_q); + l = v_p.x * v_n.y - v_p.y * v_n.x; + v_r.x = v_q.x * v_n.y - v_q.y * v_n.x; + v_r.y = v_q.x * v_p.y - v_q.y * v_p.x; + + if (l < 0.0f) + { + l *= -1.0f; + v_r.x *= -1.0f; + } + + /* Check where Q projects onto p⃑'. */ + if (v_r.x < 0.0f || v_r.x > l) + return FALSE; + + /* Check where Q projects onto n⃑'. */ + if (fabs(v_r.y) < l) + return TRUE; + + /* Q lies outside the segment. Check whether the distance to the edge is + * within the tolerance. + * + * P₀' = P₀T + n⃑' + * q⃑' = Q - P₀' + * = q⃑ - n⃑' + * + * The distance is then q⃑' · p̂'⟂. */ + + if (v_r.y > 0.0f) + d2d_point_scale(&v_n, -1.0f); + d2d_point_subtract(&v_q, &v_q, &v_n); + + /* Check where Q projects onto p⃑' + n⃑'. */ + l = d2d_point_dot(&v_q, &v_p); + if (l < 0.0f || l > d2d_point_dot(&v_p, &v_p)) + return FALSE; + + v_n.x = -v_p.y; + v_n.y = v_p.x; + d2d_point_normalise(&v_n); + + return fabsf(d2d_point_dot(&v_q, &v_n)) < tolerance; +} + static void d2d_rect_union(D2D1_RECT_F *l, const D2D1_RECT_F *r) { l->left = min(l->left, r->left); @@ -4043,10 +4125,76 @@ static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_StrokeContainsPoint(ID2D D2D1_POINT_2F point, float stroke_width, ID2D1StrokeStyle *stroke_style, const D2D1_MATRIX_3X2_F *transform, float tolerance, BOOL *contains) { - FIXME("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p stub!\n", + const struct d2d_geometry *geometry = impl_from_ID2D1RectangleGeometry(iface); + const D2D1_RECT_F *rect = &geometry->u.rectangle.rect; + unsigned int i; + struct + { + D2D1_POINT_2F s, e; + } + segments[4]; + + TRACE("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); - return E_NOTIMPL; + if (stroke_style) + FIXME("Ignoring stroke style %p.\n", stroke_style); + + tolerance = fabsf(tolerance); + + if (!transform) + { + D2D1_POINT_2F d, s; + + s.x = rect->right - rect->left; + s.y = rect->bottom - rect->top; + d.x = fabsf((rect->right + rect->left) * 0.5f - point.x); + d.y = fabsf((rect->bottom + rect->top) * 0.5f - point.y); + + /* Inside test. */ + if (d.x <= (s.x - stroke_width) * 0.5f - tolerance && d.y <= (s.y - stroke_width) * 0.5f - tolerance) + { + *contains = FALSE; + return S_OK; + } + + if (tolerance == 0.0f) + { + *contains = d.x < (s.x + stroke_width) * 0.5f && d.y < (s.y + stroke_width) * 0.5f; + } + else + { + d.x = max(d.x - (s.x + stroke_width) * 0.5f, 0.0f); + d.y = max(d.y - (s.y + stroke_width) * 0.5f, 0.0f); + + *contains = d2d_point_dot(&d, &d) < tolerance * tolerance; + } + + return S_OK; + } + + stroke_width *= 0.5f; + + d2d_point_set(&segments[0].s, rect->left - stroke_width, rect->bottom); + d2d_point_set(&segments[0].e, rect->right + stroke_width, rect->bottom); + d2d_point_set(&segments[1].s, rect->right, rect->bottom + stroke_width); + d2d_point_set(&segments[1].e, rect->right, rect->top - stroke_width); + d2d_point_set(&segments[2].s, rect->right + stroke_width, rect->top); + d2d_point_set(&segments[2].e, rect->left - stroke_width, rect->top); + d2d_point_set(&segments[3].s, rect->left, rect->top - stroke_width); + d2d_point_set(&segments[3].e, rect->left, rect->bottom + stroke_width); + + *contains = FALSE; + for (i = 0; i < ARRAY_SIZE(segments); ++i) + { + if (d2d_point_on_line_segment(&point, &segments[i].s, &segments[i].e, transform, stroke_width, tolerance)) + { + *contains = TRUE; + break; + } + } + + return S_OK; } static HRESULT STDMETHODCALLTYPE d2d_rectangle_geometry_FillContainsPoint(ID2D1RectangleGeometry *iface, diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index cf37efdc7e8..22381ca3782 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -10134,6 +10134,119 @@ static void test_effect_crop(BOOL d3d11) release_test_context(&ctx); } +static void test_stroke_contains_point(BOOL d3d11) +{ + ID2D1RectangleGeometry *rectangle; + ID2D1Factory *factory; + D2D1_RECT_F rect; + unsigned int i; + BOOL contains; + HRESULT hr; + + static const struct contains_point_test + { + D2D1_MATRIX_3X2_F transform; + D2D1_POINT_2F point; + float tolerance; + float stroke_width; + BOOL matrix; + BOOL contains; + } + rectangle_tests[] = + { + /* 0. Stroked area hittesting. Edge. */ + {{{{0.0f}}}, { 0.4f, 10.0f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, { 0.5f, 10.0f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, { 0.6f, 10.0f}, 0.0f, 1.0f, FALSE, FALSE}, + + /* 3. Negative tolerance. */ + {{{{0.0f}}}, {-0.6f, 10.0f}, -1.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, { 0.6f, 10.0f}, -1.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, { 1.4f, 10.0f}, -1.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, { 1.5f, 10.0f}, -1.0f, 1.0f, FALSE, FALSE}, + + /* 7. Within tolerance limit around corner. */ + {{{{0.0f}}}, {-D2D1_DEFAULT_FLATTENING_TOLERANCE - 1.00f, 0.0f}, 0.0f, 2.0f, FALSE, FALSE}, + {{{{0.0f}}}, {-D2D1_DEFAULT_FLATTENING_TOLERANCE - 1.01f, 0.0f}, 0.0f, 2.0f, FALSE, FALSE}, + {{{{0.0f}}}, {-D2D1_DEFAULT_FLATTENING_TOLERANCE, -D2D1_DEFAULT_FLATTENING_TOLERANCE}, + 0.0f, 2.0f, FALSE, TRUE}, + {{{{0.0f}}}, {-D2D1_DEFAULT_FLATTENING_TOLERANCE, -D2D1_DEFAULT_FLATTENING_TOLERANCE - 1.01f}, + 0.0f, 2.0f, FALSE, FALSE}, + + /* 11. Center point. */ + {{{{0.0f}}}, { 5.0f, 10.0f}, 0.0f, 1.0f, FALSE, FALSE}, + + /* 12. Center point, large stroke width. */ + {{{{0.0f}}}, { 5.0f, 10.0f}, 0.0f, 100.0f, FALSE, TRUE}, + + /* 13. Center point, large tolerance. */ + {{{{0.0f}}}, { 5.0f, 10.0f}, 50.0f, 10.0f, FALSE, TRUE}, + + /* With transformation matrix. */ + + /* 14. */ + {{{{0.0f, 0.0f, 0.0f, 1.0f}}}, {0.1f, 10.0f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{0.0f, 0.0f, 0.0f, 1.0f}}}, {5.0f, 10.0f}, 5.0f, 1.0f, TRUE, FALSE}, + {{{{0.0f, 0.0f, 0.0f, 1.0f}}}, {4.9f, 10.0f}, 5.0f, 1.0f, TRUE, TRUE}, + {{{{0.0f, 0.0f, 0.0f, 1.0f}}}, {5.0f, 10.0f}, -5.0f, 1.0f, TRUE, FALSE}, + {{{{0.0f, 0.0f, 0.0f, 1.0f}}}, {4.9f, 10.0f}, -5.0f, 1.0f, TRUE, TRUE}, + + /* 19. */ + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {0.0f, 10.0f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {0.1f, 10.0f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {0.5f, 10.0f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {0.0f, 10.0f}, 1.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {0.59f, 10.0f}, 1.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {-0.59f, 10.0f}, 1.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {0.59f, 10.0f}, -1.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f}}}, {-0.59f, 10.0f}, -1.0f, 1.0f, TRUE, TRUE}, + + /* 27. */ + {{{{1.0f, 1.0f, 0.0f, 1.0f}}}, {5.0f, 4.4f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 1.0f, 0.0f, 1.0f}}}, {5.0f, 4.6f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 1.0f, 0.0f, 1.0f}}}, {5.0f, 5.4f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 1.0f, 0.0f, 1.0f}}}, {5.0f, 5.6f}, 0.0f, 1.0f, TRUE, FALSE}, + + /* 31. */ + {{{{1.0f, 1.0f, 0.0f, 1.0f}}}, {5.0f, 6.9f}, 1.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 1.0f, 0.0f, 1.0f}}}, {5.0f, 7.0f}, 1.0f, 1.0f, TRUE, FALSE}, + + /* 33. Offset matrix */ + {{{{1.0f, 0.0f, 0.0f, 1.0f, -11.0f, 0.0f}}}, { 5.0f, 20.0f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 21.0f}}}, {10.0f, 10.0f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 11.0f, 0.0f}}}, { 5.0f, 0.0f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -21.0f}}}, { 0.0f, 10.0f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, -11.0f, 0.0f}}}, {-6.0f, 20.0f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 21.0f}}}, {10.0f, 31.0f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 11.0f, 0.0f}}}, {16.0f, 0.0f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -21.0f}}}, { 0.0f, -11.0f}, 0.0f, 1.0f, TRUE, TRUE}, + }; + + hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &IID_ID2D1Factory, NULL, (void **)&factory); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + set_rect(&rect, 0.0f, 0.0f, 10.0f, 20.0f); + hr = ID2D1Factory_CreateRectangleGeometry(factory, &rect, &rectangle); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + for (i = 0; i < ARRAY_SIZE(rectangle_tests); ++i) + { + const struct contains_point_test *test = &rectangle_tests[i]; + + winetest_push_context("Test %u", i); + + contains = !test->contains; + hr = ID2D1RectangleGeometry_StrokeContainsPoint(rectangle, test->point, test->stroke_width, + NULL, test->matrix ? &test->transform : NULL, test->tolerance, &contains); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ok(contains == test->contains, "Got unexpected result %#x.\n", contains); + + winetest_pop_context(); + } + ID2D1RectangleGeometry_Release(rectangle); + + ID2D1Factory_Release(factory); +} + START_TEST(d2d1) { HMODULE d2d1_dll = GetModuleHandleA("d2d1.dll"); @@ -10198,6 +10311,7 @@ START_TEST(d2d1) queue_test(test_effect); queue_test(test_effect_2d_affine); queue_test(test_effect_crop); + queue_d3d10_test(test_stroke_contains_point); run_queued_tests(); } -- 2.30.2

2 1

[PATCH 4/4] d2d1: Implement path_geometry_StrokeContainsPoint() for Bézier segments.
by Henri Verbeet Dec. 8, 2021

Dec. 8, 2021

From: David White <dwhite(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d2d1/geometry.c | 198 +++++++++++++++++++++++++++++++++++++++-- dlls/d2d1/tests/d2d1.c | 93 +++++++++++++++++++ 2 files changed, 285 insertions(+), 6 deletions(-) diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c index d5a430e1f74..a7074899fda 100644 --- a/dlls/d2d1/geometry.c +++ b/dlls/d2d1/geometry.c @@ -586,6 +586,172 @@ static BOOL d2d_point_on_line_segment(const D2D1_POINT_2F *q, const D2D1_POINT_2 return fabsf(d2d_point_dot(&v_q, &v_n)) < tolerance; } +/* Approximate the Bézier segment with a (wide) line segment. If the point + * lies outside the approximation, we're done. If the width of the + * approximation is less than the tolerance and the point lies inside, we're + * also done. If neither of those is the case, we subdivide the Bézier segment + * and try again. */ +static BOOL d2d_point_on_bezier_segment(const D2D1_POINT_2F *q, const D2D1_POINT_2F *p0, + const D2D1_BEZIER_SEGMENT *b, const D2D1_MATRIX_3X2_F *transform, float stroke_width, float tolerance) +{ + float d1, d2, d3, d4, d, l, m, w, w2; + D2D1_POINT_2F t[7], start, end, v_p; + D2D1_BEZIER_SEGMENT b0, b1; + + m = 1.0f; + w = stroke_width * 0.5f; + + d2d_point_subtract(&v_p, &b->point3, p0); + /* If the endpoints coincide, use the line through the control points as + * the direction vector. That choice is somewhat arbitrary; other choices + * with tighter error bounds exist. */ + if ((l = d2d_point_dot(&v_p, &v_p)) == 0.0f) + { + d2d_point_subtract(&v_p, &b->point2, &b->point1); + /* If the control points also coincide, the curve is in fact a line. */ + if ((l = d2d_point_dot(&v_p, &v_p)) == 0.0f) + { + d2d_point_subtract(&v_p, &b->point1, p0); + end.x = p0->x + 0.75f * v_p.x; + end.y = p0->y + 0.75f * v_p.y; + + return d2d_point_on_line_segment(q, p0, &end, transform, w, tolerance); + } + m = 0.0f; + } + l = sqrtf(l); + d2d_point_scale(&v_p, 1.0f / l); + m *= l; + + /* Calculate the width w2 of the approximation. */ + + end.x = p0->x + v_p.x; + end.y = p0->y + v_p.y; + /* Here, d1 and d2 are the maximum (signed) distance of the control points + * from the line through the start and end points. */ + d1 = d2d_point_ccw(p0, &end, &b->point1); + d2 = d2d_point_ccw(p0, &end, &b->point2); + /* It can be shown that if the control points of a cubic Bézier curve lie + * on the same side of the line through the endpoints, the distance of the + * curve itself to that line will be within 3/4 of the distance of the + * control points to that line; if the control points lie on opposite + * sides, that distance will be within 4/9 of the distance of the + * corresponding control point. We're taking that as a given here. */ + if (d1 * d2 > 0.0f) + { + d1 *= 0.75f; + d2 *= 0.75f; + } + else + { + d1 = (d1 * 4.0f) / 9.0f; + d2 = (d2 * 4.0f) / 9.0f; + } + w2 = max(fabsf(d1), fabsf(d2)); + + /* Project the control points onto the line through the endpoints of the + * curve. We will use these to calculate the endpoints of the + * approximation. */ + d2d_point_subtract(&t[1], &b->point1, p0); + d1 = d2d_point_dot(&v_p, &t[1]); + d2d_point_subtract(&t[2], &b->point2, p0); + d2 = d2d_point_dot(&v_p, &t[2]); + + /* Calculate the start point of the approximation. Like further above, the + * actual curve is somewhat closer to the endpoints than the control + * points are. */ + d = min(min(d1, d2), 0); + if (d1 * d2 > 0.0f) + d *= 0.75f; + else + d = (d * 4.0f) / 9.0f; + /* Account for the stroke width and tolerance around the endpoints by + * adjusting the endpoints here. This matters because there are no joins + * in the original geometry for the places where we subdivide the original + * curve. We do this here because it's easy; alternatively we could + * explicitly test for this when subdividing the curve further below. */ + d -= min(w + tolerance, w2); + start.x = p0->x + d * v_p.x; + start.y = p0->y + d * v_p.y; + + /* Calculate the end point of the approximation. */ + d1 -= m; + d2 -= m; + d = max(max(d1, d2), 0); + if (d1 * d2 > 0.0f) + d = m + d * 0.75f; + else + d = m + (d * 4.0f) / 9.0f; + d += min(w2, w + tolerance); + end.x = p0->x + d * v_p.x; + end.y = p0->y + d * v_p.y; + + /* Calculate the error bounds of the approximation. We do this in + * transformed space because we need these to be relative to the given + * tolerance. */ + + d2d_point_transform(&t[0], transform, p0->x, p0->y); + d2d_point_transform(&t[1], transform, b->point1.x, b->point1.y); + d2d_point_transform(&t[2], transform, b->point2.x, b->point2.y); + d2d_point_transform(&t[3], transform, b->point3.x, b->point3.y); + d2d_point_transform(&t[4], transform, start.x, start.y); + d2d_point_transform(&t[5], transform, end.x, end.y); + + d2d_point_subtract(&t[6], &t[5], &t[4]); + l = d2d_point_length(&t[6]); + /* Here, d1 and d2 are the maximum (signed) distance of the control points + * from the line through the start and end points. */ + d1 = d2d_point_ccw(&t[4], &t[5], &t[1]) / l; + d2 = d2d_point_ccw(&t[4], &t[5], &t[2]) / l; + if (d1 * d2 > 0.0f) + { + d1 *= 0.75f; + d2 *= 0.75f; + } + else + { + d1 = (d1 * 4.0f) / 9.0f; + d2 = (d2 * 4.0f) / 9.0f; + } + l = max(max(d1, d2), 0) - min(min(d1, d2), 0); + + /* d3 and d4 are the (unsigned) distance of the endpoints of the + * approximation from the original endpoints. */ + d2d_point_subtract(&t[6], &t[4], &t[0]); + d3 = d2d_point_length(&t[6]); + d2d_point_subtract(&t[6], &t[5], &t[3]); + d4 = d2d_point_length(&t[6]); + l = max(max(d3, d4), l); + + /* If the error of the approximation is less than the tolerance, and Q + * lies on the approximation, the distance of Q to the stroked curve is + * definitely within the tolerance. */ + if (l <= tolerance && d2d_point_on_line_segment(q, &start, &end, transform, w, tolerance - l)) + return TRUE; + /* On the other hand, if the distance of Q to the stroked curve is more + * than the sum of the tolerance and d, the distance of Q to the stroked + * curve can't possibly be within the tolerance. */ + if (!d2d_point_on_line_segment(q, &start, &end, transform, w + w2, tolerance)) + return FALSE; + + /* Subdivide the curve. Note that simply splitting the segment in half + * here works and is easy, but may not be optimal. We could potentially + * reduce the number of iterations we need to do by splitting based on + * curvature or segment length. */ + d2d_point_lerp(&t[0], &b->point1, &b->point2, 0.5f); + + b1.point3 = b->point3; + d2d_point_lerp(&b1.point2, &b->point3, &b->point2, 0.5f); + d2d_point_lerp(&b1.point1, &t[0], &b1.point2, 0.5f); + + d2d_point_lerp(&b0.point1, p0, &b->point1, 0.5f); + d2d_point_lerp(&b0.point2, &t[0], &b0.point1, 0.5f); + d2d_point_lerp(&b0.point3, &b0.point2, &b1.point1, 0.5f); + + return d2d_point_on_bezier_segment(q, p0, &b0, transform, stroke_width, tolerance) + || d2d_point_on_bezier_segment(q, &b0.point3, &b1, transform, stroke_width, tolerance); +} + static void d2d_rect_union(D2D1_RECT_F *l, const D2D1_RECT_F *r) { l->left = min(l->left, r->left); @@ -3411,8 +3577,9 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1Path { struct d2d_geometry *geometry = impl_from_ID2D1PathGeometry(iface); enum d2d_vertex_type type = D2D_VERTEX_TYPE_NONE; + unsigned int i, j, bezier_idx; + D2D1_BEZIER_SEGMENT b; D2D1_POINT_2F p, p1; - unsigned int i, j; TRACE("iface %p, point %s, stroke_width %.8e, stroke_style %p, transform %p, tolerance %.8e, contains %p.\n", iface, debug_d2d_point_2f(&point), stroke_width, stroke_style, transform, tolerance, contains); @@ -3441,7 +3608,7 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1Path break; } - for (++j; j < figure->vertex_count; ++j) + for (bezier_idx = 0, ++j; j < figure->vertex_count; ++j) { if (figure->vertex_types[j] == D2D_VERTEX_TYPE_NONE || d2d_vertex_type_is_split_bezier(figure->vertex_types[j])) @@ -3455,6 +3622,14 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1Path p = p1; break; + case D2D_VERTEX_TYPE_BEZIER: + b.point1 = figure->original_bezier_controls[bezier_idx++]; + b.point2 = figure->original_bezier_controls[bezier_idx++]; + b.point3 = figure->vertices[j]; + *contains = d2d_point_on_bezier_segment(&point, &p, &b, transform, stroke_width, tolerance); + p = b.point3; + break; + default: FIXME("Unhandled vertex type %#x.\n", type); p = figure->vertices[j]; @@ -3465,11 +3640,22 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_StrokeContainsPoint(ID2D1Path type = figure->vertex_types[j]; } - if (figure->flags & D2D_FIGURE_FLAG_CLOSED && (!*contains) && type == D2D_VERTEX_TYPE_LINE) + if (figure->flags & D2D_FIGURE_FLAG_CLOSED && (!*contains)) { - p1 = figure->vertices[0]; - *contains = d2d_point_on_line_segment(&point, &p, &p1, transform, stroke_width * 0.5f, tolerance); - p = p1; + if (type == D2D_VERTEX_TYPE_LINE) + { + p1 = figure->vertices[0]; + *contains = d2d_point_on_line_segment(&point, &p, &p1, transform, stroke_width * 0.5f, tolerance); + p = p1; + } + else if (d2d_vertex_type_is_bezier(type)) + { + b.point1 = figure->original_bezier_controls[bezier_idx++]; + b.point2 = figure->original_bezier_controls[bezier_idx++]; + b.point3 = figure->vertices[0]; + *contains = d2d_point_on_bezier_segment(&point, &p, &b, transform, stroke_width, tolerance); + p = b.point3; + } } if (*contains) diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index 15088d679df..70c47795b4e 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -10244,6 +10244,67 @@ static void test_stroke_contains_point(BOOL d3d11) {{{{0.0f}}}, {239.41f, 600.0f}, 0.1f, 1.0f, FALSE, TRUE}, {{{{0.0f}}}, {240.59f, 600.0f}, 0.1f, 1.0f, FALSE, TRUE}, {{{{0.0f}}}, {240.61f, 600.0f}, 0.1f, 1.0f, FALSE, FALSE}, + + /* 13. Curves. */ + {{{{1.0f, 0.0f, 0.0f, 1.0f, 10.0f, 10.0f}}}, {170.0f, 418.6f}, 0.0f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 10.0f, 10.0f}}}, {170.0f, 420.1f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 10.0f, 10.0f}}}, {170.0f, 417.7f}, 0.0f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 10.0f, 10.0f}}}, { 89.5f, 485.3f}, 0.1f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 10.0f, 10.0f}}}, { 90.5f, 485.3f}, 0.1f, 1.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 10.0f, 10.0f}}}, { 91.5f, 485.3f}, 0.1f, 1.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 0.0f, 1.0f, 10.0f, 10.0f}}}, { 89.0f, 485.3f}, 0.1f, 1.0f, TRUE, FALSE}, + + /* 20. A curve where the control points project beyond the endpoints + * onto the line through the endpoints. */ + {{{{0.0f}}}, {306.97f, 791.67f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {307.27f, 791.67f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {308.47f, 791.67f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {308.77f, 791.67f}, 0.0f, 1.0f, FALSE, FALSE}, + + {{{{0.0f}}}, {350.00f, 824.10f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {350.00f, 824.40f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {350.00f, 825.60f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {350.00f, 825.90f}, 0.0f, 1.0f, FALSE, FALSE}, + + {{{{0.0f}}}, {391.23f, 791.67f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {391.53f, 791.67f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {392.73f, 791.67f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {393.03f, 791.67f}, 0.0f, 1.0f, FALSE, FALSE}, + + /* 32. A curve where the endpoints coincide. */ + {{{{0.0f}}}, {570.23f, 799.77f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {570.53f, 799.77f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {571.73f, 799.77f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {572.03f, 799.77f}, 0.0f, 1.0f, FALSE, FALSE}, + + {{{{0.0f}}}, {600.00f, 824.10f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {600.00f, 824.40f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {600.00f, 825.60f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {600.00f, 825.90f}, 0.0f, 1.0f, FALSE, FALSE}, + + {{{{0.0f}}}, {627.97f, 799.77f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {628.27f, 799.77f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {629.47f, 799.77f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {629.77f, 799.77f}, 0.0f, 1.0f, FALSE, FALSE}, + + /* 44. A curve with coinciding endpoints, as well as coinciding + * control points. */ + {{{{0.0f}}}, {825.00f, 800.00f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {861.00f, 824.00f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {861.00f, 826.00f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {862.50f, 825.00f}, 0.0f, 1.0f, FALSE, TRUE}, + {{{{0.0f}}}, {864.00f, 824.00f}, 0.0f, 1.0f, FALSE, FALSE}, + {{{{0.0f}}}, {864.00f, 826.00f}, 0.0f, 1.0f, FALSE, FALSE}, + + /* 50. Shear transforms. */ + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, { 837.2f, 600.0f}, 0.1f, 5.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, { 837.5f, 600.0f}, 0.1f, 5.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, {1186.3f, 791.7f}, 0.1f, 5.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, {1186.6f, 791.7f}, 0.1f, 5.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, {1425.0f, 827.3f}, 0.1f, 5.0f, TRUE, TRUE}, + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, {1425.0f, 827.6f}, 0.1f, 5.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, {1620.1f, 800.0f}, 0.1f, 5.0f, TRUE, FALSE}, + {{{{1.0f, 0.0f, 1.0f, 1.0f}}}, {1620.4f, 800.0f}, 0.1f, 5.0f, TRUE, TRUE}, }; hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &IID_ID2D1Factory, NULL, (void **)&factory); @@ -10273,6 +10334,19 @@ static void test_stroke_contains_point(BOOL d3d11) hr = ID2D1PathGeometry_Open(path, &sink); ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + /* A limaçon. */ + set_point(&point, 160.0f, 720.0f); + ID2D1GeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED); + cubic_to(sink, 119.0f, 720.0f, 83.0f, 600.0f, 80.0f, 474.0f); + cubic_to(sink, 78.0f, 349.0f, 108.0f, 245.0f, 135.0f, 240.0f); + cubic_to(sink, 163.0f, 235.0f, 180.0f, 318.0f, 176.0f, 370.0f); + cubic_to(sink, 171.0f, 422.0f, 149.0f, 422.0f, 144.0f, 370.0f); + cubic_to(sink, 140.0f, 318.0f, 157.0f, 235.0f, 185.0f, 240.0f); + cubic_to(sink, 212.0f, 245.0f, 242.0f, 349.0f, 240.0f, 474.0f); + cubic_to(sink, 238.0f, 600.0f, 201.0f, 720.0f, 160.0f, 720.0f); + ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_CLOSED); + + /* Some straight lines. */ set_point(&point, 160.0f, 240.0f); ID2D1GeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED); line_to(sink, 240.0f, 240.0f); @@ -10280,6 +10354,25 @@ static void test_stroke_contains_point(BOOL d3d11) line_to(sink, 160.0f, 720.0f); ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_OPEN); + /* Projected control points extending beyond the line segment through the + * endpoints. */ + set_point(&point, 325.0f, 750.0f); + ID2D1GeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED); + cubic_to(sink, 250.0f, 850.0f, 450.0f, 850.0f, 375.0f, 750.0f); + ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_OPEN); + + /* Coinciding endpoints. */ + set_point(&point, 600.0f, 750.0f); + ID2D1GeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED); + cubic_to(sink, 500.0f, 850.0f, 700.0f, 850.0f, 600.0f, 750.0f); + ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_OPEN); + + /* Coinciding endpoints, as well as coinciding control points. */ + set_point(&point, 750.0f, 750.0f); + ID2D1GeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED); + cubic_to(sink, 900.0f, 850.0f, 900.0f, 850.0f, 750.0f, 750.0f); + ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_OPEN); + hr = ID2D1GeometrySink_Close(sink); ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); ID2D1GeometrySink_Release(sink); -- 2.30.2

1 0

[PATCH 1/4] d2d1: Store original Bézier curves as cubics.
by Henri Verbeet Dec. 8, 2021

Dec. 8, 2021

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d2d1/geometry.c | 127 +++++++++++++++++++++++++++++-------------- 1 file changed, 85 insertions(+), 42 deletions(-) diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c index c7d0d94f1ad..49e4393ffec 100644 --- a/dlls/d2d1/geometry.c +++ b/dlls/d2d1/geometry.c @@ -72,6 +72,7 @@ struct d2d_figure size_t bezier_control_count; D2D1_POINT_2F *original_bezier_controls; + size_t original_bezier_controls_size; size_t original_bezier_control_count; D2D1_RECT_F bounds; @@ -656,6 +657,22 @@ static BOOL d2d_figure_add_bezier_controls(struct d2d_figure *figure, size_t cou return TRUE; } +static BOOL d2d_figure_add_original_bezier_controls(struct d2d_figure *figure, size_t count, const D2D1_POINT_2F *p) +{ + if (!d2d_array_reserve((void **)&figure->original_bezier_controls, &figure->original_bezier_controls_size, + figure->original_bezier_control_count + count, sizeof(*figure->original_bezier_controls))) + { + ERR("Failed to grow cubic Bézier controls array.\n"); + return FALSE; + } + + memcpy(&figure->original_bezier_controls[figure->original_bezier_control_count], + p, count * sizeof(*figure->original_bezier_controls)); + figure->original_bezier_control_count += count; + + return TRUE; +} + static void d2d_cdt_edge_rot(struct d2d_cdt_edge_ref *dst, const struct d2d_cdt_edge_ref *src) { dst->idx = src->idx; @@ -2595,7 +2612,15 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddBeziers(ID2D1GeometrySink *if { D2D1_RECT_F bezier_bounds; - /* FIXME: This tries to approximate a cubic bezier with a quadratic one. */ + if (!d2d_figure_add_original_bezier_controls(figure, 1, &beziers[i].point1) + || !d2d_figure_add_original_bezier_controls(figure, 1, &beziers[i].point2)) + { + ERR("Failed to add cubic Bézier controls.\n"); + geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR; + return; + } + + /* FIXME: This tries to approximate a cubic Bézier with a quadratic one. */ p.x = (beziers[i].point1.x + beziers[i].point2.x) * 0.75f; p.y = (beziers[i].point1.y + beziers[i].point2.y) * 0.75f; p.x -= (figure->vertices[figure->vertex_count - 1].x + beziers[i].point3.x) * 0.25f; @@ -2667,8 +2692,8 @@ static void d2d_path_geometry_free_figures(struct d2d_geometry *geometry) for (i = 0; i < geometry->u.path.figure_count; ++i) { - heap_free(geometry->u.path.figures[i].bezier_controls); heap_free(geometry->u.path.figures[i].original_bezier_controls); + heap_free(geometry->u.path.figures[i].bezier_controls); heap_free(geometry->u.path.figures[i].vertices); } heap_free(geometry->u.path.figures); @@ -2937,7 +2962,6 @@ static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_Close(ID2D1GeometrySink *ifac { struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface); HRESULT hr = E_FAIL; - size_t i; TRACE("iface %p.\n", iface); @@ -2949,15 +2973,6 @@ static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_Close(ID2D1GeometrySink *ifac } geometry->u.path.state = D2D_GEOMETRY_STATE_CLOSED; - for (i = 0; i < geometry->u.path.figure_count; ++i) - { - struct d2d_figure *figure = &geometry->u.path.figures[i]; - size_t size = figure->bezier_control_count * sizeof(*figure->original_bezier_controls); - if (!(figure->original_bezier_controls = heap_alloc(size))) - goto done; - memcpy(figure->original_bezier_controls, figure->bezier_controls, size); - } - if (!d2d_geometry_intersect_self(geometry)) goto done; if (FAILED(hr = d2d_geometry_resolve_beziers(geometry))) @@ -3016,6 +3031,17 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1Geometr for (i = 0; i < bezier_count; ++i) { D2D1_RECT_F bezier_bounds; + D2D1_POINT_2F p[2]; + + /* Construct a cubic curve. */ + d2d_point_lerp(&p[0], &figure->vertices[figure->vertex_count - 1], &beziers[i].point1, 2.0f / 3.0f); + d2d_point_lerp(&p[1], &beziers[i].point2, &beziers[i].point1, 2.0f / 3.0f); + if (!d2d_figure_add_original_bezier_controls(figure, 2, p)) + { + ERR("Failed to add cubic Bézier controls.\n"); + geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR; + return; + } d2d_rect_get_bezier_bounds(&bezier_bounds, &figure->vertices[figure->vertex_count - 1], &beziers[i].point1, &beziers[i].point2); @@ -3228,10 +3254,19 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetBounds(ID2D1PathGeometry * break; case D2D_VERTEX_TYPE_BEZIER: + /* FIXME: This attempts to approximate a cubic Bézier with + * a quadratic one. */ p1 = figure->original_bezier_controls[bezier_idx++]; d2d_point_transform(&p1, transform, p1.x, p1.y); + p2 = figure->original_bezier_controls[bezier_idx++]; + d2d_point_transform(&p2, transform, p2.x, p2.y); + p1.x = (p1.x + p2.x) * 0.75f; + p1.y = (p1.y + p2.y) * 0.75f; p2 = figure->vertices[j]; d2d_point_transform(&p2, transform, p2.x, p2.y); + p1.x -= (p.x + p2.x) * 0.25f; + p1.y -= (p.y + p2.y) * 0.25f; + d2d_rect_get_bezier_bounds(&bezier_bounds, &p, &p1, &p2); d2d_rect_union(bounds, &bezier_bounds); p = p2; @@ -3250,10 +3285,19 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_GetBounds(ID2D1PathGeometry * if (d2d_vertex_type_is_bezier(type)) { + /* FIXME: This attempts to approximate a cubic Bézier with + * a quadratic one. */ p1 = figure->original_bezier_controls[bezier_idx++]; d2d_point_transform(&p1, transform, p1.x, p1.y); + p2 = figure->original_bezier_controls[bezier_idx++]; + d2d_point_transform(&p2, transform, p2.x, p2.y); + p1.x = (p1.x + p2.x) * 0.75f; + p1.y = (p1.y + p2.y) * 0.75f; p2 = figure->vertices[0]; d2d_point_transform(&p2, transform, p2.x, p2.y); + p1.x -= (p.x + p2.x) * 0.25f; + p1.y -= (p.y + p2.y) * 0.25f; + d2d_rect_get_bezier_bounds(&bezier_bounds, &p, &p1, &p2); d2d_rect_union(bounds, &bezier_bounds); } @@ -3367,22 +3411,6 @@ static void d2d_geometry_flatten_cubic(ID2D1SimplifiedGeometrySink *sink, const ID2D1SimplifiedGeometrySink_SetSegmentFlags(sink, D2D1_PATH_SEGMENT_NONE); } -static void d2d_geometry_simplify_quadratic(ID2D1SimplifiedGeometrySink *sink, - D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_POINT_2F *p0, - const D2D1_POINT_2F *p1, const D2D1_POINT_2F *p2, float tolerance) -{ - D2D1_BEZIER_SEGMENT b; - - d2d_point_lerp(&b.point1, p0, p1, 2.0f / 3.0f); - d2d_point_lerp(&b.point2, p2, p1, 2.0f / 3.0f); - b.point3 = *p2; - - if (option == D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES) - d2d_geometry_flatten_cubic(sink, p0, &b, tolerance); - else - ID2D1SimplifiedGeometrySink_AddBeziers(sink, &b, 1); -} - static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Simplify(ID2D1PathGeometry *iface, D2D1_GEOMETRY_SIMPLIFICATION_OPTION option, const D2D1_MATRIX_3X2_F *transform, float tolerance, ID2D1SimplifiedGeometrySink *sink) @@ -3391,8 +3419,9 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Simplify(ID2D1PathGeometry *i enum d2d_vertex_type type = D2D_VERTEX_TYPE_NONE; unsigned int i, j, bezier_idx; D2D1_FIGURE_BEGIN begin; - D2D1_POINT_2F p, p1, p2; + D2D1_BEZIER_SEGMENT b; D2D1_FIGURE_END end; + D2D1_POINT_2F p; TRACE("iface %p, option %#x, transform %p, tolerance %.8e, sink %p.\n", iface, option, transform, tolerance, sink); @@ -3432,14 +3461,21 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Simplify(ID2D1PathGeometry *i break; case D2D_VERTEX_TYPE_BEZIER: - p1 = figure->original_bezier_controls[bezier_idx++]; + b.point1 = figure->original_bezier_controls[bezier_idx++]; + b.point2 = figure->original_bezier_controls[bezier_idx++]; + b.point3 = figure->vertices[j]; if (transform) - d2d_point_transform(&p1, transform, p1.x, p1.y); - p2 = figure->vertices[j]; - if (transform) - d2d_point_transform(&p2, transform, p2.x, p2.y); - d2d_geometry_simplify_quadratic(sink, option, &p, &p1, &p2, tolerance); - p = p2; + { + d2d_point_transform(&b.point1, transform, b.point1.x, b.point1.y); + d2d_point_transform(&b.point2, transform, b.point2.x, b.point2.y); + d2d_point_transform(&b.point3, transform, b.point3.x, b.point3.y); + } + + if (option == D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES) + d2d_geometry_flatten_cubic(sink, &p, &b, tolerance); + else + ID2D1SimplifiedGeometrySink_AddBeziers(sink, &b, 1); + p = b.point3; break; default: @@ -3456,13 +3492,20 @@ static HRESULT STDMETHODCALLTYPE d2d_path_geometry_Simplify(ID2D1PathGeometry *i if (d2d_vertex_type_is_bezier(type)) { - p1 = figure->original_bezier_controls[bezier_idx++]; + b.point1 = figure->original_bezier_controls[bezier_idx++]; + b.point2 = figure->original_bezier_controls[bezier_idx++]; + b.point3 = figure->vertices[0]; if (transform) - d2d_point_transform(&p1, transform, p1.x, p1.y); - p2 = figure->vertices[0]; - if (transform) - d2d_point_transform(&p2, transform, p2.x, p2.y); - d2d_geometry_simplify_quadratic(sink, option, &p, &p1, &p2, tolerance); + { + d2d_point_transform(&b.point1, transform, b.point1.x, b.point1.y); + d2d_point_transform(&b.point2, transform, b.point2.x, b.point2.y); + d2d_point_transform(&b.point3, transform, b.point3.x, b.point3.y); + } + + if (option == D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES) + d2d_geometry_flatten_cubic(sink, &p, &b, tolerance); + else + ID2D1SimplifiedGeometrySink_AddBeziers(sink, &b, 1); } end = figure->flags & D2D_FIGURE_FLAG_CLOSED ? D2D1_FIGURE_END_CLOSED : D2D1_FIGURE_END_OPEN; -- 2.30.2

1 0