[PATCH 01/10] d3dx9: Fix handling of includes in D3DXCreateEffectFromFileExW().

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
For bug 43863 (Rollcage Redux).

dlls/d3dx9_36/d3dx9_private.h |  8 ++++++++
 dlls/d3dx9_36/effect.c        | 37 ++++++++++++++++++++++++++++++-------
 dlls/d3dx9_36/shader.c        | 38 +++++++++++++++++---------------------
 3 files changed, 55 insertions(+), 28 deletions(-)

diff --git a/dlls/d3dx9_36/d3dx9_private.h b/dlls/d3dx9_36/d3dx9_private.h
index 2044b2af448..6cc1126c80f 100644
--- a/dlls/d3dx9_36/d3dx9_private.h
+++ b/dlls/d3dx9_36/d3dx9_private.h
@@ -69,6 +69,14 @@ struct pixel_format_desc {
     void (*to_rgba)(const struct vec4 *src, struct vec4 *dst, const PALETTEENTRY *palette);
 };

+struct d3dx_include_from_file
+{
+    ID3DXInclude ID3DXInclude_iface;
+};
+
+extern CRITICAL_SECTION from_file_mutex DECLSPEC_HIDDEN;
+extern const struct ID3DXIncludeVtbl d3dx_include_from_file_vtbl DECLSPEC_HIDDEN;
+
 static inline BOOL is_conversion_from_supported(const struct pixel_format_desc *format)
 {
     if (format->type == FORMAT_ARGB || format->type == FORMAT_ARGBF16
diff --git a/dlls/d3dx9_36/effect.c b/dlls/d3dx9_36/effect.c
index 33e0fc4cdae..7675f17e403 100644
--- a/dlls/d3dx9_36/effect.c
+++ b/dlls/d3dx9_36/effect.c
@@ -6664,8 +6664,10 @@ static HRESULT d3dx9_base_effect_init(struct d3dx9_base_effect *base,
 #endif
     unsigned int i, j;

-    TRACE("base %p, data %p, data_size %lu, effect %p, pool %p, skip_constants %s.\n",
-            base, data, data_size, effect, pool, debugstr_a(skip_constants_string));
+    TRACE("base %p, data %p, data_size %lu, defines %p, include %p, eflags %#x, errors %p, "
+            "effect %p, pool %p, skip_constants %s.\n",
+            base, data, data_size, defines, include, eflags, errors, effect, pool,
+            debugstr_a(skip_constants_string));

base->effect = effect;
     base->pool = pool;
@@ -7041,9 +7043,11 @@ HRESULT WINAPI D3DXCreateEffectFromFileExW(struct IDirect3DDevice9 *device, cons
         const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags,
         struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
 {
-    void *buffer;
+    struct d3dx_include_from_file include_from_file;
+    const void *buffer;
+    unsigned int size;
+    char *filename_a;
     HRESULT ret;
-    DWORD size;

TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
             "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
@@ -7053,14 +7057,33 @@ HRESULT WINAPI D3DXCreateEffectFromFileExW(struct IDirect3DDevice9 *device, cons
     if (!device || !srcfile)
         return D3DERR_INVALIDCALL;

-    ret = map_view_of_file(srcfile, &buffer, &size);
+    if (!include)
+    {
+        include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
+        include = &include_from_file.ID3DXInclude_iface;
+    }

+    size = WideCharToMultiByte(CP_ACP, 0, srcfile, -1, NULL, 0, NULL, NULL);
+    filename_a = heap_alloc(size);
+    if (!filename_a)
+        return E_OUTOFMEMORY;
+    WideCharToMultiByte(CP_ACP, 0, srcfile, -1, filename_a, size, NULL, NULL);
+
+    EnterCriticalSection(&from_file_mutex);
+    ret = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &size);
     if (FAILED(ret))
+    {
+        LeaveCriticalSection(&from_file_mutex);
+        heap_free(filename_a);
         return D3DXERR_INVALIDDATA;
+    }

-    ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
-    UnmapViewOfFile(buffer);
+    ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool,
+            effect, compilationerrors);

+    ID3DXInclude_Close(include, buffer);
+    LeaveCriticalSection(&from_file_mutex);
+    heap_free(filename_a);
     return ret;
 }

diff --git a/dlls/d3dx9_36/shader.c b/dlls/d3dx9_36/shader.c
index f3724947601..acbbf0718ad 100644
--- a/dlls/d3dx9_36/shader.c
+++ b/dlls/d3dx9_36/shader.c
@@ -214,7 +214,6 @@ HRESULT WINAPI D3DXAssembleShader(const char *data, UINT data_len, const D3DXMAC

static const void *main_file_data;

-static CRITICAL_SECTION from_file_mutex;
 static CRITICAL_SECTION_DEBUG from_file_mutex_debug =
 {
     0, 0, &from_file_mutex,
@@ -224,14 +223,14 @@ static CRITICAL_SECTION_DEBUG from_file_mutex_debug =
     },
     0, 0, {(DWORD_PTR)(__FILE__ ": from_file_mutex")}
 };
-static CRITICAL_SECTION from_file_mutex = {&from_file_mutex_debug, -1, 0, 0, 0, 0};
+CRITICAL_SECTION from_file_mutex = {&from_file_mutex_debug, -1, 0, 0, 0, 0};

/* D3DXInclude private implementation, used to implement
  * D3DXAssembleShaderFromFile() from D3DXAssembleShader(). */
 /* To be able to correctly resolve include search paths we have to store the
  * pathname of each include file. We store the pathname pointer right before
  * the file data. */
-static HRESULT WINAPI d3dincludefromfile_open(ID3DXInclude *iface, D3DXINCLUDE_TYPE include_type,
+static HRESULT WINAPI d3dx_include_from_file_open(ID3DXInclude *iface, D3DXINCLUDE_TYPE include_type,
         const char *filename, const void *parent_data, const void **data, UINT *bytes)
 {
     const char *p, *parent_name = "";
@@ -250,7 +249,7 @@ static HRESULT WINAPI d3dincludefromfile_open(ID3DXInclude *iface, D3DXINCLUDE_T
             parent_name = *((const char **)main_file_data - 1);
     }

-    TRACE("Looking up for include file %s, parent %s\n", debugstr_a(filename), debugstr_a(parent_name));
+    TRACE("Looking up include file %s, parent %s.\n", debugstr_a(filename), debugstr_a(parent_name));

if ((p = strrchr(parent_name, '\')))
         ++p;
@@ -301,7 +300,7 @@ error:
     return HRESULT_FROM_WIN32(GetLastError());
 }

-static HRESULT WINAPI d3dincludefromfile_close(ID3DXInclude *iface, const void *data)
+static HRESULT WINAPI d3dx_include_from_file_close(ID3DXInclude *iface, const void *data)
 {
     HeapFree(GetProcessHeap(), 0, *((char **)data - 1));
     HeapFree(GetProcessHeap(), 0, (char **)data - 1);
@@ -310,13 +309,10 @@ static HRESULT WINAPI d3dincludefromfile_close(ID3DXInclude *iface, const void *
     return S_OK;
 }

-static const struct ID3DXIncludeVtbl D3DXInclude_Vtbl = {
-    d3dincludefromfile_open,
-    d3dincludefromfile_close
-};
-
-struct D3DXIncludeImpl {
-    ID3DXInclude ID3DXInclude_iface;
+const struct ID3DXIncludeVtbl d3dx_include_from_file_vtbl =
+{
+    d3dx_include_from_file_open,
+    d3dx_include_from_file_close
 };

HRESULT WINAPI D3DXAssembleShaderFromFileA(const char *filename, const D3DXMACRO *defines,
@@ -348,7 +344,7 @@ HRESULT WINAPI D3DXAssembleShaderFromFileW(const WCHAR *filename, const D3DXMACR
     const void *buffer;
     DWORD len;
     HRESULT hr;
-    struct D3DXIncludeImpl includefromfile;
+    struct d3dx_include_from_file include_from_file;
     char *filename_a;

TRACE("filename %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
@@ -356,8 +352,8 @@ HRESULT WINAPI D3DXAssembleShaderFromFileW(const WCHAR *filename, const D3DXMACR

if(!include)
     {
-        includefromfile.ID3DXInclude_iface.lpVtbl = &D3DXInclude_Vtbl;
-        include = &includefromfile.ID3DXInclude_iface;
+        include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
+        include = &include_from_file.ID3DXInclude_iface;
     }

len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
@@ -481,7 +477,7 @@ HRESULT WINAPI D3DXCompileShaderFromFileW(const WCHAR *filename, const D3DXMACRO
     const void *buffer;
     DWORD len, filename_len;
     HRESULT hr;
-    struct D3DXIncludeImpl includefromfile;
+    struct d3dx_include_from_file include_from_file;
     char *filename_a;

TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
@@ -491,8 +487,8 @@ HRESULT WINAPI D3DXCompileShaderFromFileW(const WCHAR *filename, const D3DXMACRO

if (!include)
     {
-        includefromfile.ID3DXInclude_iface.lpVtbl = &D3DXInclude_Vtbl;
-        include = &includefromfile.ID3DXInclude_iface;
+        include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
+        include = &include_from_file.ID3DXInclude_iface;
     }

filename_len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
@@ -606,7 +602,7 @@ HRESULT WINAPI D3DXPreprocessShaderFromFileW(const WCHAR *filename, const D3DXMA
     const void *buffer;
     DWORD len;
     HRESULT hr;
-    struct D3DXIncludeImpl includefromfile;
+    struct d3dx_include_from_file include_from_file;
     char *filename_a;

TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
@@ -614,8 +610,8 @@ HRESULT WINAPI D3DXPreprocessShaderFromFileW(const WCHAR *filename, const D3DXMA

if (!include)
     {
-        includefromfile.ID3DXInclude_iface.lpVtbl = &D3DXInclude_Vtbl;
-        include = &includefromfile.ID3DXInclude_iface;
+        include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
+        include = &include_from_file.ID3DXInclude_iface;
     }

len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);

[PATCH 02/10] d3dx9/tests: Add a test for D3DXCreateEffectFromFileExW().

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
It turns out that preprocessing of "ASCII" effects is pretty broken on
native. In theory we should replicate the same brokenness in Wine but
1. I don't quite understand how exactly it's broken like and 2. the
current implementation works well enough for the case at hand.

dlls/d3dx9_36/tests/effect.c | 348 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 348 insertions(+)

diff --git a/dlls/d3dx9_36/tests/effect.c b/dlls/d3dx9_36/tests/effect.c
index bcaf377f9dc..acc5ded6fd7 100644
--- a/dlls/d3dx9_36/tests/effect.c
+++ b/dlls/d3dx9_36/tests/effect.c
@@ -189,6 +189,63 @@ static IDirect3DDevice9 *create_device(HWND *window)
     return device;
 }

+static char temp_path[MAX_PATH];
+
+static BOOL create_file(const char *filename, const char *data, const unsigned int size, char *out_path)
+{
+    DWORD written;
+    HANDLE hfile;
+    char path[MAX_PATH];
+
+    if (!*temp_path)
+        GetTempPathA(sizeof(temp_path), temp_path);
+
+    strcpy(path, temp_path);
+    strcat(path, filename);
+    hfile = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+    if (hfile == INVALID_HANDLE_VALUE)
+        return FALSE;
+
+    if (WriteFile(hfile, data, size, &written, NULL))
+    {
+        CloseHandle(hfile);
+
+        if (out_path)
+            strcpy(out_path, path);
+        return TRUE;
+    }
+
+    CloseHandle(hfile);
+    return FALSE;
+}
+
+static void delete_file(const char *filename)
+{
+    char path[MAX_PATH];
+
+    strcpy(path, temp_path);
+    strcat(path, filename);
+    DeleteFileA(path);
+}
+
+static BOOL create_directory(const char *name)
+{
+    char path[MAX_PATH];
+
+    strcpy(path, temp_path);
+    strcat(path, name);
+    return CreateDirectoryA(path, NULL);
+}
+
+static void delete_directory(const char *name)
+{
+    char path[MAX_PATH];
+
+    strcpy(path, temp_path);
+    strcat(path, name);
+    RemoveDirectoryA(path);
+}
+
 static const char effect_desc[] =
 "Technique\n"
 "{\n"
@@ -7485,6 +7542,296 @@ static void test_refcount(void)
     DestroyWindow(window);
 }

+static HRESULT WINAPI d3dxinclude_open(ID3DXInclude *iface, D3DXINCLUDE_TYPE include_type,
+        const char *filename, const void *parent_data, const void **data, UINT *bytes)
+{
+    static const char include1[] =
+        "float4 light;\n"
+        "float4x4 mat;\n"
+        "float4 color;\n"
+        "\n"
+        "struct vs_input\n"
+        "{\n"
+        "    float4 position : POSITION;\n"
+        "    float3 normal : NORMAL;\n"
+        "};\n"
+        "\n"
+        "struct vs_output\n"
+        "{\n"
+        "    float4 position : POSITION;\n"
+        "    float4 diffuse : COLOR;\n"
+        "};\n";
+    static const char include2[] =
+        "#include "include1.h"\n"
+        "\n"
+        "vs_output vs_main(const vs_input v)\n"
+        "{\n"
+        "    vs_output o;\n"
+        "    const float4 scaled_color = 0.5 * color;\n"
+        "\n"
+        "    o.position = mul(v.position, mat);\n"
+        "    o.diffuse = dot((float3)light, v.normal) * scaled_color;\n"
+        "\n"
+        "    return o;\n"
+        "}\n";
+    static const char effect2[] =
+        "#include "include\include2.h"\n"
+        "\n"
+        "technique t\n"
+        "{\n"
+        "    pass p\n"
+        "    {\n"
+        "        VertexShader = compile vs_2_0 vs_main();\n"
+        "    }\n"
+        "}\n";
+    char *buffer;
+
+    trace("filename %s.\n", filename);
+    trace("parent_data %p: %s.\n", parent_data, parent_data ? (char *)parent_data : "(null)");
+
+    if (!strcmp(filename, "effect2.fx"))
+    {
+        buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(effect2));
+        memcpy(buffer, effect2, sizeof(effect2));
+        *bytes = sizeof(effect2);
+        ok(!parent_data, "Unexpected parent_data value.\n");
+    }
+    else if (!strcmp(filename, "include1.h"))
+    {
+        buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include1));
+        memcpy(buffer, include1, sizeof(include1));
+        *bytes = sizeof(include1);
+        ok(!strncmp(parent_data, include2, strlen(include2)), "Unexpected parent_data value.\n");
+    }
+    else if (!strcmp(filename, "include\include2.h"))
+    {
+        buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include2));
+        memcpy(buffer, include2, sizeof(include2));
+        *bytes = sizeof(include2);
+        todo_wine ok(parent_data && !strncmp(parent_data, effect2, strlen(effect2)),
+                "unexpected parent_data value.\n");
+    }
+    else
+    {
+        ok(0, "Unexpected #include for file %s.\n", filename);
+        return D3DERR_INVALIDCALL;
+    }
+    *data = buffer;
+    return S_OK;
+}
+
+static HRESULT WINAPI d3dxinclude_close(ID3DXInclude *iface, const void *data)
+{
+    HeapFree(GetProcessHeap(), 0, (void *)data);
+    return S_OK;
+}
+
+static const struct ID3DXIncludeVtbl d3dxinclude_vtbl =
+{
+    d3dxinclude_open,
+    d3dxinclude_close
+};
+
+struct d3dxinclude
+{
+    ID3DXInclude ID3DXInclude_iface;
+};
+
+static void test_create_effect_from_file(void)
+{
+    static const char effect1[] =
+        "float4 light;\n"
+        "float4x4 mat;\n"
+        "float4 color;\n"
+        "\n"
+        "struct vs_input\n"
+        "{\n"
+        "    float4 position : POSITION;\n"
+        "    float3 normal : NORMAL;\n"
+        "};\n"
+        "\n"
+        "struct vs_output\n"
+        "{\n"
+        "    float4 position : POSITION;\n"
+        "    float4 diffuse : COLOR;\n"
+        "};\n"
+        "\n"
+        "vs_output vs_main(const vs_input v)\n"
+        "{\n"
+        "    vs_output o;\n"
+        "    const float4 scaled_color = 0.5 * color;\n"
+        "\n"
+        "    o.position = mul(v.position, mat);\n"
+        "    o.diffuse = dot((float3)light, v.normal) * scaled_color;\n"
+        "\n"
+        "    return o;\n"
+        "}\n"
+        "\n"
+        "technique t\n"
+        "{\n"
+        "    pass p\n"
+        "    {\n"
+        "        VertexShader = compile vs_2_0 vs_main();\n"
+        "    }\n"
+        "}\n";
+    static const char include1[] =
+        "float4 light;\n"
+        "float4x4 mat;\n"
+        "float4 color;\n"
+        "\n"
+        "struct vs_input\n"
+        "{\n"
+        "    float4 position : POSITION;\n"
+        "    float3 normal : NORMAL;\n"
+        "};\n"
+        "\n"
+        "struct vs_output\n"
+        "{\n"
+        "    float4 position : POSITION;\n"
+        "    float4 diffuse : COLOR;\n"
+        "};\n";
+    static const char include1_wrong[] =
+        "#error "wrong include"\n";
+    static const char include2[] =
+        "#include "include1.h"\n"
+        "\n"
+        "vs_output vs_main(const vs_input v)\n"
+        "{\n"
+        "    vs_output o;\n"
+        "    const float4 scaled_color = 0.5 * color;\n"
+        "\n"
+        "    o.position = mul(v.position, mat);\n"
+        "    o.diffuse = dot((float3)light, v.normal) * scaled_color;\n"
+        "\n"
+        "    return o;\n"
+        "}\n";
+    static const char effect2[] =
+        "#include "include\include2.h"\n"
+        "\n"
+        "technique t\n"
+        "{\n"
+        "    pass p\n"
+        "    {\n"
+        "        VertexShader = compile vs_2_0 vs_main();\n"
+        "    }\n"
+        "}\n";
+    static const WCHAR effect1_filename_w[] = {'e','f','f','e','c','t','1','.','f','x',0};
+    static const WCHAR effect2_filename_w[] = {'e','f','f','e','c','t','2','.','f','x',0};
+    WCHAR effect_path_w[MAX_PATH], filename_w[MAX_PATH];
+    char effect_path[MAX_PATH], filename[MAX_PATH];
+    D3DPRESENT_PARAMETERS present_parameters = {0};
+    unsigned int filename_size;
+    struct d3dxinclude include;
+    IDirect3DDevice9 *device;
+    ID3DXBuffer *messages;
+    ID3DXEffect *effect;
+    IDirect3D9 *d3d;
+    ULONG refcount;
+    HWND window;
+    HRESULT hr;
+
+    if (!(window = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
+            640, 480, NULL, NULL, NULL, NULL)))
+    {
+        skip("Failed to create window.\n");
+        return;
+    }
+    if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
+    {
+        skip("Failed to create IDirect3D9 object.\n");
+        DestroyWindow(window);
+        return;
+    }
+    present_parameters.Windowed = TRUE;
+    present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
+    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
+            D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
+    if (FAILED(hr))
+    {
+        skip("Failed to create IDirect3DDevice9 object, hr %#x.\n", hr);
+        IDirect3D9_Release(d3d);
+        DestroyWindow(window);
+        return;
+    }
+
+    if (!create_file("effect1.fx", effect1, sizeof(effect1) - 1, filename))
+    {
+        skip("Couldn't create temporary file, skipping test.\n");
+        return;
+    }
+
+    filename_size = strlen(filename);
+    filename_size -= sizeof("effect1.fx") - 1;
+    memcpy(effect_path, filename, filename_size);
+    effect_path[filename_size] = 0;
+    MultiByteToWideChar(CP_ACP, 0, effect_path, -1, effect_path_w, sizeof(effect_path_w));
+
+    create_directory("include");
+    create_file("effect2.fx", effect2, sizeof(effect2) - 1, NULL);
+    create_file("include\include1.h", include1, sizeof(include1) - 1, NULL);
+    create_file("include\include2.h", include2, sizeof(include2) - 1, NULL);
+    create_file("include1.h", include1_wrong, sizeof(include1_wrong) - 1, NULL);
+
+    lstrcpyW(filename_w, effect_path_w);
+    lstrcatW(filename_w, effect1_filename_w);
+    effect = NULL;
+    messages = NULL;
+    hr = D3DXCreateEffectFromFileExW(device, filename_w, NULL, NULL, NULL,
+            0, NULL, &effect, &messages);
+    todo_wine ok(hr == D3D_OK, "Unexpected hr %#x.\n", hr);
+    if (messages)
+    {
+        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
+        ID3DXBuffer_Release(messages);
+    }
+    if (effect)
+        effect->lpVtbl->Release(effect);
+
+    lstrcpyW(filename_w, effect_path_w);
+    lstrcatW(filename_w, effect2_filename_w);
+    effect = NULL;
+    messages = NULL;
+    /* This is apparently broken on native, it ends up using the wrong include. */
+    hr = D3DXCreateEffectFromFileExW(device, filename_w, NULL, NULL, NULL,
+            0, NULL, &effect, &messages);
+    todo_wine ok(hr == E_FAIL, "Unexpected error, hr %#x.\n", hr);
+    if (messages)
+    {
+        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
+        ID3DXBuffer_Release(messages);
+    }
+    if (effect)
+        effect->lpVtbl->Release(effect);
+
+    delete_file("effect1.fx");
+    delete_file("effect2.fx");
+    delete_file("include\include1.h");
+    delete_file("include\include2.h");
+    delete_file("include2.h");
+    delete_directory("include");
+
+    lstrcpyW(filename_w, effect2_filename_w);
+    effect = NULL;
+    messages = NULL;
+    include.ID3DXInclude_iface.lpVtbl = &d3dxinclude_vtbl;
+    /* This is actually broken in native d3dx9 (manually tried multiple
+     * versions, all are affected). For reference, the message printed below
+     * is "ID3DXEffectCompiler: There were no techniques" */
+    hr = D3DXCreateEffectFromFileExW(device, filename_w, NULL, &include.ID3DXInclude_iface, NULL,
+            0, NULL, &effect, &messages);
+    todo_wine ok(hr == E_FAIL, "D3DXInclude test failed with error %#x.\n", hr);
+    if (messages)
+    {
+        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
+        ID3DXBuffer_Release(messages);
+    }
+
+    refcount = IDirect3DDevice9_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+    IDirect3D9_Release(d3d);
+    DestroyWindow(window);
+}
+
 START_TEST(effect)
 {
     IDirect3DDevice9 *device;
@@ -7522,4 +7869,5 @@ START_TEST(effect)
     test_effect_null_shader();
     test_effect_clone();
     test_refcount();
+    test_create_effect_from_file();
 }

[PATCH 03/10] d3dx9: Implement FindNextValidTechnique().

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
For bug 34101 / 43863.

dlls/d3dx9_36/effect.c | 40 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 36 insertions(+), 4 deletions(-)

diff --git a/dlls/d3dx9_36/effect.c b/dlls/d3dx9_36/effect.c
index 7675f17e403..1e91a7b82b9 100644
--- a/dlls/d3dx9_36/effect.c
+++ b/dlls/d3dx9_36/effect.c
@@ -4038,13 +4038,45 @@ done:
     return ret;
 }

-static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect* iface, D3DXHANDLE technique, D3DXHANDLE* next_technique)
+static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect *iface,
+        D3DXHANDLE technique, D3DXHANDLE *next_technique)
 {
-    struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
+    struct ID3DXEffectImpl *effect = impl_from_ID3DXEffect(iface);
+    struct d3dx9_base_effect *base = &effect->base_effect;
+    struct d3dx_technique *prev_tech, *tech;
+    unsigned int i;

-    FIXME("(%p)->(%p, %p): stub\n", This, technique, next_technique);
+    TRACE("iface %p, technique %p, next_technique %p.\n", iface, technique, next_technique);

-    return E_NOTIMPL;
+    if (technique)
+    {
+        if (!(prev_tech = get_valid_technique(base, technique)))
+            return D3DERR_INVALIDCALL;
+
+        for (i = 0; i < base->technique_count; ++i)
+        {
+            tech = &base->techniques[i];
+            if (tech == prev_tech)
+                break;
+        }
+    }
+    else
+    {
+        i = 0;
+    }
+
+    for (++i; i < base->technique_count; ++i)
+    {
+        tech = &base->techniques[i];
+        if (SUCCEEDED(ID3DXEffectImpl_ValidateTechnique(iface, get_technique_handle(tech))))
+        {
+            *next_technique = get_technique_handle(tech);
+            return D3D_OK;
+        }
+    }
+
+    *next_technique = get_technique_handle(&base->techniques[0]);
+    return S_FALSE;
 }

static BOOL walk_parameter_dep(struct d3dx_parameter *param, walk_parameter_dep_func param_func,

[PATCH 04/10] d3dx9/tests: Add a test for FindNextValidTechnique().

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
 dlls/d3dx9_36/tests/effect.c | 88 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/dlls/d3dx9_36/tests/effect.c b/dlls/d3dx9_36/tests/effect.c
index acc5ded6fd7..0ae02315f4d 100644
--- a/dlls/d3dx9_36/tests/effect.c
+++ b/dlls/d3dx9_36/tests/effect.c
@@ -7832,6 +7832,93 @@ static void test_create_effect_from_file(void)
     DestroyWindow(window);
 }

+static void test_effect_find_next_valid_technique(void)
+{
+    D3DPRESENT_PARAMETERS present_parameters = {0};
+    IDirect3DDevice9 *device;
+    D3DXTECHNIQUE_DESC desc;
+    ID3DXEffect *effect;
+    IDirect3D9 *d3d;
+    D3DXHANDLE tech;
+    ULONG refcount;
+    HWND window;
+    HRESULT hr;
+
+    if (!(window = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
+            640, 480, NULL, NULL, NULL, NULL)))
+    {
+        skip("Failed to create window.\n");
+        return;
+    }
+    if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
+    {
+        skip("Failed to create IDirect3D9 object.\n");
+        DestroyWindow(window);
+        return;
+    }
+    present_parameters.Windowed = TRUE;
+    present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
+    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
+            D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
+    if (FAILED(hr))
+    {
+        skip("Failed to create IDirect3DDevice9 object, hr %#x.\n", hr);
+        IDirect3D9_Release(d3d);
+        DestroyWindow(window);
+        return;
+    }
+
+    hr = D3DXCreateEffectEx(device, test_effect_unsupported_shader_blob, sizeof(test_effect_unsupported_shader_blob),
+            NULL, NULL, NULL, 0, NULL, &effect, NULL);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+
+    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);
+
+    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
+    ok(hr == S_FALSE, "Got result %#x.\n", hr);
+    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+    ok(!strcmp(desc.Name, "tech0"), "Got unexpected technique %s.\n", desc.Name);
+
+    effect->lpVtbl->SetInt(effect, "i", 1);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+
+    tech = (D3DXHANDLE)0xdeadbeef;
+    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
+    ok(hr == S_FALSE, "Got result %#x.\n", hr);
+    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+    ok(!strcmp(desc.Name, "tech0"), "Got unexpected technique %s.\n", desc.Name);
+
+    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
+    ok(hr == S_FALSE, "Got result %#x.\n", hr);
+
+    effect->lpVtbl->SetInt(effect, "i", 0);
+
+    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
+    ok(hr == D3D_OK, "Got result %#x.\n", hr);
+    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);
+
+    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
+    ok(hr == S_FALSE, "Got result %#x.\n", hr);
+
+    hr = effect->lpVtbl->FindNextValidTechnique(effect, "nope", &tech);
+    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);
+
+    effect->lpVtbl->Release(effect);
+
+    refcount = IDirect3DDevice9_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+    IDirect3D9_Release(d3d);
+    DestroyWindow(window);
+}
+
 START_TEST(effect)
 {
     IDirect3DDevice9 *device;
@@ -7870,4 +7957,5 @@ START_TEST(effect)
     test_effect_clone();
     test_refcount();
     test_create_effect_from_file();
+    test_effect_find_next_valid_technique();
 }

[PATCH 05/10] d3dx9: Disentangle ID3DXEffectCompiler implementation from struct d3dx9_base_effect.

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
Sharing the implementation with ID3DXEffect makes no sense. Instead of
incorrectly claiming to partially implement it, make it a complete
stub. Doing that even avoids a crash inside D3DXCreateEffectCompiler()
when a "working" d3dcompiler_43.dll is around (specifically, it
previously called d3dx9_base_effect_init() and then crashed in
d3dx9_create_object() because base->effect was NULL).

This improves Battlefield 2142 (bug 39652), although (unsurprisingly)
it's not enough to make the game work.

dlls/d3dx9_36/effect.c       | 365 ++++++++++++++-----------------------------
 dlls/d3dx9_36/tests/effect.c |   2 +-
 2 files changed, 117 insertions(+), 250 deletions(-)

diff --git a/dlls/d3dx9_36/effect.c b/dlls/d3dx9_36/effect.c
index 1e91a7b82b9..404a36d0b54 100644
--- a/dlls/d3dx9_36/effect.c
+++ b/dlls/d3dx9_36/effect.c
@@ -207,8 +207,6 @@ struct ID3DXEffectCompilerImpl
 {
     ID3DXEffectCompiler ID3DXEffectCompiler_iface;
     LONG ref;
-
-    struct d3dx9_base_effect base_effect;
 };

static struct d3dx_parameter *get_annotation_by_name(struct d3dx9_base_effect *base,
@@ -736,13 +734,6 @@ static void free_effect(struct ID3DXEffectImpl *effect)
     IDirect3DDevice9_Release(effect->device);
 }

-static void free_effect_compiler(struct ID3DXEffectCompilerImpl *compiler)
-{
-    TRACE("Free effect compiler %p\n", compiler);
-
-    d3dx9_base_effect_cleanup(&compiler->base_effect);
-}
-
 static void get_vector(struct d3dx_parameter *param, D3DXVECTOR4 *vector)
 {
     UINT i;
@@ -4661,7 +4652,6 @@ static ULONG WINAPI ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler *iface)

if (!ref)
     {
-        free_effect_compiler(This);
         HeapFree(GetProcessHeap(), 0, This);
     }

@@ -4671,547 +4661,435 @@ static ULONG WINAPI ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler *iface)
 /*** ID3DXBaseEffect methods ***/
 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler *iface, D3DXEFFECT_DESC *desc)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, desc %p stub!\n", iface, desc);

