static HRESULT WINAPI d3d8_GetAdapterDisplayMode(IDirect3D8 *iface, UINT adapter, D3DDISPLAYMODE *mode) { struct d3d8 *d3d8 = impl_from_IDirect3D8(iface); struct wined3d_display_mode wined3d_mode; HRESULT hr; TRACE("iface %p, adapter %u, mode %p.\n", iface, adapter, mode); wined3d_mutex_lock(); hr = wined3d_get_adapter_display_mode(d3d8->wined3d, adapter, &wined3d_mode, NULL); wined3d_mutex_unlock(); if (SUCCEEDED(hr)) { mode->Width = wined3d_mode.width; mode->Height = wined3d_mode.height; mode->RefreshRate = wined3d_mode.refresh_rate; mode->Format = d3dformat_from_wined3dformat(wined3d_mode.format_id); } return hr; }
static HRESULT WINAPI IDirect3DVolume9Impl_GetDesc(IDirect3DVolume9 *iface, D3DVOLUME_DESC *desc) { IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl *)iface; struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; TRACE("iface %p, desc %p.\n", iface, desc); wined3d_mutex_lock(); wined3d_resource = IWineD3DVolume_GetResource(This->wineD3DVolume); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); wined3d_mutex_unlock(); desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = wined3d_desc.resource_type; desc->Usage = wined3d_desc.usage; desc->Pool = wined3d_desc.pool; desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; desc->Depth = wined3d_desc.depth; return D3D_OK; }
IDirect3D8* WINAPI DECLSPEC_HOTPATCH Direct3DCreate8(UINT SDKVersion) { IDirect3D8Impl* object; TRACE("SDKVersion = %x\n", SDKVersion); wined3d_mutex_lock(); object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3D8Impl)); object->lpVtbl = &Direct3D8_Vtbl; object->ref = 1; object->WineD3D = WineDirect3DCreate(8, (IUnknown *)object); TRACE("Created Direct3D object @ %p, WineObj @ %p\n", object, object->WineD3D); wined3d_mutex_unlock(); if (!object->WineD3D) { HeapFree( GetProcessHeap(), 0, object ); object = NULL; } return (IDirect3D8*) object; }
static HRESULT WINAPI d3d8_vertexbuffer_GetDesc(IDirect3DVertexBuffer8 *iface, D3DVERTEXBUFFER_DESC *desc) { struct d3d8_vertexbuffer *buffer = impl_from_IDirect3DVertexBuffer8(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; TRACE("iface %p, desc %p.\n", iface, desc); wined3d_mutex_lock(); wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); wined3d_mutex_unlock(); desc->Format = D3DFMT_VERTEXDATA; desc->Type = D3DRTYPE_VERTEXBUFFER; desc->Usage = buffer->usage; desc->Pool = d3dpool_from_wined3daccess(wined3d_desc.access, wined3d_desc.usage); desc->Size = wined3d_desc.size; desc->FVF = buffer->fvf; return D3D_OK; }
HRESULT pixelshader_init(IDirect3DPixelShader9Impl *shader, IDirect3DDevice9Impl *device, const DWORD *byte_code) { HRESULT hr; shader->ref = 1; shader->lpVtbl = &Direct3DPixelShader9_Vtbl; wined3d_mutex_lock(); hr = IWineD3DDevice_CreatePixelShader(device->WineD3DDevice, byte_code, NULL, &shader->wineD3DPixelShader, (IUnknown *)shader, &d3d9_pixelshader_wined3d_parent_ops); wined3d_mutex_unlock(); if (FAILED(hr)) { WARN("Failed to created wined3d pixel shader, hr %#x.\n", hr); return hr; } shader->parentDevice = (IDirect3DDevice9Ex *)device; IDirect3DDevice9Ex_AddRef(shader->parentDevice); return D3D_OK; }
static HRESULT WINAPI IDirect3DSwapChain8Impl_GetBackBuffer(IDirect3DSwapChain8 *iface, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8 **ppBackBuffer) { IDirect3DSwapChain8Impl *This = impl_from_IDirect3DSwapChain8(iface); struct wined3d_surface *wined3d_surface = NULL; HRESULT hr; TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n", iface, iBackBuffer, Type, ppBackBuffer); wined3d_mutex_lock(); hr = wined3d_swapchain_get_back_buffer(This->wined3d_swapchain, iBackBuffer, (enum wined3d_backbuffer_type)Type, &wined3d_surface); if (SUCCEEDED(hr) && wined3d_surface) { *ppBackBuffer = wined3d_surface_get_parent(wined3d_surface); IDirect3DSurface8_AddRef(*ppBackBuffer); wined3d_surface_decref(wined3d_surface); } wined3d_mutex_unlock(); return hr; }
/***************************************************************************** * IDirect3DVertexBuffer7::GetVertexBufferDesc * * Returns the description of a vertex buffer * * Params: * Desc: Address to write the description to * * Returns * DDERR_INVALIDPARAMS if Desc is NULL * D3D_OK on success * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface, D3DVERTEXBUFFERDESC *Desc) { IDirect3DVertexBufferImpl *This = impl_from_IDirect3DVertexBuffer7(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; TRACE("iface %p, desc %p.\n", iface, Desc); if(!Desc) return DDERR_INVALIDPARAMS; wined3d_mutex_lock(); wined3d_resource = wined3d_buffer_get_resource(This->wineD3DVertexBuffer); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); wined3d_mutex_unlock(); /* Now fill the Desc structure */ Desc->dwCaps = This->Caps; Desc->dwFVF = This->fvf; Desc->dwNumVertices = wined3d_desc.size / get_flexible_vertex_size(This->fvf); return D3D_OK; }
/***************************************************************************** * IDirect3DVertexBuffer7::Optimize * * Converts an unoptimized vertex buffer into an optimized buffer * * Params: * D3DDevice: Device for which this buffer is optimized * Flags: Not used, should be set to 0 * * Returns * D3D_OK, because it's a stub * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_Optimize(IDirect3DVertexBuffer7 *iface, IDirect3DDevice7 *D3DDevice, DWORD Flags) { IDirect3DVertexBufferImpl *This = impl_from_IDirect3DVertexBuffer7(iface); static BOOL hide = FALSE; TRACE("iface %p, device %p, flags %#x.\n", iface, D3DDevice, Flags); if (!hide) { FIXME("iface %p, device %p, flags %#x stub!\n", iface, D3DDevice, Flags); hide = TRUE; } /* We could forward this call to WineD3D and take advantage * of it once we use OpenGL vertex buffers */ wined3d_mutex_lock(); This->Caps |= D3DVBCAPS_OPTIMIZED; wined3d_mutex_unlock(); return DD_OK; }
static ULONG WINAPI d3d8_texture_2d_Release(IDirect3DTexture8 *iface) { struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); ULONG ref = InterlockedDecrement(&texture->resource.refcount); TRACE("%p decreasing refcount to %u.\n", iface, ref); if (!ref) { IDirect3DDevice8 *parent_device = texture->parent_device; struct d3d8_surface *surface; wined3d_mutex_lock(); LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d8_surface, rtv_entry) { wined3d_rendertarget_view_decref(surface->wined3d_rtv); } wined3d_texture_decref(texture->wined3d_texture); wined3d_mutex_unlock(); /* Release the device last, as it may cause the device to be destroyed. */ IDirect3DDevice8_Release(parent_device); }
static ULONG WINAPI d3d8_texture_2d_AddRef(IDirect3DTexture8 *iface) { struct d3d8_texture *texture = impl_from_IDirect3DTexture8(iface); ULONG ref = InterlockedIncrement(&texture->resource.refcount); TRACE("%p increasing refcount to %u.\n", iface, ref); if (ref == 1) { struct d3d8_surface *surface; IDirect3DDevice8_AddRef(texture->parent_device); wined3d_mutex_lock(); LIST_FOR_EACH_ENTRY(surface, &texture->rtv_list, struct d3d8_surface, rtv_entry) { wined3d_rendertarget_view_incref(surface->wined3d_rtv); } wined3d_texture_incref(texture->wined3d_texture); wined3d_mutex_unlock(); } return ref; }
static HRESULT WINAPI d3d8_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture8 *iface, UINT level, IDirect3DVolume8 **volume) { struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface); struct wined3d_resource *sub_resource; struct d3d8_volume *volume_impl; TRACE("iface %p, level %u, volume %p.\n", iface, level, volume); wined3d_mutex_lock(); if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) { wined3d_mutex_unlock(); return D3DERR_INVALIDCALL; } volume_impl = wined3d_resource_get_parent(sub_resource); *volume = &volume_impl->IDirect3DVolume8_iface; IDirect3DVolume8_AddRef(*volume); wined3d_mutex_unlock(); return D3D_OK; }
static HRESULT WINAPI d3d8_indexbuffer_Lock(IDirect3DIndexBuffer8 *iface, UINT offset, UINT size, BYTE **data, DWORD flags) { struct d3d8_indexbuffer *buffer = impl_from_IDirect3DIndexBuffer8(iface); struct wined3d_resource *wined3d_resource; struct wined3d_map_desc wined3d_map_desc; struct wined3d_box wined3d_box = {0}; HRESULT hr; TRACE("iface %p, offset %u, size %u, data %p, flags %#x.\n", iface, offset, size, data, flags); wined3d_box.left = offset; wined3d_box.right = offset + size; wined3d_mutex_lock(); wined3d_resource = wined3d_buffer_get_resource(buffer->wined3d_buffer); hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc, &wined3d_box, wined3dmapflags_from_d3dmapflags(flags, buffer->usage)); wined3d_mutex_unlock(); *data = wined3d_map_desc.data; return hr; }
static void STDMETHODCALLTYPE d3d11_texture2d_GetDesc(ID3D11Texture2D *iface, D3D11_TEXTURE2D_DESC *desc) { struct d3d_texture2d *texture = impl_from_ID3D11Texture2D(iface); struct wined3d_resource_desc wined3d_desc; TRACE("iface %p, desc %p.\n", iface, desc); *desc = texture->desc; wined3d_mutex_lock(); wined3d_resource_get_desc(wined3d_texture_get_resource(texture->wined3d_texture), &wined3d_desc); wined3d_mutex_unlock(); /* FIXME: Resizing swapchain buffers can cause these to change. We'd like * to get everything from wined3d, but e.g. bind flags don't exist as such * there (yet). */ desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.format); desc->SampleDesc.Count = wined3d_desc.multisample_type == WINED3D_MULTISAMPLE_NONE ? 1 : wined3d_desc.multisample_type; desc->SampleDesc.Quality = wined3d_desc.multisample_quality; }
static HRESULT WINAPI d3d9_texture_3d_LockBox(IDirect3DVolumeTexture9 *iface, UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags) { struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface); struct wined3d_resource *sub_resource; struct d3d9_volume *volume_impl; HRESULT hr; TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n", iface, level, locked_box, box, flags); wined3d_mutex_lock(); if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) hr = D3DERR_INVALIDCALL; else { volume_impl = wined3d_resource_get_parent(sub_resource); hr = IDirect3DVolume9_LockBox(&volume_impl->IDirect3DVolume9_iface, locked_box, box, flags); } wined3d_mutex_unlock(); return hr; }
static HRESULT WINAPI d3d9_volume_GetDesc(IDirect3DVolume9 *iface, D3DVOLUME_DESC *desc) { struct d3d9_volume *volume = impl_from_IDirect3DVolume9(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; TRACE("iface %p, desc %p.\n", iface, desc); wined3d_mutex_lock(); wined3d_resource = wined3d_volume_get_resource(volume->wined3d_volume); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); wined3d_mutex_unlock(); desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = wined3d_desc.resource_type; desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; desc->Pool = wined3d_desc.pool; desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; desc->Depth = wined3d_desc.depth; return D3D_OK; }
static HRESULT WINAPI IDirect3DCubeTexture8Impl_GetCubeMapSurface(IDirect3DCubeTexture8 *iface, D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface8 **surface) { IDirect3DCubeTexture8Impl *texture = impl_from_IDirect3DCubeTexture8(iface); struct wined3d_resource *sub_resource; UINT sub_resource_idx; TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface); wined3d_mutex_lock(); sub_resource_idx = IWineD3DCubeTexture_GetLevelCount(texture->wineD3DCubeTexture) * face + level; if (!(sub_resource = IWineD3DCubeTexture_GetSubResource(texture->wineD3DCubeTexture, sub_resource_idx))) { wined3d_mutex_unlock(); return D3DERR_INVALIDCALL; } *surface = wined3d_resource_get_parent(sub_resource); IDirect3DSurface8_AddRef(*surface); wined3d_mutex_unlock(); return D3D_OK; }
static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); struct wined3d_resource *sub_resource; struct d3d9_surface *surface_impl; HRESULT hr; TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n", iface, level, locked_rect, rect, flags); wined3d_mutex_lock(); if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) hr = D3DERR_INVALIDCALL; else { surface_impl = wined3d_resource_get_parent(sub_resource); hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags); } wined3d_mutex_unlock(); return hr; }
static HRESULT WINAPI d3d9_texture_2d_GetSurfaceLevel(IDirect3DTexture9 *iface, UINT level, IDirect3DSurface9 **surface) { struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface); struct wined3d_resource *sub_resource; struct d3d9_surface *surface_impl; TRACE("iface %p, level %u, surface %p.\n", iface, level, surface); wined3d_mutex_lock(); if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) { wined3d_mutex_unlock(); return D3DERR_INVALIDCALL; } surface_impl = wined3d_resource_get_parent(sub_resource); *surface = &surface_impl->IDirect3DSurface9_iface; IDirect3DSurface9_AddRef(*surface); wined3d_mutex_unlock(); return D3D_OK; }
static HRESULT WINAPI IDirect3DCubeTexture9Impl_LockRect(IDirect3DCubeTexture9 *iface, D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { IDirect3DCubeTexture9Impl *texture = impl_from_IDirect3DCubeTexture9(iface); struct wined3d_resource *sub_resource; UINT sub_resource_idx; HRESULT hr; TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n", iface, face, level, locked_rect, rect, flags); wined3d_mutex_lock(); sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level; if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx))) hr = D3DERR_INVALIDCALL; else hr = IDirect3DSurface9_LockRect((IDirect3DSurface9 *)wined3d_resource_get_parent(sub_resource), locked_rect, rect, flags); wined3d_mutex_unlock(); return hr; }
static HRESULT WINAPI IDirect3D9Impl_EnumAdapterModes(IDirect3D9Ex *iface, UINT Adapter, D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE *pMode) { IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface); HRESULT hr; TRACE("iface %p, adapter %u, format %#x, mode_idx %u, mode %p.\n", iface, Adapter, Format, Mode, pMode); /* We can't pass this to WineD3D, otherwise it'll think it came from D3D8 or DDraw. It's supposed to fail anyway, so no harm returning failure. */ if(Format != D3DFMT_X8R8G8B8 && Format != D3DFMT_R5G6B5) return D3DERR_INVALIDCALL; wined3d_mutex_lock(); hr = wined3d_enum_adapter_modes(This->WineD3D, Adapter, wined3dformat_from_d3dformat(Format), Mode, (struct wined3d_display_mode *)pMode); wined3d_mutex_unlock(); if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format); return hr; }
static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc) { struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface); struct wined3d_resource *sub_resource; HRESULT hr = D3D_OK; DWORD level_count; TRACE("iface %p, level %u, desc %p.\n", iface, level, desc); wined3d_mutex_lock(); level_count = wined3d_texture_get_level_count(texture->wined3d_texture); if (level >= level_count) { wined3d_mutex_unlock(); return D3DERR_INVALIDCALL; } if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level))) hr = D3DERR_INVALIDCALL; else { struct wined3d_resource_desc wined3d_desc; wined3d_resource_get_desc(sub_resource, &wined3d_desc); desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = wined3d_desc.resource_type; desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK; desc->Pool = wined3d_desc.pool; desc->MultiSampleType = wined3d_desc.multisample_type; desc->MultiSampleQuality = wined3d_desc.multisample_quality; desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; } wined3d_mutex_unlock(); return hr; }
static HRESULT WINAPI d3d9_swapchain_GetBackBuffer(IDirect3DSwapChain9Ex *iface, UINT backbuffer_idx, D3DBACKBUFFER_TYPE backbuffer_type, IDirect3DSurface9 **backbuffer) { struct d3d9_swapchain *swapchain = impl_from_IDirect3DSwapChain9Ex(iface); struct wined3d_resource *wined3d_resource; struct wined3d_texture *wined3d_texture; struct d3d9_surface *surface_impl; HRESULT hr = D3D_OK; TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n", iface, backbuffer_idx, backbuffer_type, backbuffer); /* backbuffer_type is ignored by native. */ if (!backbuffer) { WARN("The output pointer is NULL, returning D3DERR_INVALIDCALL.\n"); return D3DERR_INVALIDCALL; } wined3d_mutex_lock(); if ((wined3d_texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, backbuffer_idx))) { wined3d_resource = wined3d_texture_get_sub_resource(wined3d_texture, 0); surface_impl = wined3d_resource_get_parent(wined3d_resource); *backbuffer = &surface_impl->IDirect3DSurface9_iface; IDirect3DSurface9_AddRef(*backbuffer); } else { /* Do not set *backbuffer = NULL, see tests/device.c, test_swapchain(). */ hr = D3DERR_INVALIDCALL; } wined3d_mutex_unlock(); return hr; }
HRESULT d3d_get_private_data(struct wined3d_private_store *store, REFGUID guid, UINT *data_size, void *data) { const struct wined3d_private_data *stored_data; DWORD size_in; if (!data_size) return E_INVALIDARG; wined3d_mutex_lock(); if (!(stored_data = wined3d_private_store_get_private_data(store, guid))) { *data_size = 0; wined3d_mutex_unlock(); return DXGI_ERROR_NOT_FOUND; } size_in = *data_size; *data_size = stored_data->size; if (!data) { wined3d_mutex_unlock(); return S_OK; } if (size_in < stored_data->size) { wined3d_mutex_unlock(); return DXGI_ERROR_MORE_DATA; } if (stored_data->flags & WINED3DSPD_IUNKNOWN) IUnknown_AddRef(stored_data->content.object); memcpy(data, stored_data->content.data, stored_data->size); wined3d_mutex_unlock(); return S_OK; }
HRESULT d3d9_resource_get_private_data(struct d3d9_resource *resource, const GUID *guid, void *data, DWORD *data_size) { const struct wined3d_private_data *stored_data; DWORD size_in; HRESULT hr; wined3d_mutex_lock(); stored_data = wined3d_private_store_get_private_data(&resource->private_store, guid); if (!stored_data) { hr = D3DERR_NOTFOUND; goto done; } size_in = *data_size; *data_size = stored_data->size; if (!data) { hr = D3D_OK; goto done; } if (size_in < stored_data->size) { hr = D3DERR_MOREDATA; goto done; } if (stored_data->flags & WINED3DSPD_IUNKNOWN) IUnknown_AddRef(stored_data->content.object); memcpy(data, stored_data->content.data, stored_data->size); hr = D3D_OK; done: wined3d_mutex_unlock(); return hr; }
static HRESULT WINAPI IDirect3D8Impl_CheckDeviceFormat(LPDIRECT3D8 iface, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { IDirect3D8Impl *This = impl_from_IDirect3D8(iface); HRESULT hr; WINED3DRESOURCETYPE WineD3DRType; TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#x, resource_type %#x, format %#x.\n", iface, Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat); if(CheckFormat == D3DFMT_R8G8B8) { /* See comment in dlls/d3d9/directx.c, IDirect3D9Impl_CheckDeviceFormat for details */ WARN("D3DFMT_R8G8B8 is not available on windows, returning D3DERR_NOTAVAILABLE\n"); return D3DERR_NOTAVAILABLE; } switch(RType) { case D3DRTYPE_VERTEXBUFFER: case D3DRTYPE_INDEXBUFFER: WineD3DRType = WINED3DRTYPE_BUFFER; break; default: WineD3DRType = RType; break; } wined3d_mutex_lock(); hr = wined3d_check_device_format(This->WineD3D, Adapter, DeviceType, wined3dformat_from_d3dformat(AdapterFormat), Usage, WineD3DRType, wined3dformat_from_d3dformat(CheckFormat), SURFACE_OPENGL); wined3d_mutex_unlock(); return hr; }
static HRESULT STDMETHODCALLTYPE dxgi_swapchain_ResizeBuffers(IDXGISwapChain *iface, UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags) { struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain(iface); struct wined3d_swapchain_desc wined3d_desc; struct wined3d_texture *texture; IUnknown *parent; unsigned int i; HRESULT hr; TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n", iface, buffer_count, width, height, debug_dxgi_format(format), flags); if (flags) FIXME("Ignoring flags %#x.\n", flags); wined3d_mutex_lock(); wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc); for (i = 0; i < wined3d_desc.backbuffer_count; ++i) { texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, i); parent = wined3d_texture_get_parent(texture); IUnknown_AddRef(parent); if (IUnknown_Release(parent)) { wined3d_mutex_unlock(); return DXGI_ERROR_INVALID_CALL; } } if (format != DXGI_FORMAT_UNKNOWN) wined3d_desc.backbuffer_format = wined3dformat_from_dxgi_format(format); hr = wined3d_swapchain_resize_buffers(swapchain->wined3d_swapchain, buffer_count, width, height, wined3d_desc.backbuffer_format, wined3d_desc.multisample_type, wined3d_desc.multisample_quality); wined3d_mutex_unlock(); return hr; }
/***************************************************************************** * IDirect3DVertexBuffer7::Lock * * Locks the vertex buffer and returns a pointer to the vertex data * Locking vertex buffers is similar to locking surfaces, because Windows * uses surfaces to store vertex data internally (According to the DX sdk) * * Params: * Flags: Locking flags. Relevant here are DDLOCK_READONLY, DDLOCK_WRITEONLY, * DDLOCK_DISCARDCONTENTS and DDLOCK_NOOVERWRITE. * Data: Returns a pointer to the vertex data * Size: Returns the size of the buffer if not NULL * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS if Data is NULL * D3DERR_VERTEXBUFFEROPTIMIZED if called on an optimized buffer(WineD3D) * *****************************************************************************/ static HRESULT WINAPI d3d_vertex_buffer7_Lock(IDirect3DVertexBuffer7 *iface, DWORD flags, void **data, DWORD *data_size) { struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; HRESULT hr; DWORD wined3d_flags = 0; TRACE("iface %p, flags %#x, data %p, data_size %p.\n", iface, flags, data, data_size); /* Writeonly: Pointless. Event: Unsupported by native according to the sdk * nosyslock: Not applicable */ if (!(flags & DDLOCK_WAIT)) wined3d_flags |= WINED3D_MAP_DONOTWAIT; if (flags & DDLOCK_READONLY) wined3d_flags |= WINED3D_MAP_READONLY; if (flags & DDLOCK_NOOVERWRITE) wined3d_flags |= WINED3D_MAP_NOOVERWRITE; if (flags & DDLOCK_DISCARDCONTENTS) wined3d_flags |= WINED3D_MAP_DISCARD; wined3d_mutex_lock(); if (data_size) { /* Get the size, for returning it, and for locking */ wined3d_resource = wined3d_buffer_get_resource(buffer->wineD3DVertexBuffer); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); *data_size = wined3d_desc.size; } hr = wined3d_buffer_map(buffer->wineD3DVertexBuffer, 0, 0, (BYTE **)data, wined3d_flags); wined3d_mutex_unlock(); return hr; }
static HRESULT STDMETHODCALLTYPE d3d10_texture2d_Map(ID3D10Texture2D *iface, UINT sub_resource_idx, D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE2D *mapped_texture) { struct d3d_texture2d *texture = impl_from_ID3D10Texture2D(iface); struct wined3d_map_desc wined3d_map_desc; HRESULT hr; TRACE("iface %p, sub_resource_idx %u, map_type %u, map_flags %#x, mapped_texture %p.\n", iface, sub_resource_idx, map_type, map_flags, mapped_texture); if (map_flags) FIXME("Ignoring map_flags %#x.\n", map_flags); wined3d_mutex_lock(); if (SUCCEEDED(hr = wined3d_texture_map(texture->wined3d_texture, sub_resource_idx, &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d10_map_type(map_type)))) { mapped_texture->pData = wined3d_map_desc.data; mapped_texture->RowPitch = wined3d_map_desc.row_pitch; } wined3d_mutex_unlock(); return hr; }
static HRESULT WINAPI IDirect3DSurface9Impl_GetDesc(IDirect3DSurface9 *iface, D3DSURFACE_DESC *desc) { IDirect3DSurface9Impl *This = impl_from_IDirect3DSurface9(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; TRACE("iface %p, desc %p.\n", iface, desc); wined3d_mutex_lock(); wined3d_resource = wined3d_surface_get_resource(This->wined3d_surface); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); wined3d_mutex_unlock(); desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format); desc->Type = wined3d_desc.resource_type; desc->Usage = wined3d_desc.usage; desc->Pool = wined3d_desc.pool; desc->MultiSampleType = wined3d_desc.multisample_type; desc->MultiSampleQuality = wined3d_desc.multisample_quality; desc->Width = wined3d_desc.width; desc->Height = wined3d_desc.height; return D3D_OK; }
HRESULT volumetexture_init(IDirect3DVolumeTexture8Impl *texture, IDirect3DDevice8Impl *device, UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) { HRESULT hr; texture->IDirect3DVolumeTexture8_iface.lpVtbl = &Direct3DVolumeTexture8_Vtbl; texture->ref = 1; wined3d_mutex_lock(); hr = wined3d_texture_create_3d(device->wined3d_device, width, height, depth, levels, usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool, texture, &d3d8_volumetexture_wined3d_parent_ops, &texture->wined3d_texture); wined3d_mutex_unlock(); if (FAILED(hr)) { WARN("Failed to create wined3d volume texture, hr %#x.\n", hr); return hr; } texture->parentDevice = &device->IDirect3DDevice8_iface; IDirect3DDevice8_AddRef(texture->parentDevice); return D3D_OK; }