[PATCH 0/1] MR8277: d3d11: Implement CreateRasterizerState2().

[Elizabeth Figura (＠zfigura)]

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/8277

[PATCH 1/1] d3d11: Implement CreateRasterizerState2().

[Elizabeth Figura]

From: Elizabeth Figura <zfigura(a)codeweavers.com>

---
 dlls/d3d11/d3d11_private.h |  6 +--
 dlls/d3d11/device.c        | 52 +++++++++++++++++--------
 dlls/d3d11/state.c         | 79 +++++++++++++++++++++++---------------
 dlls/d3d11/tests/d3d11.c   | 28 ++++++++++++++
 4 files changed, 115 insertions(+), 50 deletions(-)

diff --git a/dlls/d3d11/d3d11_private.h b/dlls/d3d11/d3d11_private.h
index 89385b019a6..d9cb912a034 100644
--- a/dlls/d3d11/d3d11_private.h
+++ b/dlls/d3d11/d3d11_private.h
@@ -470,18 +470,18 @@ struct d3d_depthstencil_state *unsafe_impl_from_ID3D10DepthStencilState(
 /* ID3D11RasterizerState, ID3D10RasterizerState */
 struct d3d_rasterizer_state
 {
-    ID3D11RasterizerState1 ID3D11RasterizerState1_iface;
+    ID3D11RasterizerState2 ID3D11RasterizerState2_iface;
     ID3D10RasterizerState ID3D10RasterizerState_iface;
     LONG refcount;
 
     struct wined3d_private_store private_store;
     struct wined3d_rasterizer_state *wined3d_state;
-    D3D11_RASTERIZER_DESC1 desc;
+    D3D11_RASTERIZER_DESC2 desc;
     struct wine_rb_entry entry;
     ID3D11Device5 *device;
 };
 
-HRESULT d3d_rasterizer_state_create(struct d3d_device *device, const D3D11_RASTERIZER_DESC1 *desc,
+HRESULT d3d_rasterizer_state_create(struct d3d_device *device, const D3D11_RASTERIZER_DESC2 *desc,
         struct d3d_rasterizer_state **state);
 struct d3d_rasterizer_state *unsafe_impl_from_ID3D11RasterizerState(ID3D11RasterizerState *iface);
 struct d3d_rasterizer_state *unsafe_impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface);
diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c
index 1521ef92fa7..2c52721253d 100644
--- a/dlls/d3d11/device.c
+++ b/dlls/d3d11/device.c
@@ -2292,7 +2292,7 @@ static void STDMETHODCALLTYPE d3d11_device_context_RSGetState(ID3D11DeviceContex
     if ((wined3d_state = wined3d_device_context_get_rasterizer_state(context->wined3d_context)))
     {
         rasterizer_state_impl = wined3d_rasterizer_state_get_parent(wined3d_state);
-        *rasterizer_state = (ID3D11RasterizerState *)&rasterizer_state_impl->ID3D11RasterizerState1_iface;
+        *rasterizer_state = (ID3D11RasterizerState *)&rasterizer_state_impl->ID3D11RasterizerState2_iface;
         ID3D11RasterizerState_AddRef(*rasterizer_state);
     }
     else
@@ -4458,7 +4458,7 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState(ID3D11Device
 {
     struct d3d_device *device = impl_from_ID3D11Device5(iface);
     struct d3d_rasterizer_state *object;
-    D3D11_RASTERIZER_DESC1 desc1;
+    D3D11_RASTERIZER_DESC2 desc2;
     HRESULT hr;
 
     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
@@ -4466,13 +4466,14 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState(ID3D11Device
     if (!desc)
         return E_INVALIDARG;
 
-    memcpy(&desc1, desc, sizeof(*desc));
-    desc1.ForcedSampleCount = 0;
+    memcpy(&desc2, desc, sizeof(*desc));
+    desc2.ForcedSampleCount = 0;
+    desc2.ConservativeRaster = D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF;
 
-    if (FAILED(hr = d3d_rasterizer_state_create(device, &desc1, &object)))
+    if (FAILED(hr = d3d_rasterizer_state_create(device, &desc2, &object)))
         return hr;
 
-    *rasterizer_state = (ID3D11RasterizerState *)&object->ID3D11RasterizerState1_iface;
+    *rasterizer_state = (ID3D11RasterizerState *)&object->ID3D11RasterizerState2_iface;
 
     return S_OK;
 }
@@ -5136,6 +5137,7 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState1(ID3D11Devic
 {
     struct d3d_device *device = impl_from_ID3D11Device5(iface);
     struct d3d_rasterizer_state *object;
+    D3D11_RASTERIZER_DESC2 desc2;
     HRESULT hr;
 
     TRACE("iface %p, desc %p, state %p.\n", iface, desc, state);
@@ -5143,10 +5145,13 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState1(ID3D11Devic
     if (!desc)
         return E_INVALIDARG;
 
-    if (FAILED(hr = d3d_rasterizer_state_create(device, desc, &object)))
+    memcpy(&desc2, desc, sizeof(*desc));
+    desc2.ConservativeRaster = D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF;
+
+    if (FAILED(hr = d3d_rasterizer_state_create(device, &desc2, &object)))
         return hr;
 
-    *state = &object->ID3D11RasterizerState1_iface;
+    *state = (ID3D11RasterizerState1 *)&object->ID3D11RasterizerState2_iface;
 
     return S_OK;
 }
@@ -5292,9 +5297,21 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CreateTexture3D1(ID3D11Device5 *if
 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateRasterizerState2(ID3D11Device5 *iface,
         const D3D11_RASTERIZER_DESC2 *desc, ID3D11RasterizerState2 **state)
 {
-    FIXME("iface %p, desc %p, state %p stub!\n", iface, desc, state);
+    struct d3d_device *device = impl_from_ID3D11Device5(iface);
+    struct d3d_rasterizer_state *object;
+    HRESULT hr;
 
-    return E_NOTIMPL;
+    TRACE("iface %p, desc %p, state %p.\n", iface, desc, state);
+
+    if (!desc)
+        return E_INVALIDARG;
+
+    if (FAILED(hr = d3d_rasterizer_state_create(device, desc, &object)))
+        return hr;
+
+    *state = &object->ID3D11RasterizerState2_iface;
+
+    return S_OK;
 }
 
 static HRESULT STDMETHODCALLTYPE d3d11_device_CreateShaderResourceView1(ID3D11Device5 *iface,
@@ -6037,7 +6054,7 @@ static void STDMETHODCALLTYPE d3d10_device_RSSetState(ID3D10Device1 *iface, ID3D
 
     rasterizer_state_object = unsafe_impl_from_ID3D10RasterizerState(rasterizer_state);
     d3d11_device_context_RSSetState(&device->immediate_context.ID3D11DeviceContext4_iface,
-            rasterizer_state_object ? (ID3D11RasterizerState *)&rasterizer_state_object->ID3D11RasterizerState1_iface : NULL);
+            rasterizer_state_object ? (ID3D11RasterizerState *)&rasterizer_state_object->ID3D11RasterizerState2_iface : NULL);
 }
 
 static void STDMETHODCALLTYPE d3d10_device_RSSetViewports(ID3D10Device1 *iface,
@@ -7331,7 +7348,7 @@ static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRasterizerState(ID3D10Device
 {
     struct d3d_device *device = impl_from_ID3D10Device(iface);
     struct d3d_rasterizer_state *object;
-    D3D11_RASTERIZER_DESC1 desc1;
+    D3D11_RASTERIZER_DESC2 desc2;
     HRESULT hr;
 
     TRACE("iface %p, desc %p, rasterizer_state %p.\n", iface, desc, rasterizer_state);
@@ -7339,10 +7356,11 @@ static HRESULT STDMETHODCALLTYPE d3d10_device_CreateRasterizerState(ID3D10Device
     if (!desc)
         return E_INVALIDARG;
 
-    memcpy(&desc1, desc, sizeof(*desc));
-    desc1.ForcedSampleCount = 0;
+    memcpy(&desc2, desc, sizeof(*desc));
+    desc2.ForcedSampleCount = 0;
+    desc2.ConservativeRaster = D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF;
 
-    if (FAILED(hr = d3d_rasterizer_state_create(device, &desc1, &object)))
+    if (FAILED(hr = d3d_rasterizer_state_create(device, &desc2, &object)))
         return hr;
 
     *rasterizer_state = &object->ID3D10RasterizerState_iface;
@@ -8117,8 +8135,8 @@ static int d3d_depthstencil_state_compare(const void *key, const struct wine_rb_
 
 static int d3d_rasterizer_state_compare(const void *key, const struct wine_rb_entry *entry)
 {
-    const D3D11_RASTERIZER_DESC1 *ka = key;
-    const D3D11_RASTERIZER_DESC1 *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_rasterizer_state, entry)->desc;
+    const D3D11_RASTERIZER_DESC2 *ka = key;
+    const D3D11_RASTERIZER_DESC2 *kb = &WINE_RB_ENTRY_VALUE(entry, const struct d3d_rasterizer_state, entry)->desc;
 
     return memcmp(ka, kb, sizeof(*ka));
 }
diff --git a/dlls/d3d11/state.c b/dlls/d3d11/state.c
index 18ceb76049d..9914377c6c0 100644
--- a/dlls/d3d11/state.c
+++ b/dlls/d3d11/state.c
@@ -887,15 +887,15 @@ struct d3d_depthstencil_state *unsafe_impl_from_ID3D10DepthStencilState(ID3D10De
 
 /* ID3D11RasterizerState methods */
 
-static inline struct d3d_rasterizer_state *impl_from_ID3D11RasterizerState1(ID3D11RasterizerState1 *iface)
+static inline struct d3d_rasterizer_state *impl_from_ID3D11RasterizerState2(ID3D11RasterizerState2 *iface)
 {
-    return CONTAINING_RECORD(iface, struct d3d_rasterizer_state, ID3D11RasterizerState1_iface);
+    return CONTAINING_RECORD(iface, struct d3d_rasterizer_state, ID3D11RasterizerState2_iface);
 }
 
-static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_QueryInterface(ID3D11RasterizerState1 *iface,
+static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_QueryInterface(ID3D11RasterizerState2 *iface,
         REFIID riid, void **object)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
 
     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 
@@ -904,7 +904,7 @@ static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_QueryInterface(ID3D11Ras
             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
             || IsEqualGUID(riid, &IID_IUnknown))
     {
-        ID3D11RasterizerState1_AddRef(iface);
+        ID3D11RasterizerState2_AddRef(iface);
         *object = iface;
         return S_OK;
     }
@@ -923,9 +923,9 @@ static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_QueryInterface(ID3D11Ras
     return E_NOINTERFACE;
 }
 
-static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_AddRef(ID3D11RasterizerState1 *iface)
+static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_AddRef(ID3D11RasterizerState2 *iface)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
     ULONG refcount = InterlockedIncrement(&state->refcount);
 
     TRACE("%p increasing refcount to %lu.\n", state, refcount);
@@ -939,9 +939,9 @@ static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_AddRef(ID3D11RasterizerSta
     return refcount;
 }
 
-static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_Release(ID3D11RasterizerState1 *iface)
+static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_Release(ID3D11RasterizerState2 *iface)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
     ULONG refcount = InterlockedDecrement(&state->refcount);
 
     TRACE("%p decreasing refcount to %lu.\n", state, refcount);
@@ -956,10 +956,10 @@ static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_Release(ID3D11RasterizerSt
     return refcount;
 }
 
-static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDevice(ID3D11RasterizerState1 *iface,
+static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDevice(ID3D11RasterizerState2 *iface,
         ID3D11Device **device)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
 
     TRACE("iface %p, device %p.\n", iface, device);
 
@@ -967,57 +967,67 @@ static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDevice(ID3D11RasterizerS
     ID3D11Device_AddRef(*device);
 }
 
-static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_GetPrivateData(ID3D11RasterizerState1 *iface,
+static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_GetPrivateData(ID3D11RasterizerState2 *iface,
         REFGUID guid, UINT *data_size, void *data)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
 
     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 
     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 }
 
-static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateData(ID3D11RasterizerState1 *iface,
+static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateData(ID3D11RasterizerState2 *iface,
         REFGUID guid, UINT data_size, const void *data)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
 
     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 
     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 }
 
-static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateDataInterface(ID3D11RasterizerState1 *iface,
+static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateDataInterface(ID3D11RasterizerState2 *iface,
         REFGUID guid, const IUnknown *data)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
 
     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 
     return d3d_set_private_data_interface(&state->private_store, guid, data);
 }
 
-static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDesc(ID3D11RasterizerState1 *iface,
+static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDesc(ID3D11RasterizerState2 *iface,
         D3D11_RASTERIZER_DESC *desc)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
 
     TRACE("iface %p, desc %p.\n", iface, desc);
 
     memcpy(desc, &state->desc, sizeof(*desc));
 }
 
-static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDesc1(ID3D11RasterizerState1 *iface,
+static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDesc1(ID3D11RasterizerState2 *iface,
         D3D11_RASTERIZER_DESC1 *desc)
 {
-    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState1(iface);
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
+
+    TRACE("iface %p, desc %p.\n", iface, desc);
+
+    memcpy(desc, &state->desc, sizeof(*desc));
+}
+
+static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDesc2(ID3D11RasterizerState2 *iface,
+        D3D11_RASTERIZER_DESC2 *desc)
+{
+    struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState2(iface);
 
     TRACE("iface %p, desc %p.\n", iface, desc);
 
     *desc = state->desc;
 }
 
-static const struct ID3D11RasterizerState1Vtbl d3d11_rasterizer_state_vtbl =
+static const struct ID3D11RasterizerState2Vtbl d3d11_rasterizer_state_vtbl =
 {
     /* IUnknown methods */
     d3d11_rasterizer_state_QueryInterface,
@@ -1032,6 +1042,8 @@ static const struct ID3D11RasterizerState1Vtbl d3d11_rasterizer_state_vtbl =
     d3d11_rasterizer_state_GetDesc,
     /* ID3D11RasterizerState1 methods */
     d3d11_rasterizer_state_GetDesc1,
+    /* ID3D11RasterizerState2 methods */
+    d3d11_rasterizer_state_GetDesc2,
 };
 
 /* ID3D10RasterizerState methods */
@@ -1050,7 +1062,7 @@ static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_QueryInterface(ID3D10Ras
 
     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 
-    return d3d11_rasterizer_state_QueryInterface(&state->ID3D11RasterizerState1_iface, riid, object);
+    return d3d11_rasterizer_state_QueryInterface(&state->ID3D11RasterizerState2_iface, riid, object);
 }
 
 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_AddRef(ID3D10RasterizerState *iface)
@@ -1059,7 +1071,7 @@ static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_AddRef(ID3D10RasterizerSta
 
     TRACE("iface %p.\n", iface);
 
-    return d3d11_rasterizer_state_AddRef(&state->ID3D11RasterizerState1_iface);
+    return d3d11_rasterizer_state_AddRef(&state->ID3D11RasterizerState2_iface);
 }
 
 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_Release(ID3D10RasterizerState *iface)
@@ -1068,7 +1080,7 @@ static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_Release(ID3D10RasterizerSt
 
     TRACE("iface %p.\n", state);
 
-    return d3d11_rasterizer_state_Release(&state->ID3D11RasterizerState1_iface);
+    return d3d11_rasterizer_state_Release(&state->ID3D11RasterizerState2_iface);
 }
 
 /* ID3D10DeviceChild methods */
@@ -1167,12 +1179,12 @@ static enum wined3d_cull wined3d_cull_from_d3d11(D3D11_CULL_MODE mode)
 }
 
 static HRESULT d3d_rasterizer_state_init(struct d3d_rasterizer_state *state, struct d3d_device *device,
-        const D3D11_RASTERIZER_DESC1 *desc)
+        const D3D11_RASTERIZER_DESC2 *desc)
 {
     struct wined3d_rasterizer_state_desc wined3d_desc;
     HRESULT hr;
 
-    state->ID3D11RasterizerState1_iface.lpVtbl = &d3d11_rasterizer_state_vtbl;
+    state->ID3D11RasterizerState2_iface.lpVtbl = &d3d11_rasterizer_state_vtbl;
     state->ID3D10RasterizerState_iface.lpVtbl = &d3d10_rasterizer_state_vtbl;
     state->refcount = 1;
     wined3d_private_store_init(&state->private_store);
@@ -1209,6 +1221,13 @@ static HRESULT d3d_rasterizer_state_init(struct d3d_rasterizer_state *state, str
             FIXME("Ignoring ForcedSampleCount %#x.\n", desc->ForcedSampleCount);
     }
 
+    if (desc->ConservativeRaster)
+    {
+        static unsigned int once;
+        if (!once++)
+            FIXME("Ignoring conservative rasterization.\n");
+    }
+
     /* We cannot fail after creating a wined3d_rasterizer_state object. It
      * would lead to double free. */
     if (FAILED(hr = wined3d_rasterizer_state_create(device->wined3d_device, &wined3d_desc,
@@ -1225,7 +1244,7 @@ static HRESULT d3d_rasterizer_state_init(struct d3d_rasterizer_state *state, str
     return S_OK;
 }
 
-HRESULT d3d_rasterizer_state_create(struct d3d_device *device, const D3D11_RASTERIZER_DESC1 *desc,
+HRESULT d3d_rasterizer_state_create(struct d3d_device *device, const D3D11_RASTERIZER_DESC2 *desc,
         struct d3d_rasterizer_state **state)
 {
     struct d3d_rasterizer_state *object;
@@ -1238,7 +1257,7 @@ HRESULT d3d_rasterizer_state_create(struct d3d_device *device, const D3D11_RASTE
         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_rasterizer_state, entry);
 
         TRACE("Returning existing rasterizer state %p.\n", object);
-        ID3D11RasterizerState1_AddRef(&object->ID3D11RasterizerState1_iface);
+        ID3D11RasterizerState2_AddRef(&object->ID3D11RasterizerState2_iface);
         *state = object;
         wined3d_mutex_unlock();
 
@@ -1272,7 +1291,7 @@ struct d3d_rasterizer_state *unsafe_impl_from_ID3D11RasterizerState(ID3D11Raster
         return NULL;
     assert(iface->lpVtbl == (ID3D11RasterizerStateVtbl *)&d3d11_rasterizer_state_vtbl);
 
-    return impl_from_ID3D11RasterizerState1((ID3D11RasterizerState1 *)iface);
+    return impl_from_ID3D11RasterizerState2((ID3D11RasterizerState2 *)iface);
 }
 
 struct d3d_rasterizer_state *unsafe_impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c
index 0bb0e095013..62cbcaa7561 100644
--- a/dlls/d3d11/tests/d3d11.c
+++ b/dlls/d3d11/tests/d3d11.c
@@ -5881,6 +5881,7 @@ static void test_create_rasterizer_state(void)
     D3D11_RASTERIZER_DESC desc;
     ID3D11Device *device, *tmp;
     ID3D11Device1 *device1;
+    ID3D11Device3 *device3;
     HRESULT hr;
 
     if (!(device = create_device(NULL)))
@@ -5969,6 +5970,33 @@ static void test_create_rasterizer_state(void)
         ID3D11Device1_Release(device1);
     }
 
+    if (ID3D11Device_QueryInterface(device, &IID_ID3D11Device3, (void **)&device3) == S_OK)
+    {
+        ID3D11RasterizerState2 *state_ex2;
+        D3D11_RASTERIZER_DESC2 desc2;
+
+        hr = ID3D11RasterizerState_QueryInterface(rast_state1, &IID_ID3D11RasterizerState2, (void **)&state_ex2);
+        ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+        memset(&desc2, 0xcc, sizeof(desc2));
+        ID3D11RasterizerState2_GetDesc2(state_ex2, &desc2);
+        ok(!memcmp(&desc2, &desc, sizeof(desc)), "D3D11 desc didn't match.\n");
+        ok(!desc2.ForcedSampleCount, "Got forced sample count %u.\n", desc2.ForcedSampleCount);
+        ok(!desc2.ConservativeRaster, "Got conservative raster %u.\n", desc2.ConservativeRaster);
+
+        ID3D11RasterizerState2_Release(state_ex2);
+
+        memcpy(&desc2, &desc, sizeof(desc));
+        desc2.ForcedSampleCount = 0;
+        desc2.ConservativeRaster = D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF;
+        hr = ID3D11Device3_CreateRasterizerState2(device3, &desc2, &state_ex2);
+        ok(hr == S_OK, "Got hr %#lx.\n", hr);
+
+        ID3D11RasterizerState2_Release(state_ex2);
+
+        ID3D11Device3_Release(device3);
+    }
+
     refcount = ID3D11RasterizerState_Release(rast_state2);
     ok(refcount == 1, "Got unexpected refcount %lu.\n", refcount);
     refcount = ID3D11RasterizerState_Release(rast_state1);
-- 
GitLab

https://gitlab.winehq.org/wine/wine/-/merge_requests/8277