-    TRACE("iface %p, desc %p.\n", iface, desc);
-
-    return d3dx9_base_effect_get_desc(&compiler->base_effect, desc);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, desc %p stub!\n", iface, parameter, desc);

-    TRACE("iface %p, parameter %p, desc %p.\n", iface, parameter, desc);
-
-    return d3dx9_base_effect_get_parameter_desc(&compiler->base_effect, parameter, desc);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler *iface,
         D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, technique %p, desc %p stub!\n", iface, technique, desc);

-    TRACE("iface %p, technique %p, desc %p.\n", iface, technique, desc);
-
-    return d3dx9_base_effect_get_technique_desc(&compiler->base_effect, technique, desc);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler *iface,
         D3DXHANDLE pass, D3DXPASS_DESC *desc)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, pass %p, desc %p stub!\n", iface, pass, desc);

-    TRACE("iface %p, pass %p, desc %p.\n", iface, pass, desc);
-
-    return d3dx9_base_effect_get_pass_desc(&compiler->base_effect, pass, desc);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler *iface,
         D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, shader %p, desc %p stub!\n", iface, shader, desc);

-    TRACE("iface %p, shader %p, desc %p.\n", iface, shader, desc);
-
-    return d3dx9_base_effect_get_function_desc(&compiler->base_effect, shader, desc);
+    return E_NOTIMPL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, UINT index)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, index %u.\n", iface, parameter, index);
+    FIXME("iface %p, parameter %p, index %u stub!\n", iface, parameter, index);

