HRESULT d3d10_pixel_shader_init(struct d3d10_pixel_shader *shader, struct d3d10_device *device,
const void *byte_code, SIZE_T byte_code_length)
{
struct d3d10_shader_info shader_info;
HRESULT hr;
shader->ID3D10PixelShader_iface.lpVtbl = &d3d10_pixel_shader_vtbl;
shader->refcount = 1;
shader_info.output_signature = &shader->output_signature;
hr = shader_extract_from_dxbc(byte_code, byte_code_length, &shader_info);
if (FAILED(hr))
{
ERR("Failed to extract shader, hr %#x.\n", hr);
return hr;
}
hr = wined3d_shader_create_ps(device->wined3d_device, shader_info.shader_code,
&shader->output_signature, shader, &d3d10_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader, 4);
if (FAILED(hr))
{
WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
shader_free_signature(&shader->output_signature);
hr = E_INVALIDARG;
return hr;
}
shader->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(shader->device);
return S_OK;
}
HRESULT d3d10_texture3d_init(struct d3d10_texture3d *texture, struct d3d10_device *device,
const D3D10_TEXTURE3D_DESC *desc)
{
struct wined3d_resource_desc wined3d_desc;
HRESULT hr;
texture->ID3D10Texture3D_iface.lpVtbl = &d3d10_texture3d_vtbl;
texture->refcount = 1;
texture->desc = *desc;
wined3d_desc.resource_type = WINED3D_RTYPE_VOLUME_TEXTURE;
wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
wined3d_desc.multisample_quality = 0;
wined3d_desc.usage = wined3d_usage_from_d3d10core(desc->BindFlags, desc->Usage);
wined3d_desc.pool = WINED3D_POOL_DEFAULT;
wined3d_desc.width = desc->Width;
wined3d_desc.height = desc->Height;
wined3d_desc.depth = desc->Depth;
wined3d_desc.size = 0;
if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc, desc->MipLevels,
0, texture, &d3d10_texture3d_wined3d_parent_ops, &texture->wined3d_texture)))
{
WARN("Failed to create wined3d texture, hr %#x.\n", hr);
return hr;
}
texture->desc.MipLevels = wined3d_texture_get_level_count(texture->wined3d_texture);
texture->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(texture->device);
return S_OK;
}
HRESULT d3d10_sampler_state_init(struct d3d10_sampler_state *state, struct d3d10_device *device,
const D3D10_SAMPLER_DESC *desc)
{
HRESULT hr;
state->ID3D10SamplerState_iface.lpVtbl = &d3d10_sampler_state_vtbl;
state->refcount = 1;
state->desc = *desc;
if (FAILED(hr = wined3d_sampler_create(state, &state->wined3d_sampler)))
{
WARN("Failed to create wined3d sampler, hr %#x.\n", hr);
return hr;
}
if (wine_rb_put(&device->sampler_states, desc, &state->entry) == -1)
{
ERR("Failed to insert sampler state entry.\n");
wined3d_sampler_decref(state->wined3d_sampler);
return E_FAIL;
}
state->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(state->device);
return S_OK;
}
static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_AddRef(ID3D10PixelShader *iface)
{
struct d3d10_pixel_shader *This = impl_from_ID3D10PixelShader(iface);
ULONG refcount = InterlockedIncrement(&This->refcount);
TRACE("%p increasing refcount to %u\n", This, refcount);
if (refcount == 1)
{
ID3D10Device1_AddRef(This->device);
wined3d_shader_incref(This->wined3d_shader);
}
return refcount;
}
static ULONG STDMETHODCALLTYPE d3d10_texture2d_AddRef(ID3D10Texture2D *iface)
{
struct d3d10_texture2d *This = impl_from_ID3D10Texture2D(iface);
ULONG refcount = InterlockedIncrement(&This->refcount);
TRACE("%p increasing refcount to %u\n", This, refcount);
if (refcount == 1)
{
ID3D10Device1_AddRef(This->device);
wined3d_texture_incref(This->wined3d_texture);
}
return refcount;
}
HRESULT d3d10_query_init(struct d3d10_query *query, struct d3d10_device *device,
const D3D10_QUERY_DESC *desc, BOOL predicate)
{
HRESULT hr;
static const enum wined3d_query_type query_type_map[] =
{
/* D3D10_QUERY_EVENT */ WINED3D_QUERY_TYPE_EVENT,
/* D3D10_QUERY_OCCLUSION */ WINED3D_QUERY_TYPE_OCCLUSION,
/* D3D10_QUERY_TIMESTAMP */ WINED3D_QUERY_TYPE_TIMESTAMP,
/* D3D10_QUERY_TIMESTAMP_DISJOINT */ WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT,
/* D3D10_QUERY_PIPELINE_STATISTICS */ WINED3D_QUERY_TYPE_PIPELINE_STATISTICS,
/* D3D10_QUERY_OCCLUSION_PREDICATE */ WINED3D_QUERY_TYPE_OCCLUSION,
/* D3D10_QUERY_SO_STATISTICS */ WINED3D_QUERY_TYPE_SO_STATISTICS,
/* D3D10_QUERY_SO_OVERFLOW_PREDICATE */ WINED3D_QUERY_TYPE_SO_OVERFLOW,
};
if (desc->Query >= sizeof(query_type_map) / sizeof(*query_type_map))
{
FIXME("Unhandled query type %#x.\n", desc->Query);
return E_INVALIDARG;
}
if (desc->MiscFlags)
FIXME("Ignoring MiscFlags %#x.\n", desc->MiscFlags);
query->ID3D10Query_iface.lpVtbl = &d3d10_query_vtbl;
query->refcount = 1;
wined3d_mutex_lock();
wined3d_private_store_init(&query->private_store);
if (FAILED(hr = wined3d_query_create(device->wined3d_device,
query_type_map[desc->Query], query, &query->wined3d_query)))
{
WARN("Failed to create wined3d query, hr %#x.\n", hr);
wined3d_private_store_cleanup(&query->private_store);
wined3d_mutex_unlock();
return hr;
}
wined3d_mutex_unlock();
query->predicate = predicate;
query->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(query->device);
return S_OK;
}
HRESULT d3d10_sampler_state_init(struct d3d10_sampler_state *state, struct d3d10_device *device,
const D3D10_SAMPLER_DESC *desc)
{
struct wined3d_sampler_desc wined3d_desc;
HRESULT hr;
state->ID3D10SamplerState_iface.lpVtbl = &d3d10_sampler_state_vtbl;
state->refcount = 1;
wined3d_private_store_init(&state->private_store);
state->desc = *desc;
wined3d_desc.address_u = wined3d_texture_address_from_d3d10core(desc->AddressU);
wined3d_desc.address_v = wined3d_texture_address_from_d3d10core(desc->AddressV);
wined3d_desc.address_w = wined3d_texture_address_from_d3d10core(desc->AddressW);
memcpy(wined3d_desc.border_color, desc->BorderColor, sizeof(wined3d_desc.border_color));
wined3d_desc.mag_filter = wined3d_texture_filter_mag_from_d3d10core(desc->Filter);
wined3d_desc.min_filter = wined3d_texture_filter_min_from_d3d10core(desc->Filter);
wined3d_desc.mip_filter = wined3d_texture_filter_mip_from_d3d10core(desc->Filter);
wined3d_desc.lod_bias = desc->MipLODBias;
wined3d_desc.min_lod = desc->MinLOD;
wined3d_desc.max_lod = desc->MaxLOD;
wined3d_desc.max_anisotropy = desc->Filter & D3D10_FILTER_ANISO_MASK ? desc->MaxAnisotropy : 1;
wined3d_desc.compare = wined3d_texture_compare_from_d3d10core(desc->Filter);
wined3d_desc.comparison_func = wined3d_cmp_func_from_d3d10core(desc->ComparisonFunc);
wined3d_desc.srgb_decode = FALSE;
if (FAILED(hr = wined3d_sampler_create(device->wined3d_device, &wined3d_desc, state, &state->wined3d_sampler)))
{
WARN("Failed to create wined3d sampler, hr %#x.\n", hr);
wined3d_private_store_cleanup(&state->private_store);
return hr;
}
if (wine_rb_put(&device->sampler_states, desc, &state->entry) == -1)
{
ERR("Failed to insert sampler state entry.\n");
wined3d_sampler_decref(state->wined3d_sampler);
wined3d_private_store_cleanup(&state->private_store);
return E_FAIL;
}
state->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(state->device);
return S_OK;
}
HRESULT d3d10_rasterizer_state_init(struct d3d10_rasterizer_state *state, struct d3d10_device *device,
const D3D10_RASTERIZER_DESC *desc)
{
state->ID3D10RasterizerState_iface.lpVtbl = &d3d10_rasterizer_state_vtbl;
state->refcount = 1;
state->desc = *desc;
if (wine_rb_put(&device->rasterizer_states, desc, &state->entry) == -1)
{
ERR("Failed to insert rasterizer state entry.\n");
return E_FAIL;
}
state->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(state->device);
return S_OK;
}
HRESULT d3d10_depthstencil_state_init(struct d3d10_depthstencil_state *state, struct d3d10_device *device,
const D3D10_DEPTH_STENCIL_DESC *desc)
{
state->ID3D10DepthStencilState_iface.lpVtbl = &d3d10_depthstencil_state_vtbl;
state->refcount = 1;
state->desc = *desc;
if (wine_rb_put(&device->depthstencil_states, desc, &state->entry) == -1)
{
ERR("Failed to insert depthstencil state entry.\n");
return E_FAIL;
}
state->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(state->device);
return S_OK;
}
HRESULT d3d10_blend_state_init(struct d3d10_blend_state *state, struct d3d10_device *device,
const D3D10_BLEND_DESC *desc)
{
state->ID3D10BlendState_iface.lpVtbl = &d3d10_blend_state_vtbl;
state->refcount = 1;
state->desc = *desc;
if (wine_rb_put(&device->blend_states, desc, &state->entry) == -1)
{
ERR("Failed to insert blend state entry.\n");
return E_FAIL;
}
state->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(state->device);
return S_OK;
}
HRESULT d2d_dc_render_target_init(struct d2d_dc_render_target *render_target, ID2D1Factory1 *factory,
ID3D10Device1 *d3d_device, const D2D1_RENDER_TARGET_PROPERTIES *desc)
{
IDXGIDevice *dxgi_device;
ID2D1Device *device;
HRESULT hr;
render_target->ID2D1DCRenderTarget_iface.lpVtbl = &d2d_dc_render_target_vtbl;
/* Set with BindDC(). */
SetRectEmpty(&render_target->dst_rect);
render_target->hdc = NULL;
render_target->pixel_format = desc->pixelFormat;
switch (desc->pixelFormat.format)
{
case DXGI_FORMAT_B8G8R8A8_UNORM:
if (desc->pixelFormat.alphaMode == D2D1_ALPHA_MODE_PREMULTIPLIED
|| desc->pixelFormat.alphaMode == D2D1_ALPHA_MODE_IGNORE)
break;
default:
FIXME("Unhandled format %#x, alpha mode %u.\n", desc->pixelFormat.format, desc->pixelFormat.alphaMode);
return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
}
if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device)))
{
WARN("Failed to get DXGI device interface, hr %#x.\n", hr);
return hr;
}
hr = ID2D1Factory1_CreateDevice(factory, dxgi_device, &device);
IDXGIDevice_Release(dxgi_device);
if (FAILED(hr))
{
WARN("Failed to create D2D device, hr %#x.\n", hr);
return hr;
}
hr = d2d_d3d_create_render_target(device, NULL, (IUnknown *)&render_target->ID2D1DCRenderTarget_iface,
&d2d_dc_render_target_ops, desc, (void **)&render_target->dxgi_inner);
ID2D1Device_Release(device);
if (FAILED(hr))
{
WARN("Failed to create DXGI surface render target, hr %#x.\n", hr);
return hr;
}
if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner,
&IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target)))
{
WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#x.\n", hr);
IUnknown_Release(render_target->dxgi_inner);
return hr;
}
render_target->d3d_device = d3d_device;
ID3D10Device1_AddRef(render_target->d3d_device);
return S_OK;
}
HRESULT d3d10_texture2d_init(struct d3d10_texture2d *texture, struct d3d10_device *device,
const D3D10_TEXTURE2D_DESC *desc)
{
struct wined3d_resource_desc wined3d_desc;
HRESULT hr;
texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
texture->refcount = 1;
texture->desc = *desc;
if (desc->MipLevels == 1 && desc->ArraySize == 1)
{
DXGI_SURFACE_DESC surface_desc;
IWineDXGIDevice *wine_device;
if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,
(void **)&wine_device)))
{
ERR("Device should implement IWineDXGIDevice.\n");
return E_FAIL;
}
surface_desc.Width = desc->Width;
surface_desc.Height = desc->Height;
surface_desc.Format = desc->Format;
surface_desc.SampleDesc = desc->SampleDesc;
hr = IWineDXGIDevice_create_surface(wine_device, &surface_desc, 0, NULL,
(IUnknown *)&texture->ID3D10Texture2D_iface, (void **)&texture->dxgi_surface);
IWineDXGIDevice_Release(wine_device);
if (FAILED(hr))
{
ERR("Failed to create DXGI surface, returning %#x\n", hr);
return hr;
}
}
if (desc->ArraySize != 1)
FIXME("Array textures not implemented.\n");
if (desc->SampleDesc.Count > 1)
FIXME("Multisampled textures not implemented.\n");
wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE;
wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
wined3d_desc.usage = wined3d_usage_from_d3d10core(desc->BindFlags, desc->Usage);
wined3d_desc.pool = WINED3D_POOL_DEFAULT;
wined3d_desc.width = desc->Width;
wined3d_desc.height = desc->Height;
wined3d_desc.depth = 1;
wined3d_desc.size = 0;
if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc, desc->MipLevels,
0, texture, &d3d10_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
{
WARN("Failed to create wined3d texture, hr %#x.\n", hr);
if (texture->dxgi_surface)
IUnknown_Release(texture->dxgi_surface);
return hr;
}
texture->desc.MipLevels = wined3d_texture_get_level_count(texture->wined3d_texture);
texture->device = &device->ID3D10Device1_iface;
ID3D10Device1_AddRef(texture->device);
return S_OK;
}