自学教程：C++ wined3d_texture_get_resource函数代码示例

struct wined3d_resource *wined3d_resource_from_d3d11_resource(ID3D11Resource *resource){    D3D11_RESOURCE_DIMENSION dimension;    ID3D11Resource_GetType(resource, &dimension);    switch (dimension)    {        case D3D11_RESOURCE_DIMENSION_BUFFER:            return wined3d_buffer_get_resource(unsafe_impl_from_ID3D11Buffer(                    (ID3D11Buffer *)resource)->wined3d_buffer);        case D3D11_RESOURCE_DIMENSION_TEXTURE2D:            return wined3d_texture_get_resource(unsafe_impl_from_ID3D11Texture2D(                    (ID3D11Texture2D *)resource)->wined3d_texture);        case D3D11_RESOURCE_DIMENSION_TEXTURE3D:            return wined3d_texture_get_resource(unsafe_impl_from_ID3D11Texture3D(                    (ID3D11Texture3D *)resource)->wined3d_texture);        default:            FIXME("Unhandled resource dimension %#x./n", dimension);            return NULL;    }}

static HRESULT WINAPI d3d9_surface_LockRect(IDirect3DSurface9 *iface,        D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags){    struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface);    struct wined3d_box box;    struct wined3d_map_desc map_desc;    HRESULT hr;    TRACE("iface %p, locked_rect %p, rect %s, flags %#x./n",            iface, locked_rect, wine_dbgstr_rect(rect), flags);    if (rect)    {        box.left = rect->left;        box.top = rect->top;        box.right = rect->right;        box.bottom = rect->bottom;        box.front = 0;        box.back = 1;    }    wined3d_mutex_lock();    hr = wined3d_resource_sub_resource_map(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx,            &map_desc, rect ? &box : NULL, flags);    wined3d_mutex_unlock();    if (SUCCEEDED(hr))    {        locked_rect->Pitch = map_desc.row_pitch;        locked_rect->pBits = map_desc.data;    }    return hr;}

static HRESULT STDMETHODCALLTYPE d3d10_texture3d_Map(ID3D10Texture3D *iface, UINT sub_resource_idx,        D3D10_MAP map_type, UINT map_flags, D3D10_MAPPED_TEXTURE3D *mapped_texture){    struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(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_resource_map(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx,            &wined3d_map_desc, NULL, wined3d_map_flags_from_d3d11_map_type(map_type))))    {        mapped_texture->pData = wined3d_map_desc.data;        mapped_texture->RowPitch = wined3d_map_desc.row_pitch;        mapped_texture->DepthPitch = wined3d_map_desc.slice_pitch;    }    wined3d_mutex_unlock();    return hr;}

static void STDMETHODCALLTYPE d3d10_texture3d_Unmap(ID3D10Texture3D *iface, UINT sub_resource_idx){    struct d3d_texture3d *texture = impl_from_ID3D10Texture3D(iface);    TRACE("iface %p, sub_resource_idx %u./n", iface, sub_resource_idx);    wined3d_mutex_lock();    wined3d_resource_unmap(wined3d_texture_get_resource(texture->wined3d_texture), sub_resource_idx);    wined3d_mutex_unlock();}