-    return d3dx9_base_effect_get_parameter(&compiler->base_effect, parameter, index);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const char *name)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, name %s.\n", iface, parameter, debugstr_a(name));
+    FIXME("iface %p, parameter %p, name %s stub!\n", iface, parameter, debugstr_a(name));

-    return d3dx9_base_effect_get_parameter_by_name(&compiler->base_effect, parameter, name);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const char *semantic)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, semantic %s.\n", iface, parameter, debugstr_a(semantic));
+    FIXME("iface %p, parameter %p, semantic %s stub!\n", iface, parameter, debugstr_a(semantic));

-    return d3dx9_base_effect_get_parameter_by_semantic(&compiler->base_effect, parameter, semantic);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, UINT index)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, index %u.\n", iface, parameter, index);
+    FIXME("iface %p, parameter %p, index %u stub!\n", iface, parameter, index);

-    return d3dx9_base_effect_get_parameter_element(&compiler->base_effect, parameter, index);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler *iface, UINT index)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, index %u.\n", iface, index);
+    FIXME("iface %p, index %u stub!\n", iface, index);

-    return d3dx9_base_effect_get_technique(&compiler->base_effect, index);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler *iface, const char *name)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));

-    return d3dx9_base_effect_get_technique_by_name(&compiler->base_effect, name);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler *iface, D3DXHANDLE technique, UINT index)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, technique %p, index %u.\n", iface, technique, index);
+    FIXME("iface %p, technique %p, index %u stub!\n", iface, technique, index);

