May 2018 - Wine-devel - list.winehq.org

[PATCH v2] comctl32/edit/tests: Add interactive test showing a rendering glitch
by Fabian Maurer 06 Jun '18

06 Jun '18

v2: Only run test when WINETEST_INTERACTIVE is set Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/comctl32/tests/edit.c | 35 +++++++++++++++++++++++++++++++++++ dlls/comctl32/tests/rsrc.rc | 12 ++++++++++++ 2 files changed, 47 insertions(+) diff --git a/dlls/comctl32/tests/edit.c b/dlls/comctl32/tests/edit.c index 7e9e7e7634..fa8ded377d 100644 --- a/dlls/comctl32/tests/edit.c +++ b/dlls/comctl32/tests/edit.c @@ -3094,6 +3094,36 @@ static void test_change_focus(void) DestroyWindow(hwnd); } +static INT_PTR CALLBACK dialog_proc_interactive(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam) +{ + switch (msg) + { + case WM_COMMAND: + if (HIWORD(wparam) == BN_CLICKED) + { + EndDialog(hdlg, LOWORD(wparam)); + } + break; + case WM_CLOSE: + EndDialog(hdlg, IDCANCEL); + break; + + default: + break; + } + + return FALSE; +} + +static void test_rendering_interactive(void) +{ + int button_clicked; + + button_clicked = DialogBoxParamA(GetModuleHandleA(NULL), "EDIT_OVERLAPPING_LABEL", NULL, dialog_proc_interactive, 0); + todo_wine + ok(button_clicked == IDOK, "Interactive test 'edit overlapping label' failed.\n"); +} + START_TEST(edit) { ULONG_PTR ctx_cookie; @@ -3139,6 +3169,11 @@ START_TEST(edit) test_wordbreak_proc(); test_change_focus(); + if (winetest_interactive) + { + test_rendering_interactive(); + } + UnregisterWindowClasses(); unload_v6_module(ctx_cookie, hCtx); diff --git a/dlls/comctl32/tests/rsrc.rc b/dlls/comctl32/tests/rsrc.rc index 327aa225e1..959130e2f1 100644 --- a/dlls/comctl32/tests/rsrc.rc +++ b/dlls/comctl32/tests/rsrc.rc @@ -78,6 +78,18 @@ FONT 8, "MS Shell Dlg" { } +EDIT_OVERLAPPING_LABEL DIALOG 0, 0, 200, 80 +STYLE WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | DS_CENTER +CAPTION "Does the edit box look alright?" +FONT 8, "MS Shell Dlg" +{ + LTEXT "Title:", -1, 5, 5, 70, 15, BS_CENTER + EDITTEXT 1000, 60, 5, 450, 15, WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_WANTRETURN + + PUSHBUTTON "OK", IDOK, 20, 60, 50, 14, WS_CHILD | WS_VISIBLE | WS_TABSTOP + PUSHBUTTON "Broken", IDNO, 100, 60, 50, 14, WS_CHILD | WS_VISIBLE | WS_TABSTOP +} + STRINGTABLE { IDS_TBADD1 "abc" -- 2.17.1

3 4

[PATCH 1/4 v4] riched20/tests: Rewrite tests for ITextServices_TxGetNaturalSize().
by Jactry Zeng 06 Jun '18

06 Jun '18

Signed-off-by: Jactry Zeng <jzeng(a)codeweavers.com> --- dlls/riched20/tests/Makefile.in | 2 +- dlls/riched20/tests/txtsrv.c | 189 ++++++++++++++++++++++++++-------------- 2 files changed, 126 insertions(+), 65 deletions(-) diff --git a/dlls/riched20/tests/Makefile.in b/dlls/riched20/tests/Makefile.in index 34c00afa7c..ca381d9dc2 100644 --- a/dlls/riched20/tests/Makefile.in +++ b/dlls/riched20/tests/Makefile.in @@ -1,5 +1,5 @@ TESTDLL = riched20.dll -IMPORTS = ole32 oleaut32 user32 gdi32 +IMPORTS = ole32 oleaut32 user32 gdi32 usp10 C_SRCS = \ editor.c \ diff --git a/dlls/riched20/tests/txtsrv.c b/dlls/riched20/tests/txtsrv.c index 88b5adf13c..76b4eb34f6 100644 --- a/dlls/riched20/tests/txtsrv.c +++ b/dlls/riched20/tests/txtsrv.c @@ -37,6 +37,7 @@ #include <wine/test.h> #include <oleauto.h> #include <limits.h> +#include <usp10.h> static HMODULE hmoduleRichEdit; static IID *pIID_ITextServices; @@ -697,81 +698,141 @@ static void test_TxSetText(void) ITextHost_Release(host); } +static void hf_from_cf(HFONT *hf, CHARFORMAT2W cf) +{ + LOGFONTW lf; + + memset(&lf, 0, sizeof(lf)); + lstrcpyW(lf.lfFaceName, cf.szFaceName); + lf.lfHeight = MulDiv(-cf.yHeight, GetDeviceCaps(GetDC(NULL), LOGPIXELSY), 1440); + lf.lfWeight = FW_NORMAL; + if (cf.dwEffects & cf.dwMask & CFM_BOLD) + lf.lfWeight = FW_BOLD; + if (cf.dwMask & CFM_WEIGHT) + lf.lfWeight = cf.wWeight; + if (cf.dwEffects & cf.dwMask & CFM_ITALIC) + lf.lfItalic = TRUE; + if ((cf.dwEffects & cf.dwMask & CFM_UNDERLINE) && + !(cf.dwEffects & CFE_LINK) && + cf.bUnderlineType == CFU_CF1UNDERLINE) + lf.lfUnderline = TRUE; + if (cf.dwEffects & cf.dwMask & CFM_STRIKEOUT) + lf.lfStrikeOut = TRUE; + if (cf.dwEffects & cf.dwMask & (CFM_SUBSCRIPT | CFM_SUPERSCRIPT)) + lf.lfHeight = (lf.lfHeight * 2) / 3; + if (cf.dwMask & CFM_FACE) + lf.lfPitchAndFamily = cf.bPitchAndFamily; + if (cf.dwMask & CFM_CHARSET) + lf.lfCharSet = cf.bCharSet; + *hf = CreateFontIndirectW(&lf); +} + +static LONG get_max_width(HDC hdc, LPCWSTR string, LONG avail_width, LONG *lines) +{ + SCRIPT_ITEM buf[16], *items = buf; + LONG items_passed = sizeof(buf) / sizeof(buf[0]), num_items; + SCRIPT_CONTROL control = {LANG_USER_DEFAULT, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, + FALSE, FALSE, 0}; + SCRIPT_STATE state = {0, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 0, 0}; + SCRIPT_CACHE script_cache = NULL; + LONG max_glyphs = 1.5 * lstrlenW(string) + 16; + LONG max_clusters = lstrlenW(string) * 2; + WORD *clusters = HeapAlloc(GetProcessHeap(), 0, max_clusters * sizeof(WORD)); + WORD *glyphs = HeapAlloc(GetProcessHeap(), 0, max_glyphs * + (sizeof(WORD) + sizeof(SCRIPT_VISATTR) + sizeof(LONG) + sizeof(GOFFSET))); + SCRIPT_VISATTR *vis_attrs = (SCRIPT_VISATTR *)((char *)glyphs + max_glyphs * sizeof(WORD)); + GOFFSET *offsets = (GOFFSET *)((char *)glyphs + max_glyphs * (sizeof(WORD) + sizeof(SCRIPT_VISATTR) + + sizeof(LONG))); + LONG num_glyphs = 0; + LONG *advances = (LONG *)((char *)glyphs + max_glyphs * (sizeof(WORD) + sizeof(SCRIPT_VISATTR))); + LONG i, width = 0, max_width = 0; + + ScriptItemize(string, lstrlenW(string), items_passed, &control, &state, items, &num_items); + ScriptShape(hdc, &script_cache, string, lstrlenW(string), max_glyphs, &items[0].a, glyphs, + clusters, vis_attrs, &num_glyphs); + ScriptPlace(hdc, &script_cache, glyphs, num_glyphs, vis_attrs, &items[0].a, advances, offsets, + NULL); + + *lines = 1; + for (i = 0; i < num_glyphs; i++) + { + width += advances[i]; + if (width >= avail_width) + { + (*lines)++; + width -= advances[i]; + if (width > max_width) + max_width = width; + width = advances[i]; + } + if (width > max_width) + max_width = width; + } + HeapFree(GetProcessHeap(), 0, clusters); + HeapFree(GetProcessHeap(), 0, glyphs); + return max_width; +} + +#define CHECK_TXGETNATURALSIZE(res,width,height,expected_width,expected_height) \ + _check_txgetnaturalsize(res, width, height, expected_width, expected_height, __LINE__) +static void _check_txgetnaturalsize(HRESULT res, LONG width, LONG height, LONG expected_width, + LONG expected_height, int line) +{ + ok_(__FILE__,line)(res == S_OK, "TxGetNaturalSize failed: 0x%08x.\n", res); + ok_(__FILE__,line)(width >= expected_width && width <= expected_width + 1, + "got wrong width: %d, expected: %d {+1}.\n", width, expected_width); + ok_(__FILE__,line)(height == expected_height, "got wrong height: %d, expected: %d.\n", + height, expected_height); +} + static void test_TxGetNaturalSize(void) { ITextServices *txtserv; ITextHost *host; HRESULT result; - BOOL ret; - - /* This value is used when calling TxGetNaturalSize. MSDN says - that this is not supported however a null pointer cannot be - used as it will cause a segmentation violation. The values in - the structure being pointed to are required to be INT_MAX - otherwise calculations can give wrong values. */ - const SIZEL psizelExtent = {INT_MAX,INT_MAX}; - - static const WCHAR oneA[] = {'A',0}; - - /* Results of measurements */ - LONG xdim, ydim; - - /* The device context to do the tests in */ + SIZEL psizelExtent = {-1,-1}; + static const WCHAR test_text[] = {'T','e','s','t','S','o','m','e','T','e','x','t',0}; + LONG width, height, expected_width, expected_height, lines; HDC hdcDraw; - - /* Variables with the text metric information */ - INT charwidth_caps_text[26]; - TEXTMETRICA tmInfo_text; + HWND hwnd; + RECT rect; + CHARFORMAT2W cf; + LRESULT lresult; + HFONT hf, old_hf; + TEXTMETRICA tm; if (!init_texthost(&txtserv, &host)) return; - hdcDraw = GetDC(NULL); - SaveDC(hdcDraw); - - /* Populate the metric strucs */ - SetMapMode(hdcDraw,MM_TEXT); - GetTextMetricsA(hdcDraw, &tmInfo_text); - SetLastError(0xdeadbeef); - ret = GetCharWidth32A(hdcDraw,'A','Z',charwidth_caps_text); - if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) { - win_skip("GetCharWidth32 is not available\n"); - goto cleanup; - } - - /* Make measurements in MM_TEXT */ + hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP | WS_VISIBLE, + 0, 0, 100, 100, 0, 0, 0, NULL); + hdcDraw = GetDC(hwnd); SetMapMode(hdcDraw,MM_TEXT); - xdim = 0; ydim = 0; - - result = ITextServices_TxSetText(txtserv, oneA); - ok(result == S_OK, "ITextServices_TxSetText failed (result = %x)\n", result); - if (result != S_OK) { - skip("Could not set text\n"); - goto cleanup; - } - - SetLastError(0xdeadbeef); - result = ITextServices_TxGetNaturalSize(txtserv, DVASPECT_CONTENT, - hdcDraw, NULL, NULL, - TXTNS_FITTOCONTENT, &psizelExtent, - &xdim, &ydim); - todo_wine ok(result == S_OK || broken(result == E_FAIL), /* WINXP Arabic Language */ - "TxGetNaturalSize gave unexpected return value (result = %x)\n", result); - if (result == S_OK) { - todo_wine ok(ydim == tmInfo_text.tmHeight, - "Height calculated incorrectly (expected %d, got %d)\n", - tmInfo_text.tmHeight, ydim); - /* The native DLL adds one pixel extra when calculating widths. */ - todo_wine ok(xdim >= charwidth_caps_text[0] && xdim <= charwidth_caps_text[0] + 1, - "Width calculated incorrectly (expected %d {+1}, got %d)\n", - charwidth_caps_text[0], xdim); - } else - skip("TxGetNaturalSize measurements not performed (xdim = %d, ydim = %d, result = %x, error = %x)\n", - xdim, ydim, result, GetLastError()); - -cleanup: - RestoreDC(hdcDraw,1); - ReleaseDC(NULL,hdcDraw); + GetClientRect(hwnd, &rect); + + result = ITextServices_TxSetText(txtserv, test_text); + ok(result == S_OK, "ITextServices_TxSetText failed: 0x%08x.\n", result); + + cf.cbSize = sizeof(cf); + result = ITextServices_TxSendMessage(txtserv, EM_GETCHARFORMAT, SCF_DEFAULT, (LPARAM)&cf, &lresult); + ok(result == S_OK, "ITextServices_TxSendMessage failed: 0x%08x.\n", result); + hf_from_cf(&hf, cf); + + old_hf = SelectObject(hdcDraw, hf); + expected_width = get_max_width(hdcDraw, test_text, rect.right - rect.left, &lines); + GetTextMetricsA(hdcDraw, &tm); + expected_height = (tm.tmAscent + tm.tmDescent) * lines; + SelectObject(hdcDraw, old_hf); + + psizelExtent.cx = -1; psizelExtent.cy = -1; + width = rect.right - rect.left; + height = 0; + result = ITextServices_TxGetNaturalSize(txtserv, DVASPECT_CONTENT, hdcDraw, NULL, NULL, + TXTNS_FITTOCONTENT, &psizelExtent, &width, &height); + todo_wine CHECK_TXGETNATURALSIZE(result, width, height, expected_width, expected_height); + + ReleaseDC(hwnd, hdcDraw); + DestroyWindow(hwnd); ITextServices_Release(txtserv); ITextHost_Release(host); } -- 2.15.1 (Apple Git-101)

3 2

[resend PATCH 1/2] include: Add ID2D1DeviceContext definition.
by Nikolay Sivov 03 Jun '18

03 Jun '18

From: Lucian Poston <lucian.poston(a)gmail.com> Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- Same patch, resending. include/d2d1_1.idl | 284 ++++++++++++++++++++++++++++++++++++++++++++ include/dcommon.idl | 20 ++++ 2 files changed, 304 insertions(+) diff --git a/include/d2d1_1.idl b/include/d2d1_1.idl index 4b6224afe3..4d30f6fd34 100644 --- a/include/d2d1_1.idl +++ b/include/d2d1_1.idl @@ -27,7 +27,18 @@ interface ID2D1Properties; interface IPrintDocumentPackageTarget; interface ID2D1PrintControl; interface IWICImagingFactory; +interface IWICColorContext; interface ID2D1ColorContext; +interface ID2D1Effect; +interface ID2D1GradientStopCollection1; +interface ID2D1ImageBrush; +interface ID2D1BitmapBrush1; +interface ID2D1CommandList; + +cpp_quote("#ifndef __dwrite_h__") +/* already defined in dwrite.h but needed for WIDL */ +typedef struct DWRITE_GLYPH_RUN_DESCRIPTION DWRITE_GLYPH_RUN_DESCRIPTION; +cpp_quote("#endif /* __dwrite_h__ */") typedef enum D2D1_DEVICE_CONTEXT_OPTIONS { @@ -96,7 +107,63 @@ typedef enum D2D1_MAP_OPTIONS D2D1_MAP_OPTIONS_FORCE_DWORD = 0xffffffff, } D2D1_MAP_OPTIONS; +typedef enum D2D1_BUFFER_PRECISION +{ + D2D1_BUFFER_PRECISION_UNKNOWN = 0, + D2D1_BUFFER_PRECISION_8BPC_UNORM = 1, + D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB = 2, + D2D1_BUFFER_PRECISION_16BPC_UNORM = 3, + D2D1_BUFFER_PRECISION_16BPC_FLOAT = 4, + D2D1_BUFFER_PRECISION_32BPC_FLOAT = 5, + D2D1_BUFFER_PRECISION_FORCE_DWORD = 0xffffffff, +} D2D1_BUFFER_PRECISION; + +typedef enum D2D1_COLOR_INTERPOLATION_MODE +{ + D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT = 0, + D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED = 1, + D2D1_COLOR_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_COLOR_INTERPOLATION_MODE; + +typedef enum D2D1_INTERPOLATION_MODE +{ + D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR, + D2D1_INTERPOLATION_MODE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR, + D2D1_INTERPOLATION_MODE_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC, + D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR, + D2D1_INTERPOLATION_MODE_ANISOTROPIC = D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC, + D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC, + D2D1_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_INTERPOLATION_MODE; + +typedef enum D2D1_COMPOSITE_MODE +{ + D2D1_COMPOSITE_MODE_SOURCE_OVER = 0, + D2D1_COMPOSITE_MODE_DESTINATION_OVER = 1, + D2D1_COMPOSITE_MODE_SOURCE_IN = 2, + D2D1_COMPOSITE_MODE_DESTINATION_IN = 3, + D2D1_COMPOSITE_MODE_SOURCE_OUT = 4, + D2D1_COMPOSITE_MODE_DESTINATION_OUT = 5, + D2D1_COMPOSITE_MODE_SOURCE_ATOP = 6, + D2D1_COMPOSITE_MODE_DESTINATION_ATOP = 7, + D2D1_COMPOSITE_MODE_XOR = 8, + D2D1_COMPOSITE_MODE_PLUS = 9, + D2D1_COMPOSITE_MODE_SOURCE_COPY = 10, + D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY = 11, + D2D1_COMPOSITE_MODE_MASK_INVERT = 12, + D2D1_COMPOSITE_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_COMPOSITE_MODE; + +typedef enum D2D1_LAYER_OPTIONS1 +{ + D2D1_LAYER_OPTIONS1_NONE = 0, + D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND = 1, + D2D1_LAYER_OPTIONS1_IGNORE_ALPHA = 2, + D2D1_LAYER_OPTIONS1_FORCE_DWORD = 0xffffffff, +} D2D1_LAYER_OPTIONS1; + typedef struct D2D1_PROPERTY_BINDING D2D1_PROPERTY_BINDING; +typedef D2D_MATRIX_4X4_F D2D1_MATRIX_4X4_F; typedef struct D2D1_STROKE_STYLE_PROPERTIES1 { @@ -134,6 +201,54 @@ typedef struct D2D1_MAPPED_RECT BYTE *bits; } D2D1_MAPPED_RECT; +typedef struct D2D1_BITMAP_PROPERTIES1 +{ + D2D1_PIXEL_FORMAT pixelFormat; + float dpiX; + float dpiY; + D2D1_BITMAP_OPTIONS bitmapOptions; + ID2D1ColorContext *colorContext; +} D2D1_BITMAP_PROPERTIES1; + +typedef struct D2D1_IMAGE_BRUSH_PROPERTIES +{ + D2D1_RECT_F sourceRectangle; + D2D1_EXTEND_MODE extendModeX; + D2D1_EXTEND_MODE extendModeY; + D2D1_INTERPOLATION_MODE interpolationMode; +} D2D1_IMAGE_BRUSH_PROPERTIES; + +typedef struct D2D1_BITMAP_BRUSH_PROPERTIES1 +{ + D2D1_EXTEND_MODE extendModeX; + D2D1_EXTEND_MODE extendModeY; + D2D1_INTERPOLATION_MODE interpolationMode; +} D2D1_BITMAP_BRUSH_PROPERTIES1; + +typedef struct D2D1_RENDERING_CONTROLS +{ + D2D1_BUFFER_PRECISION bufferPrecision; + D2D1_SIZE_U tileSize; +} D2D1_RENDERING_CONTROLS; + +typedef struct D2D1_LAYER_PARAMETERS1 +{ + D2D1_RECT_F contentBounds; + ID2D1Geometry *geometricMask; + D2D1_ANTIALIAS_MODE maskAntialiasMode; + D2D1_MATRIX_3X2_F maskTransform; + float opacity; + ID2D1Brush *opacityBrush; + D2D1_LAYER_OPTIONS1 layerOptions; +} D2D1_LAYER_PARAMETERS1; + +typedef struct D2D1_EFFECT_INPUT_DESCRIPTION +{ + ID2D1Effect *effect; + UINT32 inputIndex; + D2D1_RECT_F inputRectangle; +} D2D1_EFFECT_INPUT_DESCRIPTION; + typedef HRESULT (__stdcall *PD2D1_EFFECT_FACTORY)(IUnknown **effect); [ @@ -183,6 +298,175 @@ interface ID2D1Device : ID2D1Resource ); } +[ + object, + uuid(e8f7fe7a-191c-466d-ad95-975678bda998), + local, +] +interface ID2D1DeviceContext : ID2D1RenderTarget +{ + HRESULT CreateBitmap( + [in] D2D1_SIZE_U size, + [in] const void *src_data, + [in] UINT32 pitch, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateBitmapFromWicBitmap( + [in] IWICBitmapSource *bitmap_source, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateColorContext( + [in] D2D1_COLOR_SPACE space, + [in] const BYTE *profile, + [in] UINT32 profile_size, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromFilename( + [in] const WCHAR *filename, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromWicColorContext( + [in] IWICColorContext *wic_color_context, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateBitmapFromDxgiSurface( + [in] IDXGISurface *surface, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateEffect( + [in] REFCLSID effect_id, + [out] ID2D1Effect **effect + ); + HRESULT CreateGradientStopCollection( + [in] const D2D1_GRADIENT_STOP *stops, + [in] UINT32 stop_count, + [in] D2D1_COLOR_SPACE preinterpolation_space, + [in] D2D1_COLOR_SPACE postinterpolation_space, + [in] D2D1_BUFFER_PRECISION buffer_precision, + [in] D2D1_EXTEND_MODE extend_mode, + [in] D2D1_COLOR_INTERPOLATION_MODE color_interpolation_mode, + [out] ID2D1GradientStopCollection1 **gradient + ); + HRESULT CreateImageBrush( + [in] ID2D1Image *image, + [in] const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [out] ID2D1ImageBrush **brush + ); + HRESULT CreateBitmapBrush( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [out] ID2D1BitmapBrush1 **bitmap_brush + ); + HRESULT CreateCommandList( + [out] ID2D1CommandList **command_list + ); + BOOL IsDxgiFormatSupported( + [in] DXGI_FORMAT format + ); + BOOL IsBufferPrecisionSupported( + [in] D2D1_BUFFER_PRECISION buffer_precision + ); + void GetImageLocalBounds( + [in] ID2D1Image *image, + [out] D2D1_RECT_F *local_bounds + ); + HRESULT GetImageWorldBounds( + [in] ID2D1Image *image, + [out] D2D1_RECT_F *world_bounds + ); + HRESULT GetGlyphRunWorldBounds( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] DWRITE_MEASURING_MODE measuring_mode, + [out] D2D1_RECT_F *bounds + ); + void GetDevice( + [out] ID2D1Device **device + ); + void SetTarget( + [in] ID2D1Image *target + ); + void GetTarget( + [out] ID2D1Image **target + ); + void SetRenderingControls( + [in] const D2D1_RENDERING_CONTROLS *rendering_controls + ); + void GetRenderingControls( + [out] D2D1_RENDERING_CONTROLS *rendering_controls + ); + void SetPrimitiveBlend( + [in] D2D1_PRIMITIVE_BLEND primitive_blend + ); + D2D1_PRIMITIVE_BLEND GetPrimitiveBlend(); + void SetUnitMode( + [in] D2D1_UNIT_MODE unit_mode + ); + D2D1_UNIT_MODE GetUnitMode(); + void DrawGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, + [in] ID2D1Brush *brush, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + void DrawImage( + [in] ID2D1Image *image, + [in] const D2D1_POINT_2F *target_offset, + [in] const D2D1_RECT_F *image_rect, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] D2D1_COMPOSITE_MODE composite_mode + ); + void DrawGdiMetafile( + [in] ID2D1GdiMetafile *metafile, + [in] const D2D1_POINT_2F *target_offset + ); + void DrawBitmap( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_RECT_F *dst_rect, + [in] float opacity, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] const D2D1_RECT_F *src_rect, + [in] const D2D1_MATRIX_4X4_F *perspective_transform + ); + void PushLayer( + [in] const D2D1_LAYER_PARAMETERS1 *layer_parameters, + [in] ID2D1Layer *layer + ); + HRESULT InvalidateEffectInputRectangle( + [in] ID2D1Effect *effect, + [in] UINT32 input, + [in] const D2D1_RECT_F *input_rect + ); + HRESULT GetEffectInvalidRectangleCount( + [in] ID2D1Effect *effect, + [out] UINT32 *rect_count + ); + HRESULT GetEffectInvalidRectangles( + [in] ID2D1Effect *effect, + [out] D2D1_RECT_F *rectangles, + [in] UINT32 rect_count + ); + HRESULT GetEffectRequiredInputRectangles( + [in] ID2D1Effect *effect, + [in] const D2D1_RECT_F *image_rect, + [in] const D2D1_EFFECT_INPUT_DESCRIPTION *desc, + [out] D2D1_RECT_F *input_rect, + [in] UINT32 input_count + ); + void FillOpacityMask( + [in] ID2D1Bitmap *mask, + [in] ID2D1Brush *brush, + [in] const D2D1_RECT_F *dst_rect, + [in] const D2D1_RECT_F *src_rect + ); +} + [ object, uuid(bb12d362-daee-4b9a-aa1d-14ba401cfa1f), diff --git a/include/dcommon.idl b/include/dcommon.idl index db5055d202..e651a75d0e 100644 --- a/include/dcommon.idl +++ b/include/dcommon.idl @@ -61,3 +61,23 @@ typedef struct D2D_SIZE_U UINT32 width; UINT32 height; } D2D_SIZE_U, D2D1_SIZE_U; + +typedef struct D2D_MATRIX_4X4_F +{ + float _11; + float _12; + float _13; + float _14; + float _21; + float _22; + float _23; + float _24; + float _31; + float _32; + float _33; + float _34; + float _41; + float _42; + float _43; + float _44; +} D2D_MATRIX_4X4_F; -- 2.17.0

3 5

[PATCH 1/2] msvcrt: Avoid using inline assembly in __ExceptionPtrDestroy().
by Zebediah Figura 01 Jun '18

01 Jun '18

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/msvcrt/cpp.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/dlls/msvcrt/cpp.c b/dlls/msvcrt/cpp.c index 07cde75..3402d13 100644 --- a/dlls/msvcrt/cpp.c +++ b/dlls/msvcrt/cpp.c @@ -1718,10 +1718,12 @@ void __cdecl __ExceptionPtrCreate(exception_ptr *ep) } #ifdef __i386__ -static inline void call_dtor(const cxx_exception_type *type, void *func, void *object) -{ - __asm__ __volatile__("call *%0" : : "m" (func), "c" (object) : "eax", "edx", "memory"); -} +extern void call_dtor(const cxx_exception_type *type, void *func, void *object); + +__ASM_GLOBAL_FUNC( call_dtor, + "movl 12(%esp),%ecx\n\t" + "call *8(%esp)\n\t" + "ret" ); #elif __x86_64__ static inline void call_dtor(const cxx_exception_type *type, unsigned int dtor, void *object) { -- 2.7.4

3 4

[PATCH 1/4] dbghelp: Don't enforce child architecture in elf_map_file().
by Zebediah Figura 31 May '18

31 May '18

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/dbghelp/elf_module.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/dlls/dbghelp/elf_module.c b/dlls/dbghelp/elf_module.c index e047a7f..e4689a7 100644 --- a/dlls/dbghelp/elf_module.c +++ b/dlls/dbghelp/elf_module.c @@ -346,12 +346,7 @@ static BOOL elf_map_file(struct elf_map_file_data* emfd, struct image_file_map* /* and check for an ELF header */ if (memcmp(fmap->u.elf.elfhdr.e_ident, elf_signature, sizeof(elf_signature))) goto done; - /* and check 32 vs 64 size according to current machine */ -#ifdef _WIN64 - if (fmap->u.elf.elfhdr.e_ident[EI_CLASS] != ELFCLASS64) goto done; -#else - if (fmap->u.elf.elfhdr.e_ident[EI_CLASS] != ELFCLASS32) goto done; -#endif + fmap->addr_size = fmap->u.elf.elfhdr.e_ident[EI_CLASS] == ELFCLASS64 ? 64 : 32; fmap->u.elf.sect = HeapAlloc(GetProcessHeap(), 0, fmap->u.elf.elfhdr.e_shnum * sizeof(fmap->u.elf.sect[0])); -- 2.7.4

1 3

[PATCH 12/17] shdocvw/tests: Use the available ARRAY_SIZE() macro
by Michael Stefaniuc 31 May '18

31 May '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/shdocvw/tests/shdocvw.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/shdocvw/tests/shdocvw.c b/dlls/shdocvw/tests/shdocvw.c index 7b4eccf27c..d54cf1613a 100644 --- a/dlls/shdocvw/tests/shdocvw.c +++ b/dlls/shdocvw/tests/shdocvw.c @@ -207,7 +207,7 @@ static void test_ParseURLFromOutsideSourceA(void) return; } - for(i = 0; i < sizeof(ParseURL_table)/sizeof(ParseURL_table[0]); i++) { + for(i = 0; i < ARRAY_SIZE(ParseURL_table); i++) { memset(buffer, '#', sizeof(buffer)-1); buffer[sizeof(buffer)-1] = '\0'; len = sizeof(buffer); @@ -306,7 +306,7 @@ static void test_ParseURLFromOutsideSourceW(void) MultiByteToWideChar(CP_ACP, 0, bufferA, -1, bufferW, INTERNET_MAX_URL_LENGTH); /* len is in characters */ - len = sizeof(bufferW)/sizeof(bufferW[0]); + len = ARRAY_SIZE(bufferW); dummy = 0; res = pParseURLFromOutsideSourceW(urlW, bufferW, &len, &dummy); WideCharToMultiByte(CP_ACP, 0, bufferW, -1, bufferA, sizeof(bufferA), NULL, NULL); -- 2.14.3

2 1

[PATCH] comctl32/edit/tests: Add interactive test showing a rendering glitch
by Fabian Maurer 31 May '18

31 May '18

Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/comctl32/tests/edit.c | 32 ++++++++++++++++++++++++++++++++ dlls/comctl32/tests/rsrc.rc | 12 ++++++++++++ 2 files changed, 44 insertions(+) diff --git a/dlls/comctl32/tests/edit.c b/dlls/comctl32/tests/edit.c index 7e9e7e7634..76397ac92f 100644 --- a/dlls/comctl32/tests/edit.c +++ b/dlls/comctl32/tests/edit.c @@ -3094,6 +3094,36 @@ static void test_change_focus(void) DestroyWindow(hwnd); } +static INT_PTR CALLBACK dialog_proc_interactive(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam) +{ + switch (msg) + { + case WM_COMMAND: + if (HIWORD(wparam) == BN_CLICKED) + { + EndDialog(hdlg, LOWORD(wparam)); + } + break; + case WM_CLOSE: + EndDialog(hdlg, IDCANCEL); + break; + + default: + break; + } + + return FALSE; +} + +static void test_rendering_interactive(void) +{ + int button_clicked; + + button_clicked = DialogBoxParamA(GetModuleHandleA(NULL), "EDIT_OVERLAPPING_LABEL", NULL, dialog_proc_interactive, 0); + todo_wine + ok(button_clicked == IDOK, "Interactive test 'edit overlapping label' failed.\n"); +} + START_TEST(edit) { ULONG_PTR ctx_cookie; @@ -3139,6 +3169,8 @@ START_TEST(edit) test_wordbreak_proc(); test_change_focus(); + test_rendering_interactive(); + UnregisterWindowClasses(); unload_v6_module(ctx_cookie, hCtx); diff --git a/dlls/comctl32/tests/rsrc.rc b/dlls/comctl32/tests/rsrc.rc index 327aa225e1..959130e2f1 100644 --- a/dlls/comctl32/tests/rsrc.rc +++ b/dlls/comctl32/tests/rsrc.rc @@ -78,6 +78,18 @@ FONT 8, "MS Shell Dlg" { } +EDIT_OVERLAPPING_LABEL DIALOG 0, 0, 200, 80 +STYLE WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | DS_CENTER +CAPTION "Does the edit box look alright?" +FONT 8, "MS Shell Dlg" +{ + LTEXT "Title:", -1, 5, 5, 70, 15, BS_CENTER + EDITTEXT 1000, 60, 5, 450, 15, WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_WANTRETURN + + PUSHBUTTON "OK", IDOK, 20, 60, 50, 14, WS_CHILD | WS_VISIBLE | WS_TABSTOP + PUSHBUTTON "Broken", IDNO, 100, 60, 50, 14, WS_CHILD | WS_VISIBLE | WS_TABSTOP +} + STRINGTABLE { IDS_TBADD1 "abc" -- 2.17.1

2 2

[PATCH 1/2] fc: Add stub program
by Fabian Maurer 31 May '18

31 May '18

Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- configure | 26 ++++++++------------------ configure.ac | 1 + programs/fc/Makefile.in | 4 ++++ programs/fc/fc.c | 33 +++++++++++++++++++++++++++++++++ 4 files changed, 46 insertions(+), 18 deletions(-) create mode 100644 programs/fc/Makefile.in create mode 100644 programs/fc/fc.c diff --git a/configure b/configure index 2960b34c93..ea2d353e5f 100755 --- a/configure +++ b/configure @@ -800,7 +800,6 @@ infodir docdir oldincludedir includedir -runstatedir localstatedir sharedstatedir sysconfdir @@ -1672,6 +1671,7 @@ enable_eject enable_expand enable_explorer enable_extrac32 +enable_fc enable_findstr enable_fsutil enable_hh @@ -1859,7 +1859,6 @@ datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' -runstatedir='${localstatedir}/run' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' @@ -2112,15 +2111,6 @@ do | -silent | --silent | --silen | --sile | --sil) silent=yes ;; - -runstatedir | --runstatedir | --runstatedi | --runstated \ - | --runstate | --runstat | --runsta | --runst | --runs \ - | --run | --ru | --r) - ac_prev=runstatedir ;; - -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ - | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ - | --run=* | --ru=* | --r=*) - runstatedir=$ac_optarg ;; - -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ @@ -2258,7 +2248,7 @@ fi for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ - libdir localedir mandir runstatedir + libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. @@ -2411,7 +2401,6 @@ Fine tuning of the installation directories: --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] - --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] @@ -6623,7 +6612,7 @@ else We can't simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. */ -#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; @@ -6669,7 +6658,7 @@ else We can't simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. */ -#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; @@ -6693,7 +6682,7 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext We can't simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. */ -#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; @@ -6738,7 +6727,7 @@ else We can't simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. */ -#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; @@ -6762,7 +6751,7 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext We can't simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. */ -#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31)) +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; @@ -19373,6 +19362,7 @@ wine_fn_config_makefile programs/eject enable_eject wine_fn_config_makefile programs/expand enable_expand wine_fn_config_makefile programs/explorer enable_explorer wine_fn_config_makefile programs/extrac32 enable_extrac32 +wine_fn_config_makefile programs/fc enable_fc wine_fn_config_makefile programs/findstr enable_findstr wine_fn_config_makefile programs/fsutil enable_fsutil wine_fn_config_makefile programs/hh enable_hh diff --git a/configure.ac b/configure.ac index 3a6a3a1762..a9fffc17c5 100644 --- a/configure.ac +++ b/configure.ac @@ -3875,6 +3875,7 @@ WINE_CONFIG_MAKEFILE(programs/eject) WINE_CONFIG_MAKEFILE(programs/expand) WINE_CONFIG_MAKEFILE(programs/explorer) WINE_CONFIG_MAKEFILE(programs/extrac32) +WINE_CONFIG_MAKEFILE(programs/fc) WINE_CONFIG_MAKEFILE(programs/findstr) WINE_CONFIG_MAKEFILE(programs/fsutil) WINE_CONFIG_MAKEFILE(programs/hh) diff --git a/programs/fc/Makefile.in b/programs/fc/Makefile.in new file mode 100644 index 0000000000..96d878a410 --- /dev/null +++ b/programs/fc/Makefile.in @@ -0,0 +1,4 @@ +MODULE = fc.exe +APPMODE = -mconsole -municode + +C_SRCS = fc.c diff --git a/programs/fc/fc.c b/programs/fc/fc.c new file mode 100644 index 0000000000..ba3b04bda2 --- /dev/null +++ b/programs/fc/fc.c @@ -0,0 +1,33 @@ +/* + * Copyright 2018 Fabian Maurer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(fc); + +int wmain(int argc, WCHAR *argv[]) +{ + int i; + + WINE_FIXME("stub:"); + for (i = 0; i < argc; i++) + WINE_FIXME(" %s", wine_dbgstr_w(argv[i])); + WINE_FIXME("\n"); + + return 0; +} -- 2.17.1

1 1

[PATCH] d3dx10/tests: Use the available ARRAY_SIZE() macro
by Michael Stefaniuc 31 May '18

31 May '18

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/d3dx10_43/tests/d3dx10.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/d3dx10_43/tests/d3dx10.c b/dlls/d3dx10_43/tests/d3dx10.c index 9c84a76e79..2bf92cdb58 100644 --- a/dlls/d3dx10_43/tests/d3dx10.c +++ b/dlls/d3dx10_43/tests/d3dx10.c @@ -269,8 +269,8 @@ float4 main(float4 color : COLOR) : SV_TARGET hr = ID3D10Device_CreatePixelShader(device, simple_ps, sizeof(simple_ps), &ps); ok(SUCCEEDED(hr), "Failed to create pixel shader, hr %#x.\n", hr); - hr = ID3D10Device_CreateInputLayout(device, layout_desc, sizeof(layout_desc) / sizeof(*layout_desc), - simple_vs, sizeof(simple_vs), &input_layout); + hr = ID3D10Device_CreateInputLayout(device, layout_desc, ARRAY_SIZE(layout_desc), simple_vs, + sizeof(simple_vs), &input_layout); ok(SUCCEEDED(hr), "Failed to create input layout, hr %#x.\n", hr); blend_desc.AlphaToCoverageEnable = FALSE; -- 2.14.3

2 1

[PATCH v2 1/8] dxgi: Create Vulkan swapchains for D3D12.
by Józef Kucia 31 May '18

31 May '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- Version 2: Load libvkd3d just before creating a Direct3D 12 swapchain. --- dlls/d3d12/d3d12_main.c | 16 ++ dlls/dxgi/Makefile.in | 3 +- dlls/dxgi/swapchain.c | 502 +++++++++++++++++++++++++++++++++++++++++++++--- 3 files changed, 498 insertions(+), 23 deletions(-) diff --git a/dlls/d3d12/d3d12_main.c b/dlls/d3d12/d3d12_main.c index 71eb1f97a73e..91525b49a790 100644 --- a/dlls/d3d12/d3d12_main.c +++ b/dlls/d3d12/d3d12_main.c @@ -34,6 +34,8 @@ #include <vkd3d.h> +#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) + WINE_DEFAULT_DEBUG_CHANNEL(d3d12); WINE_DECLARE_DEBUG_CHANNEL(winediag); @@ -113,6 +115,16 @@ HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_fe struct vkd3d_device_create_info device_create_info; const struct vulkan_funcs *vk_funcs; + static const char * const instance_extensions[] = + { + VK_KHR_SURFACE_EXTENSION_NAME, + VK_KHR_WIN32_SURFACE_EXTENSION_NAME, + }; + static const char * const device_extensions[] = + { + VK_KHR_SWAPCHAIN_EXTENSION_NAME, + }; + TRACE("adapter %p, minimum_feature_level %#x, iid %s, device %p.\n", adapter, minimum_feature_level, debugstr_guid(iid), device); @@ -132,11 +144,15 @@ HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_fe instance_create_info.wchar_size = sizeof(WCHAR); instance_create_info.pfn_vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)vk_funcs->p_vkGetInstanceProcAddr; + instance_create_info.instance_extensions = instance_extensions; + instance_create_info.instance_extension_count = ARRAY_SIZE(instance_extensions); memset(&device_create_info, 0, sizeof(device_create_info)); device_create_info.type = VKD3D_STRUCTURE_TYPE_DEVICE_CREATE_INFO; device_create_info.minimum_feature_level = minimum_feature_level; device_create_info.instance_create_info = &instance_create_info; + device_create_info.device_extensions = device_extensions; + device_create_info.device_extension_count = ARRAY_SIZE(device_extensions); return vkd3d_create_device(&device_create_info, iid, device); } diff --git a/dlls/dxgi/Makefile.in b/dlls/dxgi/Makefile.in index ce76b8eecc61..c21cb18d8ffc 100644 --- a/dlls/dxgi/Makefile.in +++ b/dlls/dxgi/Makefile.in @@ -1,6 +1,7 @@ MODULE = dxgi.dll IMPORTLIB = dxgi -IMPORTS = dxguid uuid wined3d user32 +IMPORTS = gdi32 dxguid uuid wined3d user32 +EXTRAINCL = $(VKD3D_CFLAGS) C_SRCS = \ adapter.c \ diff --git a/dlls/dxgi/swapchain.c b/dlls/dxgi/swapchain.c index ca4e59004ef2..23731e0dd07b 100644 --- a/dlls/dxgi/swapchain.c +++ b/dlls/dxgi/swapchain.c @@ -22,7 +22,21 @@ #include "dxgi_private.h" +#ifdef SONAME_LIBVKD3D +#define VK_NO_PROTOTYPES +#define VKAPI_CALL +#define VKD3D_NO_PROTOTYPES +#define VKD3D_NO_VULKAN_H +#define VKD3D_NO_WIN32_TYPES +#define WINE_VK_ALIGN(x) +#include "wine/library.h" +#include "wine/vulkan.h" +#include "wine/vulkan_driver.h" +#include <vkd3d.h> +#endif + WINE_DEFAULT_DEBUG_CHANNEL(dxgi); +WINE_DECLARE_DEBUG_CHANNEL(winediag); static inline struct d3d11_swapchain *d3d11_swapchain_from_IDXGISwapChain1(IDXGISwapChain1 *iface) { @@ -797,12 +811,59 @@ HRESULT d3d11_swapchain_create(IWineDXGIDevice *device, HWND window, const DXGI_ return S_OK; } +#ifdef SONAME_LIBVKD3D + +static PFN_vkd3d_acquire_vk_queue vkd3d_acquire_vk_queue; +static PFN_vkd3d_create_image_resource vkd3d_create_image_resource; +static PFN_vkd3d_get_vk_device vkd3d_get_vk_device; +static PFN_vkd3d_get_vk_format vkd3d_get_vk_format; +static PFN_vkd3d_get_vk_physical_device vkd3d_get_vk_physical_device; +static PFN_vkd3d_get_vk_queue_family_index vkd3d_get_vk_queue_family_index; +static PFN_vkd3d_instance_from_device vkd3d_instance_from_device; +static PFN_vkd3d_instance_get_vk_instance vkd3d_instance_get_vk_instance; +static PFN_vkd3d_release_vk_queue vkd3d_release_vk_queue; +static PFN_vkd3d_resource_decref vkd3d_resource_decref; +static PFN_vkd3d_resource_incref vkd3d_resource_incref; + +struct dxgi_vk_funcs +{ + PFN_vkAcquireNextImageKHR p_vkAcquireNextImageKHR; + PFN_vkCreateSwapchainKHR p_vkCreateSwapchainKHR; + PFN_vkCreateWin32SurfaceKHR p_vkCreateWin32SurfaceKHR; + PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR; + PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR; + PFN_vkGetDeviceProcAddr p_vkGetDeviceProcAddr; + PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR p_vkGetPhysicalDeviceSurfaceFormatsKHR; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR p_vkGetPhysicalDeviceSurfacePresentModesKHR; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR p_vkGetPhysicalDeviceSurfaceSupportKHR; + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p_vkGetPhysicalDeviceWin32PresentationSupportKHR; + PFN_vkGetSwapchainImagesKHR p_vkGetSwapchainImagesKHR; + PFN_vkQueuePresentKHR p_vkQueuePresentKHR; + PFN_vkCreateFence p_vkCreateFence; + PFN_vkWaitForFences p_vkWaitForFences; + PFN_vkResetFences p_vkResetFences; + PFN_vkDestroyFence p_vkDestroyFence; +}; + struct d3d12_swapchain { IDXGISwapChain3 IDXGISwapChain3_iface; LONG refcount; struct wined3d_private_store private_store; + VkSwapchainKHR vk_swapchain; + VkSurfaceKHR vk_surface; + VkFence vk_fence; + VkInstance vk_instance; + VkDevice vk_device; + ID3D12Resource *buffers[DXGI_MAX_SWAP_CHAIN_BUFFERS]; + unsigned int buffer_count; + + uint32_t current_buffer_index; + struct dxgi_vk_funcs vk_funcs; + ID3D12CommandQueue *command_queue; ID3D12Device *device; IWineDXGIFactory *factory; @@ -855,7 +916,9 @@ static ULONG STDMETHODCALLTYPE d3d12_swapchain_AddRef(IDXGISwapChain3 *iface) static ULONG STDMETHODCALLTYPE d3d12_swapchain_Release(IDXGISwapChain3 *iface) { struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain3(iface); + const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs; ULONG refcount = InterlockedDecrement(&swapchain->refcount); + unsigned int i; TRACE("%p decreasing refcount to %u.\n", swapchain, refcount); @@ -866,6 +929,15 @@ static ULONG STDMETHODCALLTYPE d3d12_swapchain_Release(IDXGISwapChain3 *iface) wined3d_private_store_cleanup(&swapchain->private_store); + for (i = 0; i < swapchain->buffer_count; ++i) + { + vkd3d_resource_decref(swapchain->buffers[i]); + } + + vk_funcs->p_vkDestroyFence(swapchain->vk_device, swapchain->vk_fence, NULL); + vk_funcs->p_vkDestroySwapchainKHR(swapchain->vk_device, swapchain->vk_swapchain, NULL); + vk_funcs->p_vkDestroySurfaceKHR(swapchain->vk_instance, swapchain->vk_surface, NULL); + ID3D12Device_Release(swapchain->device); heap_free(swapchain); @@ -1295,45 +1367,419 @@ static const struct IDXGISwapChain3Vtbl d3d12_swapchain_vtbl = d3d12_swapchain_ResizeBuffers1, }; +static const struct vulkan_funcs *get_vk_funcs(void) +{ + const struct vulkan_funcs *vk_funcs; + HDC hdc; + + hdc = GetDC(0); + vk_funcs = __wine_get_vulkan_driver(hdc, WINE_VULKAN_DRIVER_VERSION); + ReleaseDC(0, hdc); + return vk_funcs; +} + +static BOOL load_vkd3d_functions(void *vkd3d_handle) +{ +#define LOAD_FUNCPTR(f) if (!(f = wine_dlsym(vkd3d_handle, #f, NULL, 0))) return FALSE; + LOAD_FUNCPTR(vkd3d_acquire_vk_queue) + LOAD_FUNCPTR(vkd3d_create_image_resource) + LOAD_FUNCPTR(vkd3d_get_vk_device) + LOAD_FUNCPTR(vkd3d_get_vk_format) + LOAD_FUNCPTR(vkd3d_get_vk_physical_device) + LOAD_FUNCPTR(vkd3d_get_vk_queue_family_index) + LOAD_FUNCPTR(vkd3d_instance_from_device) + LOAD_FUNCPTR(vkd3d_instance_get_vk_instance) + LOAD_FUNCPTR(vkd3d_release_vk_queue) + LOAD_FUNCPTR(vkd3d_resource_decref) + LOAD_FUNCPTR(vkd3d_resource_incref) +#undef LOAD_FUNCPTR + + return TRUE; +} + +static BOOL init_vkd3d(void) +{ + static void *vkd3d_handle; + + if (vkd3d_handle) + return TRUE; + + TRACE("Loading vkd3d %s.\n", SONAME_LIBVKD3D); + + if (!(vkd3d_handle = wine_dlopen(SONAME_LIBVKD3D, RTLD_NOW, NULL, 0))) + return FALSE; + + if (!load_vkd3d_functions(vkd3d_handle)) + { + ERR("Failed to load vkd3d functions.\n"); + wine_dlclose(vkd3d_handle, NULL, 0); + vkd3d_handle = NULL; + return FALSE; + } + + return TRUE; +} + +static BOOL init_vk_funcs(struct dxgi_vk_funcs *dxgi, VkDevice vk_device) +{ + const struct vulkan_funcs *vk; + + if (!(vk = get_vk_funcs())) + { + ERR_(winediag)("Failed to load Wine Vulkan driver.\n"); + return FALSE; + } + + dxgi->p_vkAcquireNextImageKHR = vk->p_vkAcquireNextImageKHR; + dxgi->p_vkCreateSwapchainKHR = vk->p_vkCreateSwapchainKHR; + dxgi->p_vkCreateWin32SurfaceKHR = vk->p_vkCreateWin32SurfaceKHR; + dxgi->p_vkDestroySurfaceKHR = vk->p_vkDestroySurfaceKHR; + dxgi->p_vkDestroySwapchainKHR = vk->p_vkDestroySwapchainKHR; + dxgi->p_vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)vk->p_vkGetDeviceProcAddr; + dxgi->p_vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)vk->p_vkGetInstanceProcAddr; + dxgi->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = vk->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; + dxgi->p_vkGetPhysicalDeviceSurfaceFormatsKHR = vk->p_vkGetPhysicalDeviceSurfaceFormatsKHR; + dxgi->p_vkGetPhysicalDeviceSurfacePresentModesKHR = vk->p_vkGetPhysicalDeviceSurfacePresentModesKHR; + dxgi->p_vkGetPhysicalDeviceSurfaceSupportKHR = vk->p_vkGetPhysicalDeviceSurfaceSupportKHR; + dxgi->p_vkGetPhysicalDeviceWin32PresentationSupportKHR = vk->p_vkGetPhysicalDeviceWin32PresentationSupportKHR; + dxgi->p_vkGetSwapchainImagesKHR = vk->p_vkGetSwapchainImagesKHR; + dxgi->p_vkQueuePresentKHR = vk->p_vkQueuePresentKHR; + +#define LOAD_DEVICE_PFN(name) \ + if (!(dxgi->p_##name = vk->p_vkGetDeviceProcAddr(vk_device, #name))) \ + { \ + ERR("Failed to get device proc "#name".\n"); \ + return FALSE; \ + } + LOAD_DEVICE_PFN(vkCreateFence) + LOAD_DEVICE_PFN(vkWaitForFences) + LOAD_DEVICE_PFN(vkResetFences) + LOAD_DEVICE_PFN(vkDestroyFence) +#undef LOAD_DEVICE_PFN + + return TRUE; +} + +static HRESULT select_vk_format(const struct dxgi_vk_funcs *vk_funcs, + VkPhysicalDevice vk_physical_device, VkSurfaceKHR vk_surface, + const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, VkFormat *vk_format) +{ + VkSurfaceFormatKHR *formats; + uint32_t format_count; + VkFormat format; + unsigned int i; + VkResult vr; + + *vk_format = VK_FORMAT_UNDEFINED; + + format = vkd3d_get_vk_format(swapchain_desc->Format); + if (format == VK_FORMAT_UNDEFINED) + return DXGI_ERROR_INVALID_CALL; + + vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, vk_surface, &format_count, NULL); + if (vr < 0 || !format_count) + { + WARN("Failed to get supported surface formats, vr %d.\n", vr); + return DXGI_ERROR_INVALID_CALL; + } + + if (!(formats = heap_calloc(format_count, sizeof(*formats)))) + return E_OUTOFMEMORY; + + if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, + vk_surface, &format_count, formats)) < 0) + { + WARN("Failed to enumerate supported surface formats, vr %d.\n", vr); + heap_free(formats); + return DXGI_ERROR_INVALID_CALL; + } + + for (i = 0; i < format_count; ++i) + { + if (formats[i].format == format && formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) + break; + } + heap_free(formats); + + if (i == format_count) + { + FIXME("Failed to find suitable format for %s.\n", debug_dxgi_format(swapchain_desc->Format)); + return DXGI_ERROR_INVALID_CALL; + } + + *vk_format = format; + return S_OK; +} + +static HRESULT d3d12_swapchain_init(struct d3d12_swapchain *swapchain, IWineDXGIFactory *factory, + ID3D12Device *device, ID3D12CommandQueue *queue, HWND window, + const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc) +{ + const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs; + struct vkd3d_image_resource_create_info resource_info; + struct VkSwapchainCreateInfoKHR vk_swapchain_desc; + struct VkWin32SurfaceCreateInfoKHR surface_desc; + VkImage vk_images[DXGI_MAX_SWAP_CHAIN_BUFFERS]; + VkSwapchainKHR vk_swapchain = VK_NULL_HANDLE; + VkSurfaceKHR vk_surface = VK_NULL_HANDLE; + VkSurfaceCapabilitiesKHR surface_caps; + VkPhysicalDevice vk_physical_device; + VkFence vk_fence = VK_NULL_HANDLE; + unsigned int image_count, i, j; + VkFenceCreateInfo fence_desc; + uint32_t queue_family_index; + VkInstance vk_instance; + HRESULT hr = E_FAIL; + VkBool32 supported; + VkDevice vk_device; + VkFormat vk_format; + VkResult vr; + + swapchain->IDXGISwapChain3_iface.lpVtbl = &d3d12_swapchain_vtbl; + swapchain->refcount = 1; + + swapchain->window = window; + swapchain->desc = *swapchain_desc; + swapchain->fullscreen_desc = *fullscreen_desc; + + switch (swapchain_desc->SwapEffect) + { + case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL: + case DXGI_SWAP_EFFECT_FLIP_DISCARD: + FIXME("Ignoring swap effect %#x.\n", swapchain_desc->SwapEffect); + break; + default: + WARN("Invalid swap effect %#x.\n", swapchain_desc->SwapEffect); + return DXGI_ERROR_INVALID_CALL; + } + + if (!init_vkd3d()) + { + ERR_(winediag)("libvkd3d could not be loaded.\n"); + return DXGI_ERROR_UNSUPPORTED; + } + + if (swapchain_desc->BufferUsage && swapchain_desc->BufferUsage != DXGI_USAGE_RENDER_TARGET_OUTPUT) + FIXME("Ignoring buffer usage %#x.\n", swapchain_desc->BufferUsage); + if (swapchain_desc->Scaling != DXGI_SCALING_STRETCH) + FIXME("Ignoring scaling %#x.\n", swapchain_desc->Scaling); + if (swapchain_desc->AlphaMode && swapchain_desc->AlphaMode != DXGI_ALPHA_MODE_IGNORE) + FIXME("Ignoring alpha mode %#x.\n", swapchain_desc->AlphaMode); + if (swapchain_desc->Flags) + FIXME("Ignoring swapchain flags %#x.\n", swapchain_desc->Flags); + + FIXME("Ignoring refresh rate.\n"); + if (fullscreen_desc->ScanlineOrdering) + FIXME("Unhandled scanline ordering %#x.\n", fullscreen_desc->ScanlineOrdering); + if (fullscreen_desc->Scaling) + FIXME("Unhandled mode scaling %#x.\n", fullscreen_desc->Scaling); + if (!fullscreen_desc->Windowed) + FIXME("Fullscreen not supported yet.\n"); + + vk_instance = vkd3d_instance_get_vk_instance(vkd3d_instance_from_device(device)); + vk_physical_device = vkd3d_get_vk_physical_device(device); + vk_device = vkd3d_get_vk_device(device); + + if (!init_vk_funcs(&swapchain->vk_funcs, vk_device)) + return E_FAIL; + + surface_desc.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; + surface_desc.pNext = NULL; + surface_desc.flags = 0; + surface_desc.hinstance = GetModuleHandleA("dxgi.dll"); + surface_desc.hwnd = window; + if ((vr = vk_funcs->p_vkCreateWin32SurfaceKHR(vk_instance, &surface_desc, NULL, &vk_surface)) < 0) + { + WARN("Failed to create Vulkan surface, vr %d.\n", vr); + goto fail; + } + + queue_family_index = vkd3d_get_vk_queue_family_index(queue); + if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device, + queue_family_index, vk_surface, &supported)) < 0 || !supported) + { + FIXME("Queue family does not support presentation, vr %d.\n", vr); + goto fail; + } + + if (FAILED(hr = select_vk_format(vk_funcs, vk_physical_device, vk_surface, swapchain_desc, &vk_format))) + goto fail; + hr = E_FAIL; + + if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device, + vk_surface, &surface_caps)) < 0) + { + WARN("Failed to get surface capabilities, vr %d.\n", vr); + goto fail; + } + + if (surface_caps.maxImageCount && (swapchain_desc->BufferCount > surface_caps.maxImageCount + || swapchain_desc->BufferCount < surface_caps.minImageCount)) + { + WARN("Buffer count %u is not supported (%u-%u).\n", swapchain_desc->BufferCount, + surface_caps.minImageCount, surface_caps.maxImageCount); + goto fail; + } + + if (swapchain_desc->Width > surface_caps.maxImageExtent.width + || swapchain_desc->Width < surface_caps.minImageExtent.width + || swapchain_desc->Height > surface_caps.maxImageExtent.height + || swapchain_desc->Height < surface_caps.minImageExtent.height) + { + FIXME("Swapchain dimensions %ux%u are not supported (%u-%u x %u-%u).\n", + swapchain_desc->Width, swapchain_desc->Height, + surface_caps.minImageExtent.width, surface_caps.maxImageExtent.width, + surface_caps.minImageExtent.height, surface_caps.maxImageExtent.height); + } + + if (!(surface_caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR)) + { + FIXME("Unsupported alpha mode.\n"); + goto fail; + } + + vk_swapchain_desc.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + vk_swapchain_desc.pNext = NULL; + vk_swapchain_desc.flags = 0; + vk_swapchain_desc.surface = vk_surface; + vk_swapchain_desc.minImageCount = swapchain_desc->BufferCount; + vk_swapchain_desc.imageFormat = vk_format; + vk_swapchain_desc.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + vk_swapchain_desc.imageExtent.width = swapchain_desc->Width; + vk_swapchain_desc.imageExtent.height = swapchain_desc->Height; + vk_swapchain_desc.imageArrayLayers = 1; + vk_swapchain_desc.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + vk_swapchain_desc.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; + vk_swapchain_desc.queueFamilyIndexCount = 0; + vk_swapchain_desc.pQueueFamilyIndices = NULL; + vk_swapchain_desc.preTransform = surface_caps.currentTransform; + vk_swapchain_desc.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; + vk_swapchain_desc.presentMode = VK_PRESENT_MODE_FIFO_KHR; + vk_swapchain_desc.clipped = VK_TRUE; + vk_swapchain_desc.oldSwapchain = VK_NULL_HANDLE; + if ((vr = vk_funcs->p_vkCreateSwapchainKHR(vk_device, &vk_swapchain_desc, NULL, &vk_swapchain)) < 0) + { + WARN("Failed to create Vulkan swapchain, vr %d.\n", vr); + goto fail; + } + + fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fence_desc.pNext = NULL; + fence_desc.flags = 0; + if ((vr = vk_funcs->p_vkCreateFence(vk_device, &fence_desc, NULL, &vk_fence)) < 0) + { + WARN("Failed to create Vulkan fence, vr %d.\n", vr); + goto fail; + } + + if ((vr = vk_funcs->p_vkGetSwapchainImagesKHR(vk_device, vk_swapchain, &image_count, NULL)) < 0) + { + WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr); + goto fail; + } + if (image_count != swapchain_desc->BufferCount) + FIXME("Got %u swapchain images, expected %u.\n", image_count, swapchain_desc->BufferCount); + if (image_count > ARRAY_SIZE(vk_images)) + goto fail; + if ((vr = vk_funcs->p_vkGetSwapchainImagesKHR(vk_device, vk_swapchain, &image_count, vk_images)) < 0) + { + WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr); + goto fail; + } + + swapchain->vk_swapchain = vk_swapchain; + swapchain->vk_surface = vk_surface; + swapchain->vk_fence = vk_fence; + swapchain->vk_instance = vk_instance; + swapchain->vk_device = vk_device; + + vk_funcs->p_vkAcquireNextImageKHR(vk_device, vk_swapchain, UINT64_MAX, + VK_NULL_HANDLE, vk_fence, &swapchain->current_buffer_index); + vk_funcs->p_vkWaitForFences(vk_device, 1, &vk_fence, VK_TRUE, UINT64_MAX); + vk_funcs->p_vkResetFences(vk_device, 1, &vk_fence); + + resource_info.type = VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO; + resource_info.next = NULL; + resource_info.desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + resource_info.desc.Alignment = 0; + resource_info.desc.Width = swapchain_desc->Width; + resource_info.desc.Height = swapchain_desc->Height; + resource_info.desc.DepthOrArraySize = 1; + resource_info.desc.MipLevels = 1; + resource_info.desc.Format = swapchain_desc->Format; + resource_info.desc.SampleDesc.Count = 1; + resource_info.desc.SampleDesc.Quality = 0; + resource_info.desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + resource_info.desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; + resource_info.flags = VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION; + resource_info.present_state = D3D12_RESOURCE_STATE_PRESENT; + for (i = 0; i < image_count; ++i) + { + resource_info.vk_image = vk_images[i]; + if (SUCCEEDED(hr = vkd3d_create_image_resource(device, &resource_info, &swapchain->buffers[i]))) + { + vkd3d_resource_incref(swapchain->buffers[i]); + ID3D12Resource_Release(swapchain->buffers[i]); + } + else + { + ERR("Failed to create vkd3d resource for Vulkan image %u, hr %#x.\n", i, hr); + for (j = 0; j < i; ++j) + { + vkd3d_resource_decref(swapchain->buffers[j]); + } + goto fail; + } + } + swapchain->buffer_count = image_count; + + wined3d_private_store_init(&swapchain->private_store); + + ID3D12CommandQueue_AddRef(swapchain->command_queue = queue); + ID3D12Device_AddRef(swapchain->device = device); + IWineDXGIFactory_AddRef(swapchain->factory = factory); + + return S_OK; + +fail: + vk_funcs->p_vkDestroyFence(vk_device, vk_fence, NULL); + vk_funcs->p_vkDestroySwapchainKHR(vk_device, vk_swapchain, NULL); + vk_funcs->p_vkDestroySurfaceKHR(vk_instance, vk_surface, NULL); + return hr; +} + HRESULT d3d12_swapchain_create(IWineDXGIFactory *factory, ID3D12CommandQueue *queue, HWND window, const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc, IDXGISwapChain1 **swapchain) { + DXGI_SWAP_CHAIN_FULLSCREEN_DESC default_fullscreen_desc; struct d3d12_swapchain *object; ID3D12Device *device; HRESULT hr; - if (FAILED(hr = ID3D12CommandQueue_GetDevice(queue, &IID_ID3D12Device, (void **)&device))) + if (!fullscreen_desc) { - ERR("Failed to get D3D12 device, hr %#x.\n", hr); - return hr; + memset(&default_fullscreen_desc, 0, sizeof(default_fullscreen_desc)); + default_fullscreen_desc.Windowed = TRUE; + fullscreen_desc = &default_fullscreen_desc; } if (!(object = heap_alloc_zero(sizeof(*object)))) - { - ID3D12Device_Release(device); return E_OUTOFMEMORY; - } - - object->IDXGISwapChain3_iface.lpVtbl = &d3d12_swapchain_vtbl; - object->refcount = 1; - - wined3d_private_store_init(&object->private_store); - ID3D12CommandQueue_AddRef(object->command_queue = queue); - object->device = device; - IWineDXGIFactory_AddRef(object->factory = factory); - - object->window = window; - object->desc = *swapchain_desc; - if (fullscreen_desc) + if (FAILED(hr = ID3D12CommandQueue_GetDevice(queue, &IID_ID3D12Device, (void **)&device))) { - object->fullscreen_desc = *fullscreen_desc; + ERR("Failed to get D3D12 device, hr %#x.\n", hr); + heap_free(object); + return hr; } - else + + hr = d3d12_swapchain_init(object, factory, device, queue, window, swapchain_desc, fullscreen_desc); + ID3D12Device_Release(device); + if (FAILED(hr)) { - memset(&object->fullscreen_desc, 0, sizeof(object->fullscreen_desc)); - object->fullscreen_desc.Windowed = TRUE; + heap_free(object); + return hr; } TRACE("Created swapchain %p.\n", object); @@ -1342,3 +1788,15 @@ HRESULT d3d12_swapchain_create(IWineDXGIFactory *factory, ID3D12CommandQueue *qu return S_OK; } + +#else + +HRESULT d3d12_swapchain_create(IWineDXGIFactory *factory, ID3D12CommandQueue *queue, HWND window, + const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc, + IDXGISwapChain1 **swapchain) +{ + ERR_(winediag)("Wine was built without Direct3D 12 support.\n"); + return DXGI_ERROR_UNSUPPORTED; +} + +#endif /* SONAME_LIBVKD3D */ -- 2.16.1

3 17