static HRESULT WINAPI d3d8_volume_UnlockBox(IDirect3DVolume8 *iface){    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);    HRESULT hr;    TRACE("iface %p./n", iface);    wined3d_mutex_lock();    hr = wined3d_resource_sub_resource_unmap(wined3d_texture_get_resource(volume->wined3d_texture), volume->sub_resource_idx);    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d8_texture_3d_FreePrivateData(IDirect3DVolumeTexture8 *iface, REFGUID guid){    struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);    struct wined3d_resource *resource;    HRESULT hr;    TRACE("iface %p, guid %s./n", iface, debugstr_guid(guid));    wined3d_mutex_lock();    resource = wined3d_texture_get_resource(texture->wined3d_texture);    hr = wined3d_resource_free_private_data(resource, guid);    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI IDirect3DVolumeTexture9Impl_FreePrivateData(IDirect3DVolumeTexture9 *iface,        REFGUID refguid){    IDirect3DVolumeTexture9Impl *This = impl_from_IDirect3DVolumeTexture9(iface);    struct wined3d_resource *resource;    HRESULT hr;    TRACE("iface %p, guid %s./n", iface, debugstr_guid(refguid));    wined3d_mutex_lock();    resource = wined3d_texture_get_resource(This->wined3d_texture);    hr = wined3d_resource_free_private_data(resource, refguid);    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d8_texture_3d_GetPrivateData(IDirect3DVolumeTexture8 *iface,        REFGUID guid, void *data, DWORD *data_size){    struct d3d8_texture *texture = impl_from_IDirect3DVolumeTexture8(iface);    struct wined3d_resource *resource;    HRESULT hr;    TRACE("iface %p, guid %s, data %p, data_size %p./n",            iface, debugstr_guid(guid), data, data_size);    wined3d_mutex_lock();    resource = wined3d_texture_get_resource(texture->wined3d_texture);    hr = wined3d_resource_get_private_data(resource, guid, data, data_size);    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI IDirect3DVolumeTexture8Impl_GetPrivateData(IDirect3DVolumeTexture8 *iface,        REFGUID refguid, void *pData, DWORD *pSizeOfData){    IDirect3DVolumeTexture8Impl *This = impl_from_IDirect3DVolumeTexture8(iface);    struct wined3d_resource *resource;    HRESULT hr;    TRACE("iface %p, guid %s, data %p, data_size %p./n",            iface, debugstr_guid(refguid), pData, pSizeOfData);    wined3d_mutex_lock();    resource = wined3d_texture_get_resource(This->wined3d_texture);    hr = wined3d_resource_get_private_data(resource, refguid, pData, pSizeOfData);    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d9_surface_UnlockRect(IDirect3DSurface9 *iface){    struct d3d9_surface *surface = impl_from_IDirect3DSurface9(iface);    HRESULT hr;    TRACE("iface %p./n", iface);    wined3d_mutex_lock();    hr = wined3d_resource_sub_resource_unmap(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx);    wined3d_mutex_unlock();    switch(hr)    {        case WINEDDERR_NOTLOCKED:       return D3DERR_INVALIDCALL;        default:                        return hr;    }}

static HRESULT WINAPI IDirect3DVolumeTexture9Impl_SetPrivateData(IDirect3DVolumeTexture9 *iface,        REFGUID refguid, const void *pData, DWORD SizeOfData, DWORD Flags){    IDirect3DVolumeTexture9Impl *This = impl_from_IDirect3DVolumeTexture9(iface);    struct wined3d_resource *resource;    HRESULT hr;    TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x./n",            iface, debugstr_guid(refguid), pData, SizeOfData, Flags);    wined3d_mutex_lock();    resource = wined3d_texture_get_resource(This->wined3d_texture);    hr = wined3d_resource_set_private_data(resource, refguid, pData, SizeOfData, Flags);    wined3d_mutex_unlock();    return hr;}

static HRESULT WINAPI d3d8_texture_cube_SetPrivateData(IDirect3DCubeTexture8 *iface,        REFGUID guid, const void *data, DWORD data_size, DWORD flags){    struct d3d8_texture *texture = impl_from_IDirect3DCubeTexture8(iface);    struct wined3d_resource *resource;    HRESULT hr;    TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x./n",            iface, debugstr_guid(guid), data, data_size, flags);    wined3d_mutex_lock();    resource = wined3d_texture_get_resource(texture->wined3d_texture);    hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);    wined3d_mutex_unlock();    return hr;}

static struct wined3d_resource *wined3d_resource_from_resource(ID3D10Resource *resource){    D3D10_RESOURCE_DIMENSION dimension;    ID3D10Resource_GetType(resource, &dimension);    switch(dimension)    {        case D3D10_RESOURCE_DIMENSION_BUFFER:            return wined3d_buffer_get_resource(((struct d3d10_buffer *)resource)->wined3d_buffer);        case D3D10_RESOURCE_DIMENSION_TEXTURE2D:            return wined3d_texture_get_resource(((struct d3d10_texture2d *)resource)->wined3d_texture);        default:            FIXME("Unhandled resource dimension %#x./n", dimension);            return NULL;    }}

void surface_init(struct d3d9_surface *surface, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,        struct wined3d_surface *wined3d_surface, const struct wined3d_parent_ops **parent_ops){    struct wined3d_resource_desc desc;    IDirect3DBaseTexture9 *texture;    surface->IDirect3DSurface9_iface.lpVtbl = &d3d9_surface_vtbl;    d3d9_resource_init(&surface->resource);    surface->resource.refcount = 0;    surface->wined3d_surface = wined3d_surface;    list_init(&surface->rtv_entry);    surface->container = wined3d_texture_get_parent(wined3d_texture);    surface->wined3d_texture = wined3d_texture;    surface->sub_resource_idx = sub_resource_idx;    if (surface->container && SUCCEEDED(IUnknown_QueryInterface(surface->container,            &IID_IDirect3DBaseTexture9, (void **)&texture)))    {        surface->texture = unsafe_impl_from_IDirect3DBaseTexture9(texture);        IDirect3DBaseTexture9_Release(texture);    }    wined3d_resource_get_desc(wined3d_texture_get_resource(wined3d_texture), &desc);    switch (d3dformat_from_wined3dformat(desc.format))    {        case D3DFMT_A8R8G8B8:        case D3DFMT_X8R8G8B8:        case D3DFMT_R5G6B5:        case D3DFMT_X1R5G5B5:        case D3DFMT_A1R5G5B5:        case D3DFMT_R8G8B8:            surface->getdc_supported = TRUE;            break;        default:            surface->getdc_supported = FALSE;            break;    }    *parent_ops = &d3d9_surface_wined3d_parent_ops;}

static HRESULT WINAPI d3d8_volume_LockBox(IDirect3DVolume8 *iface,        D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags){    struct d3d8_volume *volume = impl_from_IDirect3DVolume8(iface);    struct wined3d_map_desc map_desc;    HRESULT hr;    TRACE("iface %p, locked_box %p, box %p, flags %#x./n",            iface, locked_box, box, flags);    wined3d_mutex_lock();    hr = wined3d_resource_sub_resource_map(wined3d_texture_get_resource(volume->wined3d_texture), volume->sub_resource_idx,            &map_desc, (const struct wined3d_box *)box, flags);    wined3d_mutex_unlock();    locked_box->RowPitch = map_desc.row_pitch;    locked_box->SlicePitch = map_desc.slice_pitch;    locked_box->pBits = map_desc.data;    return hr;}

static HRESULT WINAPI d3d8_surface_UnlockRect(IDirect3DSurface8 *iface){    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);    HRESULT hr;    TRACE("iface %p./n", iface);    wined3d_mutex_lock();    hr = wined3d_resource_unmap(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx);    wined3d_mutex_unlock();    if (hr == WINEDDERR_NOTLOCKED)    {        D3DRESOURCETYPE type;        if (surface->texture)            type = IDirect3DBaseTexture8_GetType(&surface->texture->IDirect3DBaseTexture8_iface);        else            type = D3DRTYPE_SURFACE;        hr = type == D3DRTYPE_TEXTURE ? D3D_OK : D3DERR_INVALIDCALL;    }    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 d3d_texture2d_init(struct d3d_texture2d *texture, struct d3d_device *device,        const D3D11_TEXTURE2D_DESC *desc, const D3D11_SUBRESOURCE_DATA *data){    struct wined3d_resource_desc wined3d_desc;    unsigned int levels;    HRESULT hr;    texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;    texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;    texture->refcount = 1;    wined3d_mutex_lock();    wined3d_private_store_init(&texture->private_store);    texture->desc = *desc;    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_d3d11(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;    levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;    if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,            levels, 0, (struct wined3d_sub_resource_data *)data, texture,            &d3d_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))    {        WARN("Failed to create wined3d texture, hr %#x./n", hr);        wined3d_private_store_cleanup(&texture->private_store);        wined3d_mutex_unlock();        return hr;    }    texture->desc.MipLevels = levels;    if (desc->MipLevels == 1 && desc->ArraySize == 1)    {        IWineDXGIDevice *wine_device;        if (FAILED(hr = ID3D10Device1_QueryInterface(&device->ID3D10Device1_iface, &IID_IWineDXGIDevice,                (void **)&wine_device)))        {            ERR("Device should implement IWineDXGIDevice./n");            wined3d_texture_decref(texture->wined3d_texture);            wined3d_mutex_unlock();            return E_FAIL;        }        hr = IWineDXGIDevice_create_surface(wine_device, wined3d_texture_get_resource(texture->wined3d_texture),                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);            texture->dxgi_surface = NULL;            wined3d_texture_decref(texture->wined3d_texture);            wined3d_mutex_unlock();            return hr;        }    }    wined3d_mutex_unlock();    texture->device = &device->ID3D11Device_iface;    ID3D11Device_AddRef(texture->device);    return S_OK;}

static HRESULT WINAPI d3d8_surface_LockRect(IDirect3DSurface8 *iface,        D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags){    struct d3d8_surface *surface = impl_from_IDirect3DSurface8(iface);    struct wined3d_box box;    struct wined3d_map_desc map_desc;    HRESULT hr;    D3DRESOURCETYPE type;    TRACE("iface %p, locked_rect %p, rect %s, flags %#x./n",            iface, locked_rect, wine_dbgstr_rect(rect), flags);    wined3d_mutex_lock();    if (surface->texture)        type = IDirect3DBaseTexture8_GetType(&surface->texture->IDirect3DBaseTexture8_iface);    else        type = D3DRTYPE_SURFACE;    if (rect)    {        D3DSURFACE_DESC desc;        IDirect3DSurface8_GetDesc(iface, &desc);        if (type != D3DRTYPE_TEXTURE                && ((rect->left < 0)                || (rect->top < 0)                || (rect->left >= rect->right)                || (rect->top >= rect->bottom)                || (rect->right > desc.Width)                || (rect->bottom > desc.Height)))        {            WARN("Trying to lock an invalid rectangle, returning D3DERR_INVALIDCALL/n");            wined3d_mutex_unlock();            locked_rect->Pitch = 0;            locked_rect->pBits = NULL;            return D3DERR_INVALIDCALL;        }        wined3d_box_set(&box, rect->left, rect->top, rect->right, rect->bottom, 0, 1);    }    hr = wined3d_resource_map(wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx,            &map_desc, rect ? &box : NULL, wined3dmapflags_from_d3dmapflags(flags, 0));    wined3d_mutex_unlock();    if (SUCCEEDED(hr))    {        locked_rect->Pitch = map_desc.row_pitch;        locked_rect->pBits = map_desc.data;    }    else if (type != D3DRTYPE_TEXTURE)    {        locked_rect->Pitch = 0;        locked_rect->pBits = NULL;    }    if (hr == E_INVALIDARG)        return D3DERR_INVALIDCALL;    return hr;}