-    return d3dx9_base_effect_get_pass(&compiler->base_effect, technique, index);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler *iface,
         D3DXHANDLE technique, const char *name)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, technique %p, name %s.\n", iface, technique, debugstr_a(name));
+    FIXME("iface %p, technique %p, name %s stub!\n", iface, technique, debugstr_a(name));

-    return d3dx9_base_effect_get_pass_by_name(&compiler->base_effect, technique, name);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler *iface, UINT index)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, index %u stub!\n", iface, index);

-    TRACE("iface %p, index %u.\n", iface, index);
-
-    return d3dx9_base_effect_get_function(&compiler->base_effect, index);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler *iface, const char *name)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
+    FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));

-    return d3dx9_base_effect_get_function_by_name(&compiler->base_effect, name);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler *iface,
         D3DXHANDLE object, UINT index)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, object %p, index %u.\n", iface, object, index);
+    FIXME("iface %p, object %p, index %u stub!\n", iface, object, index);

-    return d3dx9_base_effect_get_annotation(&compiler->base_effect, object, index);
+    return NULL;
 }

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler *iface,
         D3DXHANDLE object, const char *name)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, object %p, name %s.\n", iface, object, debugstr_a(name));
+    FIXME("iface %p, object %p, name %s stub!\n", iface, object, debugstr_a(name));

-    return d3dx9_base_effect_get_annotation_by_name(&compiler->base_effect, object, name);
+    return NULL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const void *data, UINT bytes)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, data %p, bytes %u stub!\n", iface, parameter, data, bytes);

-    TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface, parameter, data, bytes);
-
-    return d3dx9_base_effect_set_value(&compiler->base_effect, parameter, data, bytes);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, void *data, UINT bytes)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface, parameter, data, bytes);
+    FIXME("iface %p, parameter %p, data %p, bytes %u stub!\n", iface, parameter, data, bytes);

-    return d3dx9_base_effect_get_value(&compiler->base_effect, parameter, data, bytes);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL b)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, b %#x stub!\n", iface, parameter, b);

-    TRACE("iface %p, parameter %p, b %#x.\n", iface, parameter, b);
-
-    return d3dx9_base_effect_set_bool(&compiler->base_effect, parameter, b);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, b %p stub!\n", iface, parameter, b);

-    TRACE("iface %p, parameter %p, b %p.\n", iface, parameter, b);
-
-    return d3dx9_base_effect_get_bool(&compiler->base_effect, parameter, b);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const BOOL *b, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, b %p, count %u stub!\n", iface, parameter, b, count);

-    TRACE("iface %p, parameter %p, b %p, count %u.\n", iface, parameter, b, count);
-
-    return d3dx9_base_effect_set_bool_array(&compiler->base_effect, parameter, b, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, BOOL *b, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, b %p, count %u stub!\n", iface, parameter, b, count);

-    TRACE("iface %p, parameter %p, b %p, count %u.\n", iface, parameter, b, count);
-
-    return d3dx9_base_effect_get_bool_array(&compiler->base_effect, parameter, b, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT n)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, n %d stub!\n", iface, parameter, n);

-    TRACE("iface %p, parameter %p, n %d.\n", iface, parameter, n);
-
-    return d3dx9_base_effect_set_int(&compiler->base_effect, parameter, n);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, n %p.\n", iface, parameter, n);
+    FIXME("iface %p, parameter %p, n %p stub!\n", iface, parameter, n);

-    return d3dx9_base_effect_get_int(&compiler->base_effect, parameter, n);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const INT *n, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, n %p, count %u.\n", iface, parameter, n, count);
+    FIXME("iface %p, parameter %p, n %p, count %u stub!\n", iface, parameter, n, count);

-    return d3dx9_base_effect_set_int_array(&compiler->base_effect, parameter, n, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, INT *n, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, n %p, count %u.\n", iface, parameter, n, count);
+    FIXME("iface %p, parameter %p, n %p, count %u stub!\n", iface, parameter, n, count);

-    return d3dx9_base_effect_get_int_array(&compiler->base_effect, parameter, n, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float f)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, f %.8e.\n", iface, parameter, f);
+    FIXME("iface %p, parameter %p, f %.8e stub!\n", iface, parameter, f);

-    return d3dx9_base_effect_set_float(&compiler->base_effect, parameter, f);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float *f)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, f %p.\n", iface, parameter, f);
+    FIXME("iface %p, parameter %p, f %p stub!\n", iface, parameter, f);

-    return d3dx9_base_effect_get_float(&compiler->base_effect, parameter, f);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const float *f, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, f %p, count %u.\n", iface, parameter, f, count);
+    FIXME("iface %p, parameter %p, f %p, count %u stub!\n", iface, parameter, f, count);

-    return d3dx9_base_effect_set_float_array(&compiler->base_effect, parameter, f, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, float *f, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, f %p, count %u.\n", iface, parameter, f, count);
+    FIXME("iface %p, parameter %p, f %p, count %u stub!\n", iface, parameter, f, count);

-    return d3dx9_base_effect_get_float_array(&compiler->base_effect, parameter, f, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXVECTOR4 *vector)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, vector %p.\n", iface, parameter, vector);
+    FIXME("iface %p, parameter %p, vector %p stub!\n", iface, parameter, vector);

-    return d3dx9_base_effect_set_vector(&compiler->base_effect, parameter, vector);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXVECTOR4 *vector)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, vector %p stub!\n", iface, parameter, vector);

-    TRACE("iface %p, parameter %p, vector %p.\n", iface, parameter, vector);
-
-    return d3dx9_base_effect_get_vector(&compiler->base_effect, parameter, vector);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface, parameter, vector, count);
+    FIXME("iface %p, parameter %p, vector %p, count %u stub!\n", iface, parameter, vector, count);

-    return d3dx9_base_effect_set_vector_array(&compiler->base_effect, parameter, vector, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, vector %p, count %u stub!\n", iface, parameter, vector, count);

-    TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface, parameter, vector, count);
-
-    return d3dx9_base_effect_get_vector_array(&compiler->base_effect, parameter, vector, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXMATRIX *matrix)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);

-    TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
-
-    return d3dx9_base_effect_set_matrix(&compiler->base_effect, parameter, matrix);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXMATRIX *matrix)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);

-    TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
-
-    return d3dx9_base_effect_get_matrix(&compiler->base_effect, parameter, matrix);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
-
-    return d3dx9_base_effect_set_matrix_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
-
-    return d3dx9_base_effect_get_matrix_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
-
-    return d3dx9_base_effect_set_matrix_pointer_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
-
-    return d3dx9_base_effect_get_matrix_pointer_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXMATRIX *matrix)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);

-    TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
-
-    return d3dx9_base_effect_set_matrix_transpose(&compiler->base_effect, parameter, matrix);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXMATRIX *matrix)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);

-    TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
-
-    return d3dx9_base_effect_get_matrix_transpose(&compiler->base_effect, parameter, matrix);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    return d3dx9_base_effect_set_matrix_transpose_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    return d3dx9_base_effect_get_matrix_transpose_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    return d3dx9_base_effect_set_matrix_transpose_pointer_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
+    FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);

-    return d3dx9_base_effect_get_matrix_transpose_pointer_array(&compiler->base_effect, parameter, matrix, count);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const char *string)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, string %s.\n", iface, parameter, debugstr_a(string));
+    FIXME("iface %p, parameter %p, string %s stub!\n", iface, parameter, debugstr_a(string));

-    return d3dx9_base_effect_set_string(&compiler->base_effect, parameter, string);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, const char **string)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, string %p.\n", iface, parameter, string);
+    FIXME("iface %p, parameter %p, string %p stub!\n", iface, parameter, string);

-    return d3dx9_base_effect_get_string(&compiler->base_effect, parameter, string);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetTexture(struct ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, texture %p.\n", iface, parameter, texture);
+    FIXME("iface %p, parameter %p, texture %p stub!\n", iface, parameter, texture);

-    return d3dx9_base_effect_set_texture(&compiler->base_effect, parameter, texture);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTexture(struct ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, texture %p.\n", iface, parameter, texture);
+    FIXME("iface %p, parameter %p, texture %p stub!\n", iface, parameter, texture);

-    return d3dx9_base_effect_get_texture(&compiler->base_effect, parameter, texture);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, shader %p stub!\n", iface, parameter, shader);

-    TRACE("iface %p, parameter %p, shader %p.\n", iface, parameter, shader);
-
-    return d3dx9_base_effect_get_pixel_shader(&compiler->base_effect, parameter, shader);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVertexShader(struct ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, struct IDirect3DVertexShader9 **shader)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
-
-    TRACE("iface %p, parameter %p, shader %p.\n", iface, parameter, shader);
+    FIXME("iface %p, parameter %p, shader %p stub!\n", iface, parameter, shader);

-    return d3dx9_base_effect_get_vertex_shader(&compiler->base_effect, parameter, shader);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler *iface,
         D3DXHANDLE parameter, UINT start, UINT end)
 {
-    struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
+    FIXME("iface %p, parameter %p, start %u, end %u stub!\n", iface, parameter, start, end);

-    TRACE("iface %p, parameter %p, start %u, end %u.\n", iface, parameter, start, end);
-
-    return d3dx9_base_effect_set_array_range(&compiler->base_effect, parameter, start, end);
+    return E_NOTIMPL;
 }

/*** ID3DXEffectCompiler methods ***/
 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL literal)
 {
-    struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
-
-    FIXME("iface %p, parameter %p, literal %u\n", This, parameter, literal);
+    FIXME("iface %p, parameter %p, literal %#x stub!\n", iface, parameter, literal);

return E_NOTIMPL;
 }

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *literal)
 {
-    struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
-
-    FIXME("iface %p, parameter %p, literal %p\n", This, parameter, literal);
+    FIXME("iface %p, parameter %p, literal %p stub!\n", iface, parameter, literal);

return E_NOTIMPL;
 }
@@ -5219,9 +5097,7 @@ static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler *if
 static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler *iface, DWORD flags,
         ID3DXBuffer **effect, ID3DXBuffer **error_msgs)
 {
-    struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
-
-    FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This, flags, effect, error_msgs);
+    FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub!\n", iface, flags, effect, error_msgs);

return E_NOTIMPL;
 }
@@ -5230,10 +5106,8 @@ static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler
         const char *target, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_msgs,
         ID3DXConstantTable **constant_table)
 {
-    struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
-
-    FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
-            This, function, target, flags, shader, error_msgs, constant_table);
+    FIXME("iface %p, function %p, target %s, flags %#x, shader %p, error_msgs %p, constant_table %p stub!\n",
+            iface, function, debugstr_a(target), flags, shader, error_msgs, constant_table);

return E_NOTIMPL;
 }
@@ -6921,20 +6795,13 @@ static HRESULT d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl *compil
         const char *data, SIZE_T data_size, const D3D_SHADER_MACRO *defines, ID3DInclude *include,
         UINT eflags, ID3DBlob **error_messages)
 {
-    HRESULT hr;
-
-    TRACE("effect %p, data %p, data_size %lu\n", compiler, data, data_size);
+    TRACE("compiler %p, data %p, data_size %lu, defines %p, include %p, eflags %#x, error_messages %p.\n",
+            compiler, data, data_size, defines, include, eflags, error_messages);

compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
     compiler->ref = 1;

-    if (FAILED(hr = d3dx9_base_effect_init(&compiler->base_effect, data, data_size, defines,
-            include, eflags, error_messages, NULL, NULL, NULL)))
-    {
-        FIXME("Failed to parse effect, hr %#x.\n", hr);
-        free_effect_compiler(compiler);
-        return hr;
-    }
+    FIXME("ID3DXEffectCompiler implementation is only a stub.\n");

return D3D_OK;
 }
diff --git a/dlls/d3dx9_36/tests/effect.c b/dlls/d3dx9_36/tests/effect.c
index 0ae02315f4d..9693939a76b 100644
--- a/dlls/d3dx9_36/tests/effect.c
+++ b/dlls/d3dx9_36/tests/effect.c
@@ -388,7 +388,7 @@ static void test_create_effect_compiler(void)
     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

hr = D3DXCreateEffectCompiler(effect_desc, 0, NULL, NULL, 0, &compiler, NULL);
-    todo_wine ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
+    ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
     if (FAILED(hr))
     {
         skip("D3DXCreateEffectCompiler failed, skipping test.\n");

[PATCH v2 06/10] d3d8: Forbid setting a viewport larger than the render target.

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
v2: Fix extents check.

dlls/d3d8/device.c | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c
index 4fcad71451e..3a676b0fd4c 100644
--- a/dlls/d3d8/device.c
+++ b/dlls/d3d8/device.c
@@ -1638,10 +1638,30 @@ static HRESULT WINAPI d3d8_device_MultiplyTransform(IDirect3DDevice8 *iface,
 static HRESULT WINAPI d3d8_device_SetViewport(IDirect3DDevice8 *iface, const D3DVIEWPORT8 *viewport)
 {
     struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
+    struct wined3d_sub_resource_desc rt_desc;
+    struct wined3d_rendertarget_view *rtv;
+    struct d3d8_surface *surface;
     struct wined3d_viewport vp;

TRACE("iface %p, viewport %p.\n", iface, viewport);

+    wined3d_mutex_lock();
+    if (!(rtv = wined3d_device_get_rendertarget_view(device->wined3d_device, 0)))
+    {
+        wined3d_mutex_unlock();
+        return D3DERR_NOTFOUND;
+    }
+    surface = wined3d_rendertarget_view_get_sub_resource_parent(rtv);
+    wined3d_texture_get_sub_resource_desc(surface->wined3d_texture, surface->sub_resource_idx, &rt_desc);
+
+    if (viewport->X > rt_desc.width || viewport->Width > rt_desc.width - viewport->X
+            || viewport->Y > rt_desc.height || viewport->Height > rt_desc.height - viewport->Y)
+    {
+        WARN("Invalid viewport, returning D3DERR_INVALIDCALL.\n");
+        wined3d_mutex_unlock();
+        return D3DERR_INVALIDCALL;
+    }
+
     vp.x = viewport->X;
     vp.y = viewport->Y;
     vp.width = viewport->Width;
@@ -1649,7 +1669,6 @@ static HRESULT WINAPI d3d8_device_SetViewport(IDirect3DDevice8 *iface, const D3D
     vp.min_z = viewport->MinZ;
     vp.max_z = viewport->MaxZ;

-    wined3d_mutex_lock();
     wined3d_device_set_viewport(device->wined3d_device, &vp);
     wined3d_mutex_unlock();

[PATCH v2 06/10] d3d8: Forbid setting a viewport larger than the render target.

[Henri Verbeet]

Signed-off-by: Henri Verbeet

[PATCH v2 07/10] d3d8/tests: Port test_viewport() to d3d8.

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
v2: Minor cleanups, add a couple additional RT sizes.

dlls/d3d8/tests/visual.c | 156 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)

diff --git a/dlls/d3d8/tests/visual.c b/dlls/d3d8/tests/visual.c
index b64f08c8a15..c2a4abfc049 100644
--- a/dlls/d3d8/tests/visual.c
+++ b/dlls/d3d8/tests/visual.c
@@ -196,6 +196,45 @@ static D3DCOLOR get_surface_color(IDirect3DSurface8 *surface, UINT x, UINT y)
     return color;
 }

+static void check_rect(struct surface_readback *rb, RECT r, const char *message)
+{
+    LONG x_coords[2][2] =
+    {
+        {r.left - 1, r.left + 1},
+        {r.right + 1, r.right - 1},
+    };
+    LONG y_coords[2][2] =
+    {
+        {r.top - 1, r.top + 1},
+        {r.bottom + 1, r.bottom - 1}
+    };
+    unsigned int i, j, x_side, y_side;
+    DWORD color;
+    LONG x, y;
+
+    for (i = 0; i < 2; ++i)
+    {
+        for (j = 0; j < 2; ++j)
+        {
+            for (x_side = 0; x_side < 2; ++x_side)
+            {
+                for (y_side = 0; y_side < 2; ++y_side)
+                {
+                    DWORD expected = (x_side == 1 && y_side == 1) ? 0xffffffff : 0xff000000;
+
+                    x = x_coords[i][x_side];
+                    y = y_coords[j][y_side];
+                    if (x < 0 || x >= 640 || y < 0 || y >= 480)
+                        continue;
+                    color = get_readback_color(rb, x, y);
+                    ok(color == expected, "%s: Pixel (%d, %d) has color %08x, expected %08x.\n",
+                            message, x, y, color, expected);
+                }
+            }
+        }
+    }
+}
+
 static IDirect3DDevice8 *create_device(IDirect3D8 *d3d, HWND device_window, HWND focus_window, BOOL windowed)
 {
     D3DPRESENT_PARAMETERS present_parameters = {0};
@@ -10132,6 +10171,122 @@ done:
     DestroyWindow(window);
 }

+static void test_viewport(void)
+{
+    static const struct
+    {
+        D3DVIEWPORT8 vp;
+        RECT expected_rect;
+        const char *message;
+    }
+    tests[] =
+    {
+        {{  0,   0,  640,  480}, {  0, 120, 479, 359}, "Viewport (0, 0) - (640, 480)"},
+        {{  0,   0,  320,  240}, {  0,  60, 239, 179}, "Viewport (0, 0) - (320, 240)"},
+        {{  0,   0, 1280,  960}, {  0, 240, 639, 479}, "Viewport (0, 0) - (1280, 960)"},
+        {{  0,   0, 2000, 1600}, {-10, -10, -10, -10}, "Viewport (0, 0) - (2000, 1600)"},
+        {{100, 100,  640,  480}, {100, 220, 579, 459}, "Viewport (100, 100) - (640, 480)"},
+        {{  0,   0, 8192, 8192}, {-10, -10, -10, -10}, "Viewport (0, 0) - (8192, 8192)"},
+    };
+    static const struct vec3 quad[] =
+    {
+        {-1.5f, -0.5f, 0.1f},
+        {-1.5f,  0.5f, 0.1f},
+        { 0.5f, -0.5f, 0.1f},
+        { 0.5f,  0.5f, 0.1f},
+    };
+    static const struct vec2 rt_sizes[] =
+    {
+        {640, 480}, {1280, 960}, {320, 240}, {800, 600},
+    };
+    struct surface_readback rb;
+    IDirect3DDevice8 *device;
+    IDirect3DSurface8 *rt;
+    unsigned int i, j;
+    IDirect3D8 *d3d;
+    ULONG refcount;
+    HWND window;
+    HRESULT hr;
+
+    window = create_window();
+    d3d = Direct3DCreate8(D3D_SDK_VERSION);
+    ok(!!d3d, "Failed to create a D3D object.\n");
+    if (!(device = create_device(d3d, window, window, TRUE)))
+    {
+        skip("Failed to create a D3D device, skipping tests.\n");
+        goto done;
+    }
+
+    hr = IDirect3DDevice8_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
+    ok(SUCCEEDED(hr), "Failed to disable depth test, hr %#x.\n", hr);
+    hr = IDirect3DDevice8_SetRenderState(device, D3DRS_LIGHTING, FALSE);
+    ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr);
+
+    hr = IDirect3DDevice8_SetVertexShader(device, D3DFVF_XYZ);
+    ok(SUCCEEDED(hr), "Failed to set FVF, hr %#x.\n", hr);
+
+    /* This crashes on Windows. */
+    /* hr = IDirect3DDevice8_SetViewport(device, NULL); */
+
+    for (i = 0; i < sizeof(rt_sizes) / sizeof(rt_sizes[0]); ++i)
+    {
+        if (i)
+        {
+            hr = IDirect3DDevice8_CreateRenderTarget(device, rt_sizes[i].x, rt_sizes[i].y,
+                    D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, TRUE, &rt);
+            ok(SUCCEEDED(hr), "Failed to create render target, hr %#x (i %u).\n", hr, i);
+            hr = IDirect3DDevice8_SetRenderTarget(device, rt, NULL);
+            ok(SUCCEEDED(hr), "Failed to set render target, hr %#x (i %u).\n", hr, i);
+        }
+        else
+        {
+            hr = IDirect3DDevice8_GetBackBuffer(device, 0, D3DBACKBUFFER_TYPE_MONO, &rt);
+            ok(SUCCEEDED(hr), "Failed to get backbuffer, hr %#x.\n", hr);
+        }
+
+        for (j = 0; j < sizeof(tests) / sizeof(tests[0]); ++j)
+        {
+            hr = IDirect3DDevice8_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 1.0f, 0);
+            ok(SUCCEEDED(hr), "Failed to clear, hr %#x (i %u, j %u).\n", hr, i, j);
+
+            hr = IDirect3DDevice8_SetViewport(device, &tests[j].vp);
+            if (tests[j].vp.X + tests[j].vp.Width > rt_sizes[i].x
+                    || tests[j].vp.Y + tests[j].vp.Height > rt_sizes[i].y)
+            {
+                ok(hr == D3DERR_INVALIDCALL,
+                        "Setting the viewport returned unexpected hr %#x (i %u, j %u).\n", hr, i, j);
+                continue;
+            }
+            else
+            {
+                ok(SUCCEEDED(hr), "Failed to set the viewport, hr %#x (i %u, j %u).\n", hr, i, j);
+            }
+
+            hr = IDirect3DDevice8_BeginScene(device);
+            ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x (i %u, j %u).\n", hr, i, j);
+            hr = IDirect3DDevice8_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
+            ok(SUCCEEDED(hr), "Got unexpected hr %#x (i %u, j %u).\n", hr, i, j);
+            hr = IDirect3DDevice8_EndScene(device);
+            ok(SUCCEEDED(hr), "Failed to end scene, hr %#x (i %u, j %u).\n", hr, i, j);
+
+            get_rt_readback(rt, &rb);
+            check_rect(&rb, tests[j].expected_rect, tests[j].message);
+            release_surface_readback(&rb);
+        }
+
+        IDirect3DSurface8_Release(rt);
+    }
+
+    hr = IDirect3DDevice8_Present(device, NULL, NULL, NULL, NULL);
+    ok(SUCCEEDED(hr), "Failed to present, hr %#x.\n", hr);
+
+    refcount = IDirect3DDevice8_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+done:
+    IDirect3D8_Release(d3d);
+    DestroyWindow(window);
+}
+
 START_TEST(visual)
 {
     D3DADAPTER_IDENTIFIER8 identifier;
@@ -10204,4 +10359,5 @@ START_TEST(visual)
     test_backbuffer_resize();
     test_drawindexedprimitiveup();
     test_map_synchronisation();
+    test_viewport();
 }

[PATCH v2 07/10] d3d8/tests: Port test_viewport() to d3d8.

[Henri Verbeet]

Signed-off-by: Henri Verbeet

[PATCH v2 08/10] ddraw: Forbid setting a viewport larger than the render target.

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
v2: Fix extents check.

dlls/ddraw/device.c | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/dlls/ddraw/device.c b/dlls/ddraw/device.c
index 75e000aa096..38fcc00e6b6 100644
--- a/dlls/ddraw/device.c
+++ b/dlls/ddraw/device.c
@@ -5315,6 +5315,9 @@ static HRESULT WINAPI d3d_device7_Clear_FPUPreserve(IDirect3DDevice7 *iface, DWO
 static HRESULT d3d_device7_SetViewport(IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
 {
     struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
+    struct wined3d_sub_resource_desc rt_desc;
+    struct wined3d_rendertarget_view *rtv;
+    struct ddraw_surface *surface;
     struct wined3d_viewport vp;

TRACE("iface %p, viewport %p.\n", iface, viewport);
@@ -5322,6 +5325,23 @@ static HRESULT d3d_device7_SetViewport(IDirect3DDevice7 *iface, D3DVIEWPORT7 *vi
     if (!viewport)
         return DDERR_INVALIDPARAMS;

+    wined3d_mutex_lock();
+    if (!(rtv = wined3d_device_get_rendertarget_view(device->wined3d_device, 0)))
+    {
+        wined3d_mutex_unlock();
+        return DDERR_INVALIDCAPS;
+    }
+    surface = wined3d_rendertarget_view_get_sub_resource_parent(rtv);
+    wined3d_texture_get_sub_resource_desc(surface->wined3d_texture, surface->sub_resource_idx, &rt_desc);
+
+    if (viewport->dwX > rt_desc.width || viewport->dwWidth > rt_desc.width - viewport->dwX
+            || viewport->dwY > rt_desc.height || viewport->dwHeight > rt_desc.height - viewport->dwY)
+    {
+        WARN("Invalid viewport, returning E_INVALIDARG.\n");
+        wined3d_mutex_unlock();
+        return E_INVALIDARG;
+    }
+
     vp.x = viewport->dwX;
     vp.y = viewport->dwY;
     vp.width = viewport->dwWidth;
@@ -5329,7 +5349,6 @@ static HRESULT d3d_device7_SetViewport(IDirect3DDevice7 *iface, D3DVIEWPORT7 *vi
     vp.min_z = viewport->dvMinZ;
     vp.max_z = viewport->dvMaxZ;

-    wined3d_mutex_lock();
     wined3d_device_set_viewport(device->wined3d_device, &vp);
     wined3d_mutex_unlock();

[PATCH 09/10] ddraw: Reset wined3d viewport on SetRenderTarget().

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
Generally the viewport is explicitly set again immediately after the
SetRenderTarget() so you wouldn't notice the difference. The ddraw7
test_viewport() does a Clear() before that though and, without this
patch, it crashes in surface_cpu_blt_colour_fill() when switching from
the 1280x960 to the 320x240 RT.

I guess another option is to fix this in wined3d (instead OR in
addition to this).

dlls/ddraw/device.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dlls/ddraw/device.c b/dlls/ddraw/device.c
index 38fcc00e6b6..6858a1bb645 100644
--- a/dlls/ddraw/device.c
+++ b/dlls/ddraw/device.c
@@ -1818,7 +1818,7 @@ static HRESULT d3d_device_set_render_target(struct d3d_device *device,
     }

if (FAILED(hr = wined3d_device_set_rendertarget_view(device->wined3d_device,
-            0, ddraw_surface_get_rendertarget_view(target), FALSE)))
+            0, ddraw_surface_get_rendertarget_view(target), TRUE)))
         return hr;

IUnknown_AddRef(rt_iface);

[PATCH 09/10] ddraw: Reset wined3d viewport on SetRenderTarget().

[Henri Verbeet]

On 22 March 2018 at 21:43, Matteo Bruni  wrote:
> Signed-off-by: Matteo Bruni
>
> Generally the viewport is explicitly set again immediately after the
> SetRenderTarget() so you wouldn't notice the difference. The ddraw7
> test_viewport() does a Clear() before that though and, without this
> patch, it crashes in surface_cpu_blt_colour_fill() when switching from
> the 1280x960 to the 320x240 RT.
>
> I guess another option is to fix this in wined3d (instead OR in
> addition to this).
>
> dlls/ddraw/device.c | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)

This causes test failures here:

../../../../../src/wine-git/tools/runtest -q -P wine -T ../../..
-M ddraw.dll -p ddraw_test.exe.so d3d && touch d3d.ok
    d3d.c:2554: Test failed: vp.dwX is 0, expected 10
    d3d.c:2555: Test failed: vp.dwY is 0, expected 10
    d3d.c:2556: Test failed: vp.dwWidth is 64, expected 246
    d3d.c:2557: Test failed: vp.dwHeight is 64, expected 246
    d3d.c:2558: Test failed: vp.dvMinZ is 0.000000, expected 0.25
    d3d.c:2559: Test failed: vp.dvMaxZ is 1.000000, expected 0.75
    d3d.c:2582: Test failed: vp.dwWidth is 256, expected 64
    d3d.c:2583: Test failed: vp.dwHeight is 256, expected 64
    d3d.c:2595: Test failed: vp.dwWidth is 256, expected 64
    d3d.c:2596: Test failed: vp.dwHeight is 256, expected 64
    Makefile:193: recipe for target 'd3d.ok' failed
    make: *** [d3d.ok] Error 10

[PATCH v2 10/10] ddraw/tests: Port test_viewport() to ddraw7.

[Matteo Bruni]

Signed-off-by: Matteo Bruni 
---
v2: Properly attach a depth buffer to the offscreen surfaces, some
minor cleanups, add a couple more RT sizes (actually 320x240 after
1280x960 crashed without the d3d_device_set_render_target() fix).

dlls/ddraw/tests/ddraw7.c | 177 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 177 insertions(+)

diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c
index 3f433a6765b..ccac01c5f89 100644
--- a/dlls/ddraw/tests/ddraw7.c
+++ b/dlls/ddraw/tests/ddraw7.c
@@ -280,6 +280,45 @@ static D3DCOLOR get_surface_color(IDirectDrawSurface7 *surface, UINT x, UINT y)
     return color;
 }

+static void check_rect(IDirectDrawSurface7 *surface, RECT r, const char *message)
+{
+    LONG x_coords[2][2] =
+    {
+        {r.left - 1, r.left + 1},
+        {r.right + 1, r.right - 1},
+    };
+    LONG y_coords[2][2] =
+    {
+        {r.top - 1, r.top + 1},
+        {r.bottom + 1, r.bottom - 1}
+    };
+    unsigned int i, j, x_side, y_side;
+    DWORD color;
+    LONG x, y;
+
+    for (i = 0; i < 2; ++i)
+    {
+        for (j = 0; j < 2; ++j)
+        {
+            for (x_side = 0; x_side < 2; ++x_side)
+            {
+                for (y_side = 0; y_side < 2; ++y_side)
+                {
+                    DWORD expected = (x_side == 1 && y_side == 1) ? 0x00ffffff : 0x00000000;
+
+                    x = x_coords[i][x_side];
+                    y = y_coords[j][y_side];
+                    if (x < 0 || x >= 640 || y < 0 || y >= 480)
+                        continue;
+                    color = get_surface_color(surface, x, y);
+                    ok(color == expected, "%s: Pixel (%d, %d) has color %08x, expected %08x.\n",
+                            message, x, y, color, expected);
+                }
+            }
+        }
+    }
+}
+
 static HRESULT CALLBACK enum_z_fmt(DDPIXELFORMAT *format, void *ctx)
 {
     DDPIXELFORMAT *z_fmt = ctx;
@@ -14095,6 +14134,143 @@ static void test_enum_surfaces(void)
     IDirectDraw7_Release(ddraw);
 }

+static void test_viewport(void)
+{
+    static struct
+    {
+        D3DVIEWPORT7 vp;
+        RECT expected_rect;
+        const char *message;
+    }
+    tests[] =
+    {
+        {{  0,   0,  640,  480}, {  0, 120, 479, 359}, "Viewport (0, 0) - (640, 480)"},
+        {{  0,   0,  320,  240}, {  0,  60, 239, 179}, "Viewport (0, 0) - (320, 240)"},
+        {{  0,   0, 1280,  960}, {  0, 240, 639, 479}, "Viewport (0, 0) - (1280, 960)"},
+        {{  0,   0, 2000, 1600}, {-10, -10, -10, -10}, "Viewport (0, 0) - (2000, 1600)"},
+        {{100, 100,  640,  480}, {100, 220, 579, 459}, "Viewport (100, 100) - (640, 480)"},
+        {{  0,   0, 8192, 8192}, {-10, -10, -10, -10}, "Viewport (0, 0) - (8192, 8192)"},
+    };
+    static struct vec3 quad[] =
+    {
+        {-1.5f, -0.5f, 0.1f},
+        {-1.5f,  0.5f, 0.1f},
+        { 0.5f, -0.5f, 0.1f},
+        { 0.5f,  0.5f, 0.1f},
+    };
+    static const struct vec2 rt_sizes[] =
+    {
+        {640, 480}, {1280, 960}, {320, 240}, {800, 600},
+    };
+    IDirectDrawSurface7 *rt, *ds;
+    DDSURFACEDESC2 surface_desc;
+    IDirect3DDevice7 *device;
+    IDirectDraw7 *ddraw;
+    DDPIXELFORMAT z_fmt;
+    unsigned int i, j;
+    IDirect3D7 *d3d;
+    ULONG refcount;
+    HWND window;
+    HRESULT hr;
+
+    window = CreateWindowA("static", "d3d7_test", WS_OVERLAPPEDWINDOW,
+            0, 0, 640, 480, 0, 0, 0, 0);
+    if (!(device = create_device(window, DDSCL_NORMAL)))
+    {
+        skip("Failed to create a 3D device, skipping test.\n");
+        DestroyWindow(window);
+        return;
+    }
+
+    hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
+    ok(SUCCEEDED(hr), "Failed to get Direct3D7 interface, hr %#x.\n", hr);
+    hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
+    ok(SUCCEEDED(hr), "Failed to get ddraw interface, hr %#x.\n", hr);
+    IDirect3D7_Release(d3d);
+
+    hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, D3DZB_FALSE);
+    ok(SUCCEEDED(hr), "Failed to disable depth test, hr %#x.\n", hr);
+    hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
+    ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr);
+
+    hr = IDirect3DDevice7_SetViewport(device, NULL);
+    ok(hr == E_INVALIDARG, "Setting NULL viewport data returned unexpected hr %#x.\n", hr);
+
+    ds = get_depth_stencil(device);
+    memset(&surface_desc, 0, sizeof(surface_desc));
+    surface_desc.dwSize = sizeof(surface_desc);
+    hr = IDirectDrawSurface7_GetSurfaceDesc(ds, &surface_desc);
+    z_fmt = U4(surface_desc).ddpfPixelFormat;
+
+    for (i = 0; i < sizeof(rt_sizes) / sizeof(rt_sizes[0]); ++i)
+    {
+        if (i)
+        {
+            memset(&surface_desc, 0, sizeof(surface_desc));
+            surface_desc.dwSize = sizeof(surface_desc);
+            surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
+            surface_desc.dwWidth = rt_sizes[i].x;
+            surface_desc.dwHeight = rt_sizes[i].y;
+            surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
+            hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &rt, NULL);
+            ok(SUCCEEDED(hr), "Failed to create render target, hr %#x (i %u).\n", hr, i);
+
+            surface_desc.dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT;
+            surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
+            U4(surface_desc).ddpfPixelFormat = z_fmt;
+            hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &ds, NULL);
+            ok(SUCCEEDED(hr), "Failed to create depth buffer, hr %#x (i %u).\n", hr, i);
+            hr = IDirectDrawSurface7_AddAttachedSurface(rt, ds);
+            ok(SUCCEEDED(hr), "Failed to attach depth buffer, hr %#x (i %u).\n", hr, i);
+
+            hr = IDirect3DDevice7_SetRenderTarget(device, rt, 0);
+            ok(SUCCEEDED(hr), "Failed to set render target, hr %#x (i %u).\n", hr, i);
+        }
+        else
+        {
+            hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
+            ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
+        }
+
+        for (j = 0; j < sizeof(tests) / sizeof(tests[0]); ++j)
+        {
+            hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 1.0f, 0);
+            ok(SUCCEEDED(hr), "Failed to clear, hr %#x (i %u, j %u).\n", hr, i, j);
+
+            hr = IDirect3DDevice7_SetViewport(device, &tests[j].vp);
+            if (tests[j].vp.dwX + tests[j].vp.dwWidth > rt_sizes[i].x
+                    || tests[j].vp.dwY + tests[j].vp.dwHeight > rt_sizes[i].y)
+            {
+                ok(hr == E_INVALIDARG, "Setting the viewport returned unexpected hr %#x (i %u, j %u).\n", hr, i, j);
+                continue;
+            }
+            else
+            {
+                ok(SUCCEEDED(hr), "Failed to set the viewport, hr %#x (i %u, j %u).\n", hr, i, j);
+            }
+
+            hr = IDirect3DDevice7_BeginScene(device);
+            ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x (i %u, j %u).\n", hr, i, j);
+            hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ, quad, 4, 0);
+            ok(SUCCEEDED(hr), "Got unexpected hr %#x (i %u, j %u).\n", hr, i, j);
+            hr = IDirect3DDevice7_EndScene(device);
+            ok(SUCCEEDED(hr), "Failed to end scene, hr %#x (i %u, j %u).\n", hr, i, j);
+
+            check_rect(rt, tests[j].expected_rect, tests[j].message);
+        }
+
+        hr = IDirectDrawSurface7_DeleteAttachedSurface(rt, 0, ds);
+        ok(SUCCEEDED(hr), "Failed to detach surface, hr %#x (i %u).\n", hr, i);
+        IDirectDrawSurface7_Release(ds);
+
+        IDirectDrawSurface7_Release(rt);
+    }
+
+    refcount = IDirect3DDevice7_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+    DestroyWindow(window);
+}
+
 START_TEST(ddraw7)
 {
     DDDEVICEIDENTIFIER2 identifier;
@@ -14229,4 +14405,5 @@ START_TEST(ddraw7)
     test_depth_readback();
     test_clear();
     test_enum_surfaces();
+    test_viewport();
 }