From 1de6adfbae7ac36c6649aab209d1a62a64e80465 Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Tue, 1 Mar 2011 09:47:56 +0100 Subject: [PATCH] wined3d: Make IWineD3DResourceImpl an independent structure. --- dlls/d3d10core/view.c | 13 ++- dlls/d3d9/device.c | 16 +-- dlls/wined3d/basetexture.c | 10 +- dlls/wined3d/buffer.c | 76 +++++++------- dlls/wined3d/context.c | 8 +- dlls/wined3d/cubetexture.c | 64 ++++++------ dlls/wined3d/device.c | 181 +++++++++++++++++---------------- dlls/wined3d/palette.c | 8 +- dlls/wined3d/resource.c | 102 ++++++++++--------- dlls/wined3d/state.c | 4 +- dlls/wined3d/surface.c | 21 ++-- dlls/wined3d/surface_base.c | 19 ++-- dlls/wined3d/surface_gdi.c | 3 +- dlls/wined3d/texture.c | 63 ++++++------ dlls/wined3d/utils.c | 2 +- dlls/wined3d/view.c | 9 +- dlls/wined3d/volume.c | 18 ++-- dlls/wined3d/volumetexture.c | 61 +++++------ dlls/wined3d/wined3d.spec | 2 + dlls/wined3d/wined3d_private.h | 91 +++++++++-------- include/wine/wined3d.idl | 14 ++- 21 files changed, 416 insertions(+), 369 deletions(-) diff --git a/dlls/d3d10core/view.c b/dlls/d3d10core/view.c index 72b7f4e1c30..fd198264627 100644 --- a/dlls/d3d10core/view.c +++ b/dlls/d3d10core/view.c @@ -25,7 +25,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d10core); -static IWineD3DResource *wined3d_resource_from_resource(ID3D10Resource *resource) +static struct wined3d_resource *wined3d_resource_from_resource(ID3D10Resource *resource) { D3D10_RESOURCE_DIMENSION dimension; @@ -34,10 +34,10 @@ static IWineD3DResource *wined3d_resource_from_resource(ID3D10Resource *resource switch(dimension) { case D3D10_RESOURCE_DIMENSION_BUFFER: - return (IWineD3DResource *)((struct d3d10_buffer *)resource)->wined3d_buffer; + return IWineD3DBuffer_GetResource(((struct d3d10_buffer *)resource)->wined3d_buffer); case D3D10_RESOURCE_DIMENSION_TEXTURE2D: - return (IWineD3DResource *)((struct d3d10_texture2d *)resource)->wined3d_surface; + return IWineD3DSurface_GetResource(((struct d3d10_texture2d *)resource)->wined3d_surface); default: FIXME("Unhandled resource dimension %#x.\n", dimension); @@ -374,7 +374,7 @@ static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTa ID3D10Resource **resource) { struct d3d10_rendertarget_view *This = (struct d3d10_rendertarget_view *)iface; - IWineD3DResource *wined3d_resource; + struct wined3d_resource *wined3d_resource; IUnknown *parent; HRESULT hr; @@ -388,9 +388,8 @@ static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTa return; } - parent = IWineD3DResource_GetParent(wined3d_resource); + parent = wined3d_resource_get_parent(wined3d_resource); hr = IUnknown_QueryInterface(parent, &IID_ID3D10Resource, (void **)&resource); - IWineD3DResource_Release(wined3d_resource); if (FAILED(hr)) { ERR("Resource parent isn't a d3d10 resource, hr %#x\n", hr); @@ -431,7 +430,7 @@ static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl = HRESULT d3d10_rendertarget_view_init(struct d3d10_rendertarget_view *view, struct d3d10_device *device, ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc) { - IWineD3DResource *wined3d_resource; + struct wined3d_resource *wined3d_resource; HRESULT hr; view->vtbl = &d3d10_rendertarget_view_vtbl; diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c index 1b6592ed88b..c6efc48cac4 100644 --- a/dlls/d3d9/device.c +++ b/dlls/d3d9/device.c @@ -529,27 +529,28 @@ static UINT WINAPI IDirect3DDevice9Impl_GetNumberOfSwapChains(IDirect3DDevice9Ex return count; } -static HRESULT WINAPI reset_enum_callback(IWineD3DResource *resource, void *data) { +static HRESULT WINAPI reset_enum_callback(struct wined3d_resource *resource, void *data) +{ BOOL *resources_ok = data; D3DRESOURCETYPE type; HRESULT ret = S_OK; - WINED3DSURFACE_DESC surface_desc; - WINED3DVOLUME_DESC volume_desc; + D3DSURFACE_DESC surface_desc; + D3DVOLUME_DESC volume_desc; D3DINDEXBUFFER_DESC index_desc; D3DVERTEXBUFFER_DESC vertex_desc; WINED3DPOOL pool; IDirect3DResource9 *parent; - parent = IWineD3DResource_GetParent(resource); + parent = wined3d_resource_get_parent(resource); type = IDirect3DResource9_GetType(parent); switch(type) { case D3DRTYPE_SURFACE: - IWineD3DSurface_GetDesc((IWineD3DSurface *) resource, &surface_desc); - pool = surface_desc.pool; + IDirect3DSurface9_GetDesc((IDirect3DSurface9 *)parent, &surface_desc); + pool = surface_desc.Pool; break; case D3DRTYPE_VOLUME: - IWineD3DVolume_GetDesc((IWineD3DVolume *) resource, &volume_desc); + IDirect3DVolume9_GetDesc((IDirect3DVolume9 *)parent, &volume_desc); pool = volume_desc.Pool; break; @@ -583,7 +584,6 @@ static HRESULT WINAPI reset_enum_callback(IWineD3DResource *resource, void *data *resources_ok = FALSE; } } - IWineD3DResource_Release(resource); return ret; } diff --git a/dlls/wined3d/basetexture.c b/dlls/wined3d/basetexture.c index cb7227f504f..8b2797eff7a 100644 --- a/dlls/wined3d/basetexture.c +++ b/dlls/wined3d/basetexture.c @@ -34,7 +34,7 @@ HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_ { HRESULT hr; - hr = resource_init((IWineD3DResourceImpl *)texture, resource_type, device, + hr = resource_init(&texture->resource, resource_type, device, 0, usage, format, pool, parent, parent_ops, resource_ops); if (FAILED(hr)) { @@ -48,7 +48,7 @@ HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_ if (!texture->baseTexture.sub_resources) { ERR("Failed to allocate sub-resource array.\n"); - resource_cleanup((IWineD3DResourceImpl *)texture); + resource_cleanup(&texture->resource); return E_OUTOFMEMORY; } @@ -79,10 +79,10 @@ void basetexture_cleanup(IWineD3DBaseTextureImpl *texture) { basetexture_unload(texture); HeapFree(GetProcessHeap(), 0, texture->baseTexture.sub_resources); - resource_cleanup((IWineD3DResourceImpl *)texture); + resource_cleanup(&texture->resource); } -IWineD3DResourceImpl *basetexture_get_sub_resource(IWineD3DBaseTextureImpl *texture, UINT sub_resource_idx) +struct wined3d_resource *basetexture_get_sub_resource(IWineD3DBaseTextureImpl *texture, UINT sub_resource_idx) { UINT sub_count = texture->baseTexture.level_count * texture->baseTexture.layer_count; @@ -125,7 +125,7 @@ void basetexture_unload(IWineD3DBaseTextureImpl *texture) texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_srgb.dirty = TRUE; - resource_unload((IWineD3DResourceImpl *)texture); + resource_unload(&texture->resource); } DWORD basetexture_set_lod(IWineD3DBaseTextureImpl *texture, DWORD lod) diff --git a/dlls/wined3d/buffer.c b/dlls/wined3d/buffer.c index 04d8f2f1121..f17928d3e23 100644 --- a/dlls/wined3d/buffer.c +++ b/dlls/wined3d/buffer.c @@ -693,39 +693,39 @@ BYTE *buffer_get_sysmem(struct wined3d_buffer *This, const struct wined3d_gl_inf } /* Do not call while under the GL lock. */ -static void buffer_unload(IWineD3DResourceImpl *resource) +static void buffer_unload(struct wined3d_resource *resource) { - struct wined3d_buffer *This = (struct wined3d_buffer *)resource; + struct wined3d_buffer *buffer = buffer_from_resource(resource); - TRACE("buffer %p.\n", This); + TRACE("buffer %p.\n", buffer); - if (This->buffer_object) + if (buffer->buffer_object) { - IWineD3DDeviceImpl *device = resource->resource.device; + IWineD3DDeviceImpl *device = resource->device; struct wined3d_context *context; context = context_acquire(device, NULL); /* Download the buffer, but don't permanently enable double buffering */ - if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)) + if (!(buffer->flags & WINED3D_BUFFER_DOUBLEBUFFER)) { - buffer_get_sysmem(This, context->gl_info); - This->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER; + buffer_get_sysmem(buffer, context->gl_info); + buffer->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER; } - delete_gl_buffer(This, context->gl_info); - This->flags |= WINED3D_BUFFER_CREATEBO; /* Recreate the buffer object next load */ - buffer_clear_dirty_areas(This); + delete_gl_buffer(buffer, context->gl_info); + buffer->flags |= WINED3D_BUFFER_CREATEBO; /* Recreate the buffer object next load */ + buffer_clear_dirty_areas(buffer); context_release(context); - HeapFree(GetProcessHeap(), 0, This->conversion_shift); - This->conversion_shift = NULL; - HeapFree(GetProcessHeap(), 0, This->conversion_map); - This->conversion_map = NULL; - This->stride = 0; - This->conversion_stride = 0; - This->flags &= ~WINED3D_BUFFER_HASDESC; + HeapFree(GetProcessHeap(), 0, buffer->conversion_shift); + buffer->conversion_shift = NULL; + HeapFree(GetProcessHeap(), 0, buffer->conversion_map); + buffer->conversion_map = NULL; + buffer->stride = 0; + buffer->conversion_stride = 0; + buffer->flags &= ~WINED3D_BUFFER_HASDESC; } resource_unload(resource); @@ -741,8 +741,8 @@ static ULONG STDMETHODCALLTYPE buffer_Release(IWineD3DBuffer *iface) if (!refcount) { - buffer_unload((IWineD3DResourceImpl *)This); - resource_cleanup((IWineD3DResourceImpl *)iface); + buffer_unload(&This->resource); + resource_cleanup(&This->resource); This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent); HeapFree(GetProcessHeap(), 0, This->maps); HeapFree(GetProcessHeap(), 0, This); @@ -764,28 +764,28 @@ static void * STDMETHODCALLTYPE buffer_GetParent(IWineD3DBuffer *iface) static HRESULT STDMETHODCALLTYPE buffer_SetPrivateData(IWineD3DBuffer *iface, REFGUID guid, const void *data, DWORD data_size, DWORD flags) { - return resource_set_private_data((IWineD3DResourceImpl *)iface, guid, data, data_size, flags); + return resource_set_private_data(&((struct wined3d_buffer *)iface)->resource, guid, data, data_size, flags); } static HRESULT STDMETHODCALLTYPE buffer_GetPrivateData(IWineD3DBuffer *iface, REFGUID guid, void *data, DWORD *data_size) { - return resource_get_private_data((IWineD3DResourceImpl *)iface, guid, data, data_size); + return resource_get_private_data(&((struct wined3d_buffer *)iface)->resource, guid, data, data_size); } static HRESULT STDMETHODCALLTYPE buffer_FreePrivateData(IWineD3DBuffer *iface, REFGUID guid) { - return resource_free_private_data((IWineD3DResourceImpl *)iface, guid); + return resource_free_private_data(&((struct wined3d_buffer *)iface)->resource, guid); } static DWORD STDMETHODCALLTYPE buffer_SetPriority(IWineD3DBuffer *iface, DWORD priority) { - return resource_set_priority((IWineD3DResourceImpl *)iface, priority); + return resource_set_priority(&((struct wined3d_buffer *)iface)->resource, priority); } static DWORD STDMETHODCALLTYPE buffer_GetPriority(IWineD3DBuffer *iface) { - return resource_get_priority((IWineD3DResourceImpl *)iface); + return resource_get_priority(&((struct wined3d_buffer *)iface)->resource); } /* The caller provides a context and binds the buffer */ @@ -997,7 +997,7 @@ static void STDMETHODCALLTYPE buffer_PreLoad(IWineD3DBuffer *iface) { FIXME("Too many declaration changes or converting dynamic buffer, stopping converting\n"); - buffer_unload((IWineD3DResourceImpl *)This); + buffer_unload(&This->resource); This->flags &= ~WINED3D_BUFFER_CREATEBO; /* The stream source state handler might have read the memory of the vertex buffer already @@ -1035,7 +1035,7 @@ static void STDMETHODCALLTYPE buffer_PreLoad(IWineD3DBuffer *iface) if(This->full_conversion_count > VB_MAXFULLCONVERSIONS) { FIXME("Too many full buffer conversions, stopping converting\n"); - buffer_unload((IWineD3DResourceImpl *)This); + buffer_unload(&This->resource); This->flags &= ~WINED3D_BUFFER_CREATEBO; IWineD3DDeviceImpl_MarkStateDirty(device, STATE_STREAMSRC); goto end; @@ -1190,7 +1190,7 @@ end: static WINED3DRESOURCETYPE STDMETHODCALLTYPE buffer_GetType(IWineD3DBuffer *iface) { - return resource_get_type((IWineD3DResourceImpl *)iface); + return resource_get_type(&((struct wined3d_buffer *)iface)->resource); } /* IWineD3DBuffer methods */ @@ -1245,6 +1245,13 @@ static GLbitfield buffer_gl_map_flags(DWORD d3d_flags) return ret; } +static struct wined3d_resource * STDMETHODCALLTYPE buffer_GetResource(IWineD3DBuffer *iface) +{ + TRACE("iface %p.\n", iface); + + return &((struct wined3d_buffer *)iface)->resource; +} + static HRESULT STDMETHODCALLTYPE buffer_Map(IWineD3DBuffer *iface, UINT offset, UINT size, BYTE **data, DWORD flags) { struct wined3d_buffer *This = (struct wined3d_buffer *)iface; @@ -1450,6 +1457,7 @@ static const struct IWineD3DBufferVtbl wined3d_buffer_vtbl = buffer_PreLoad, buffer_GetType, /* IWineD3DBuffer methods */ + buffer_GetResource, buffer_Map, buffer_Unmap, buffer_GetDesc, @@ -1477,8 +1485,8 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device, buffer->vtbl = &wined3d_buffer_vtbl; - hr = resource_init((IWineD3DResourceImpl *)buffer, WINED3DRTYPE_BUFFER, - device, size, usage, format, pool, parent, parent_ops, &buffer_resource_ops); + hr = resource_init(&buffer->resource, WINED3DRTYPE_BUFFER, device, size, + usage, format, pool, parent, parent_ops, &buffer_resource_ops); if (FAILED(hr)) { WARN("Failed to initialize resource, hr %#x\n", hr); @@ -1524,8 +1532,8 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device, if (FAILED(hr)) { ERR("Failed to map buffer, hr %#x\n", hr); - buffer_unload((IWineD3DResourceImpl *)buffer); - resource_cleanup((IWineD3DResourceImpl *)buffer); + buffer_unload(&buffer->resource); + resource_cleanup(&buffer->resource); return hr; } @@ -1538,8 +1546,8 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device, if (!buffer->maps) { ERR("Out of memory\n"); - buffer_unload((IWineD3DResourceImpl *)buffer); - resource_cleanup((IWineD3DResourceImpl *)buffer); + buffer_unload(&buffer->resource); + resource_cleanup(&buffer->resource); return E_OUTOFMEMORY; } buffer->maps_size = 1; diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index b7abc0fa906..cc0ad7e8de2 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -690,14 +690,14 @@ static void context_queue_fbo_entry_destruction(struct wined3d_context *context, } void context_resource_released(struct IWineD3DDeviceImpl *device, - struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) + struct wined3d_resource *resource, WINED3DRESOURCETYPE type) { if (!device->d3d_initialized) return; switch (type) { case WINED3DRTYPE_SURFACE: - context_enum_surface_fbo_entries(device, (IWineD3DSurfaceImpl *)resource, + context_enum_surface_fbo_entries(device, surface_from_resource(resource), context_queue_fbo_entry_destruction); break; @@ -712,12 +712,12 @@ static void context_detach_fbo_entry(struct wined3d_context *context, struct fbo } void context_resource_unloaded(struct IWineD3DDeviceImpl *device, - struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) + struct wined3d_resource *resource, WINED3DRESOURCETYPE type) { switch (type) { case WINED3DRTYPE_SURFACE: - context_enum_surface_fbo_entries(device, (IWineD3DSurfaceImpl *)resource, + context_enum_surface_fbo_entries(device, surface_from_resource(resource), context_detach_fbo_entry); break; diff --git a/dlls/wined3d/cubetexture.c b/dlls/wined3d/cubetexture.c index bf54b074988..0fc5aba08e0 100644 --- a/dlls/wined3d/cubetexture.c +++ b/dlls/wined3d/cubetexture.c @@ -43,7 +43,7 @@ static HRESULT cubetexture_bind(IWineD3DBaseTextureImpl *texture, BOOL srgb) for (i = 0; i < sub_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(texture->baseTexture.sub_resources[i]); if (texture->baseTexture.is_srgb) surface_set_texture_name(surface, texture->baseTexture.texture_srgb.name, TRUE); @@ -102,7 +102,7 @@ static void cubetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSR { for (i = 0; i < sub_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(texture->baseTexture.sub_resources[i]); if (palette9_changed(surface)) { @@ -122,7 +122,7 @@ static void cubetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSR { for (i = 0; i < sub_count; ++i) { - surface_load((IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i], srgb_mode); + surface_load(surface_from_resource(texture->baseTexture.sub_resources[i]), srgb_mode); } } else @@ -137,9 +137,9 @@ static void cubetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSR } /* Do not call while under the GL lock. */ -static void cubetexture_unload(IWineD3DResourceImpl *resource) +static void cubetexture_unload(struct wined3d_resource *resource) { - IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)resource; + IWineD3DBaseTextureImpl *texture = basetexture_from_resource(resource); UINT sub_count = texture->baseTexture.level_count * texture->baseTexture.layer_count; UINT i; @@ -147,9 +147,10 @@ static void cubetexture_unload(IWineD3DResourceImpl *resource) for (i = 0; i < sub_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i]; + struct wined3d_resource *sub_resource = texture->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(sub_resource); - surface->resource.resource_ops->resource_unload((IWineD3DResourceImpl *)surface); + resource->resource_ops->resource_unload(sub_resource); surface_set_texture_name(surface, 0, TRUE); surface_set_texture_name(surface, 0, FALSE); } @@ -177,7 +178,7 @@ static void cubetexture_cleanup(IWineD3DCubeTextureImpl *This) for (i = 0; i < sub_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)This->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(This->baseTexture.sub_resources[i]); if (surface) { @@ -241,28 +242,28 @@ static ULONG WINAPI IWineD3DCubeTextureImpl_Release(IWineD3DCubeTexture *iface) static HRESULT WINAPI IWineD3DCubeTextureImpl_SetPrivateData(IWineD3DCubeTexture *iface, REFGUID riid, const void *data, DWORD data_size, DWORD flags) { - return resource_set_private_data((IWineD3DResourceImpl *)iface, riid, data, data_size, flags); + return resource_set_private_data(&((IWineD3DCubeTextureImpl *)iface)->resource, riid, data, data_size, flags); } static HRESULT WINAPI IWineD3DCubeTextureImpl_GetPrivateData(IWineD3DCubeTexture *iface, REFGUID guid, void *data, DWORD *data_size) { - return resource_get_private_data((IWineD3DResourceImpl *)iface, guid, data, data_size); + return resource_get_private_data(&((IWineD3DCubeTextureImpl *)iface)->resource, guid, data, data_size); } static HRESULT WINAPI IWineD3DCubeTextureImpl_FreePrivateData(IWineD3DCubeTexture *iface, REFGUID refguid) { - return resource_free_private_data((IWineD3DResourceImpl *)iface, refguid); + return resource_free_private_data(&((IWineD3DCubeTextureImpl *)iface)->resource, refguid); } static DWORD WINAPI IWineD3DCubeTextureImpl_SetPriority(IWineD3DCubeTexture *iface, DWORD priority) { - return resource_set_priority((IWineD3DResourceImpl *)iface, priority); + return resource_set_priority(&((IWineD3DCubeTextureImpl *)iface)->resource, priority); } static DWORD WINAPI IWineD3DCubeTextureImpl_GetPriority(IWineD3DCubeTexture *iface) { - return resource_get_priority((IWineD3DResourceImpl *)iface); + return resource_get_priority(&((IWineD3DCubeTextureImpl *)iface)->resource); } /* Do not call while under the GL lock. */ @@ -273,7 +274,7 @@ static void WINAPI IWineD3DCubeTextureImpl_PreLoad(IWineD3DCubeTexture *iface) static WINED3DRESOURCETYPE WINAPI IWineD3DCubeTextureImpl_GetType(IWineD3DCubeTexture *iface) { - return resource_get_type((IWineD3DResourceImpl *)iface); + return resource_get_type(&((IWineD3DCubeTextureImpl *)iface)->resource); } static void * WINAPI IWineD3DCubeTextureImpl_GetParent(IWineD3DCubeTexture *iface) @@ -326,17 +327,17 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_GetLevelDesc(IWineD3DCubeTexture * UINT sub_resource_idx, WINED3DSURFACE_DESC *desc) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, desc %p.\n", iface, sub_resource_idx, desc); - if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - IWineD3DSurface_GetDesc(surface, desc); + IWineD3DSurface_GetDesc((IWineD3DSurface *)surface_from_resource(sub_resource), desc); return WINED3D_OK; } @@ -345,19 +346,19 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_GetCubeMapSurface(IWineD3DCubeText UINT sub_resource_idx, IWineD3DSurface **surface) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *s; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, surface %p.\n", iface, sub_resource_idx, surface); - if (!(s = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - IWineD3DSurface_AddRef(s); - *surface = s; + *surface = (IWineD3DSurface *)surface_from_resource(sub_resource); + IWineD3DSurface_AddRef(*surface); TRACE("Returning surface %p.\n", *surface); @@ -368,36 +369,37 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_Map(IWineD3DCubeTexture *iface, UINT sub_resource_idx, WINED3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, locked_rect %p, rect %s, flags %#x.\n", iface, sub_resource_idx, locked_rect, wine_dbgstr_rect(rect), flags); - if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_Map(surface, locked_rect, rect, flags); + return IWineD3DSurface_Map((IWineD3DSurface *)surface_from_resource(sub_resource), + locked_rect, rect, flags); } static HRESULT WINAPI IWineD3DCubeTextureImpl_Unmap(IWineD3DCubeTexture *iface, UINT sub_resource_idx) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx); - if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_Unmap(surface); + return IWineD3DSurface_Unmap((IWineD3DSurface *)surface_from_resource(sub_resource)); } static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture *iface, @@ -405,12 +407,12 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture * { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; UINT sub_resource_idx = face * texture->baseTexture.level_count; - IWineD3DSurfaceImpl *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, face %u, dirty_rect %s.\n", iface, face, wine_dbgstr_rect(dirty_rect)); - if (!(surface = (IWineD3DSurfaceImpl *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; @@ -418,7 +420,7 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture * texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_srgb.dirty = TRUE; - surface_add_dirty_rect(surface, dirty_rect); + surface_add_dirty_rect(surface_from_resource(sub_resource), dirty_rect); return WINED3D_OK; } @@ -566,7 +568,7 @@ HRESULT cubetexture_init(IWineD3DCubeTextureImpl *texture, UINT edge_length, UIN surface_set_container((IWineD3DSurfaceImpl *)surface, WINED3D_CONTAINER_TEXTURE, (IWineD3DBase *)texture); surface_set_texture_target((IWineD3DSurfaceImpl *)surface, cube_targets[j]); - texture->baseTexture.sub_resources[idx] = (IWineD3DResourceImpl *)surface; + texture->baseTexture.sub_resources[idx] = &((IWineD3DSurfaceImpl *)surface)->resource; TRACE("Created surface level %u @ %p.\n", i, surface); } tmp_w = max(1, tmp_w >> 1); diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index d292813243f..6c4814d943a 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -867,14 +867,13 @@ static ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) { if (!list_empty(&This->resources)) { - IWineD3DResourceImpl *resource; + struct wined3d_resource *resource; FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This); - LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) + LIST_FOR_EACH_ENTRY(resource, &This->resources, struct wined3d_resource, resource_list_entry) { - WINED3DRESOURCETYPE type = IWineD3DResource_GetType((IWineD3DResource *)resource); FIXME("Leftover resource %p with type %s (%#x).\n", - resource, debug_d3dresourcetype(type), type); + resource, debug_d3dresourcetype(resource->resourceType), resource->resourceType); } } @@ -1079,7 +1078,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateSurface(IWineD3DDevice *iface, UI } static HRESULT WINAPI IWineD3DDeviceImpl_CreateRendertargetView(IWineD3DDevice *iface, - IWineD3DResource *resource, void *parent, IWineD3DRendertargetView **rendertarget_view) + struct wined3d_resource *resource, void *parent, IWineD3DRendertargetView **rendertarget_view) { struct wined3d_rendertarget_view *object; @@ -1093,7 +1092,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateRendertargetView(IWineD3DDevice * return E_OUTOFMEMORY; } - wined3d_rendertarget_view_init(object, (IWineD3DResourceImpl *)resource, parent); + wined3d_rendertarget_view_init(object, resource, parent); TRACE("Created render target view %p.\n", object); *rendertarget_view = (IWineD3DRendertargetView *)object; @@ -2102,12 +2101,11 @@ err_out: return hr; } -static HRESULT WINAPI device_unload_resource(IWineD3DResource *resource, void *data) +static HRESULT WINAPI device_unload_resource(struct wined3d_resource *resource, void *data) { TRACE("Unloading resource %p.\n", resource); - ((IWineD3DResourceImpl *)resource)->resource.resource_ops->resource_unload((IWineD3DResourceImpl *)resource); - IWineD3DResource_Release(resource); + resource->resource_ops->resource_unload(resource); return S_OK; } @@ -5726,7 +5724,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_ColorFill(IWineD3DDevice *iface, static void WINAPI IWineD3DDeviceImpl_ClearRendertargetView(IWineD3DDevice *iface, IWineD3DRendertargetView *rendertarget_view, const WINED3DCOLORVALUE *color) { - IWineD3DResource *resource; + struct wined3d_resource *resource; HRESULT hr; hr = IWineD3DRendertargetView_GetResource(rendertarget_view, &resource); @@ -5736,17 +5734,14 @@ static void WINAPI IWineD3DDeviceImpl_ClearRendertargetView(IWineD3DDevice *ifac return; } - if (IWineD3DResource_GetType(resource) != WINED3DRTYPE_SURFACE) + if (resource->resourceType != WINED3DRTYPE_SURFACE) { FIXME("Only supported on surface resources\n"); - IWineD3DResource_Release(resource); return; } - hr = surface_color_fill((IWineD3DSurfaceImpl *)resource, NULL, color); + hr = surface_color_fill(surface_from_resource(resource), NULL, color); if (FAILED(hr)) ERR("Color fill failed, hr %#x.\n", hr); - - IWineD3DResource_Release(resource); } /* rendertarget and depth stencil functions */ @@ -6099,13 +6094,16 @@ static BOOL WINAPI IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOO return oldVisible; } -static HRESULT WINAPI evict_managed_resource(IWineD3DResource *resource, void *data) { +static HRESULT WINAPI evict_managed_resource(struct wined3d_resource *resource, void *data) +{ TRACE("checking resource %p for eviction\n", resource); - if(((IWineD3DResourceImpl *) resource)->resource.pool == WINED3DPOOL_MANAGED) { - TRACE("Evicting %p\n", resource); - ((IWineD3DResourceImpl *)resource)->resource.resource_ops->resource_unload((IWineD3DResourceImpl *)resource); + + if (resource->pool == WINED3DPOOL_MANAGED) + { + TRACE("Evicting %p.\n", resource); + resource->resource_ops->resource_unload(resource); } - IWineD3DResource_Release(resource); + return S_OK; } @@ -6626,23 +6624,23 @@ static void WINAPI IWineD3DDeviceImpl_GetGammaRamp(IWineD3DDevice *iface, UINT i } } -void device_resource_add(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) +void device_resource_add(struct IWineD3DDeviceImpl *device, struct wined3d_resource *resource) { TRACE("device %p, resource %p.\n", device, resource); - list_add_head(&device->resources, &resource->resource.resource_list_entry); + list_add_head(&device->resources, &resource->resource_list_entry); } -static void device_resource_remove(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) +static void device_resource_remove(struct IWineD3DDeviceImpl *device, struct wined3d_resource *resource) { TRACE("device %p, resource %p.\n", device, resource); - list_remove(&resource->resource.resource_list_entry); + list_remove(&resource->resource_list_entry); } -void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) +void device_resource_released(struct IWineD3DDeviceImpl *device, struct wined3d_resource *resource) { - WINED3DRESOURCETYPE type = IWineD3DResource_GetType((IWineD3DResource *)resource); + WINED3DRESOURCETYPE type = resource->resourceType; unsigned int i; TRACE("device %p, resource %p, type %s.\n", device, resource, debug_d3dresourcetype(type)); @@ -6652,21 +6650,25 @@ void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3D switch (type) { case WINED3DRTYPE_SURFACE: - if (!device->d3d_initialized) break; - - for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i) { - if (device->render_targets[i] == (IWineD3DSurfaceImpl *)resource) + IWineD3DSurfaceImpl *surface = surface_from_resource(resource); + + if (!device->d3d_initialized) break; + + for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i) { - ERR("Surface %p is still in use as render target %u.\n", resource, i); - device->render_targets[i] = NULL; + if (device->render_targets[i] == surface) + { + ERR("Surface %p is still in use as render target %u.\n", surface, i); + device->render_targets[i] = NULL; + } } - } - if (device->depth_stencil == (IWineD3DSurfaceImpl *)resource) - { - ERR("Surface %p is still in use as depth/stencil buffer.\n", resource); - device->depth_stencil = NULL; + if (device->depth_stencil == surface) + { + ERR("Surface %p is still in use as depth/stencil buffer.\n", surface); + device->depth_stencil = NULL; + } } break; @@ -6675,57 +6677,62 @@ void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3D case WINED3DRTYPE_VOLUMETEXTURE: for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i) { - if (device->stateBlock && device->stateBlock->state.textures[i] == (IWineD3DBaseTextureImpl *)resource) + IWineD3DBaseTextureImpl *texture = basetexture_from_resource(resource); + + if (device->stateBlock && device->stateBlock->state.textures[i] == texture) { ERR("Texture %p is still in use by stateblock %p, stage %u.\n", - resource, device->stateBlock, i); + texture, device->stateBlock, i); device->stateBlock->state.textures[i] = NULL; } if (device->updateStateBlock != device->stateBlock - && device->updateStateBlock->state.textures[i] == (IWineD3DBaseTextureImpl *)resource) + && device->updateStateBlock->state.textures[i] == texture) { ERR("Texture %p is still in use by stateblock %p, stage %u.\n", - resource, device->updateStateBlock, i); + texture, device->updateStateBlock, i); device->updateStateBlock->state.textures[i] = NULL; } } break; case WINED3DRTYPE_BUFFER: - for (i = 0; i < MAX_STREAMS; ++i) { - if (device->stateBlock - && device->stateBlock->state.streams[i].buffer == (struct wined3d_buffer *)resource) + struct wined3d_buffer *buffer = buffer_from_resource(resource); + + for (i = 0; i < MAX_STREAMS; ++i) { - ERR("Buffer %p is still in use by stateblock %p, stream %u.\n", - resource, device->stateBlock, i); - device->stateBlock->state.streams[i].buffer = NULL; + if (device->stateBlock && device->stateBlock->state.streams[i].buffer == buffer) + { + ERR("Buffer %p is still in use by stateblock %p, stream %u.\n", + buffer, device->stateBlock, i); + device->stateBlock->state.streams[i].buffer = NULL; + } + + if (device->updateStateBlock != device->stateBlock + && device->updateStateBlock->state.streams[i].buffer == buffer) + { + ERR("Buffer %p is still in use by stateblock %p, stream %u.\n", + buffer, device->updateStateBlock, i); + device->updateStateBlock->state.streams[i].buffer = NULL; + } + + } + + if (device->stateBlock && device->stateBlock->state.index_buffer == buffer) + { + ERR("Buffer %p is still in use by stateblock %p as index buffer.\n", + buffer, device->stateBlock); + device->stateBlock->state.index_buffer = NULL; } if (device->updateStateBlock != device->stateBlock - && device->updateStateBlock->state.streams[i].buffer == (struct wined3d_buffer *)resource) + && device->updateStateBlock->state.index_buffer == buffer) { - ERR("Buffer %p is still in use by stateblock %p, stream %u.\n", - resource, device->updateStateBlock, i); - device->updateStateBlock->state.streams[i].buffer = NULL; + ERR("Buffer %p is still in use by stateblock %p as index buffer.\n", + buffer, device->updateStateBlock); + device->updateStateBlock->state.index_buffer = NULL; } - - } - - if (device->stateBlock && device->stateBlock->state.index_buffer == (struct wined3d_buffer *)resource) - { - ERR("Buffer %p is still in use by stateblock %p as index buffer.\n", - resource, device->stateBlock); - device->stateBlock->state.index_buffer = NULL; - } - - if (device->updateStateBlock != device->stateBlock - && device->updateStateBlock->state.index_buffer == (struct wined3d_buffer *)resource) - { - ERR("Buffer %p is still in use by stateblock %p as index buffer.\n", - resource, device->updateStateBlock); - device->updateStateBlock->state.index_buffer = NULL; } break; @@ -6739,38 +6746,42 @@ void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3D TRACE("Resource released.\n"); } -static HRESULT WINAPI IWineD3DDeviceImpl_EnumResources(IWineD3DDevice *iface, D3DCB_ENUMRESOURCES pCallback, void *pData) { +static HRESULT WINAPI IWineD3DDeviceImpl_EnumResources(IWineD3DDevice *iface, + D3DCB_ENUMRESOURCES callback, void *data) +{ IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; - IWineD3DResourceImpl *resource, *cursor; - HRESULT ret; - TRACE("(%p)->(%p,%p)\n", This, pCallback, pData); + struct wined3d_resource *resource, *cursor; - LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) { - TRACE("enumerating resource %p\n", resource); - IWineD3DResource_AddRef((IWineD3DResource *) resource); - ret = pCallback((IWineD3DResource *) resource, pData); - if(ret == S_FALSE) { - TRACE("Canceling enumeration\n"); + TRACE("iface %p, callback %p, data %p.\n", iface, callback, data); + + LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &This->resources, struct wined3d_resource, resource_list_entry) + { + TRACE("enumerating resource %p.\n", resource); + if (callback(resource, data) == S_FALSE) + { + TRACE("Canceling enumeration.\n"); break; } } + return WINED3D_OK; } static HRESULT WINAPI IWineD3DDeviceImpl_GetSurfaceFromDC(IWineD3DDevice *iface, HDC dc, IWineD3DSurface **surface) { - IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; - IWineD3DResourceImpl *resource; + IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface; + struct wined3d_resource *resource; - LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) + LIST_FOR_EACH_ENTRY(resource, &This->resources, struct wined3d_resource, resource_list_entry) { - WINED3DRESOURCETYPE type = IWineD3DResource_GetType((IWineD3DResource *)resource); - if (type == WINED3DRTYPE_SURFACE) + if (resource->resourceType == WINED3DRTYPE_SURFACE) { - if (((IWineD3DSurfaceImpl *)resource)->hDC == dc) + IWineD3DSurfaceImpl *s = surface_from_resource(resource); + + if (s->hDC == dc) { - TRACE("Found surface %p for dc %p.\n", resource, dc); - *surface = (IWineD3DSurface *)resource; + TRACE("Found surface %p for dc %p.\n", s, dc); + *surface = (IWineD3DSurface *)s; return WINED3D_OK; } } diff --git a/dlls/wined3d/palette.c b/dlls/wined3d/palette.c index d14587aaf3f..e70c2f1347a 100644 --- a/dlls/wined3d/palette.c +++ b/dlls/wined3d/palette.c @@ -95,7 +95,7 @@ HRESULT CDECL wined3d_palette_get_entries(const struct wined3d_palette *palette, HRESULT CDECL wined3d_palette_set_entries(struct wined3d_palette *palette, DWORD flags, DWORD start, DWORD count, const PALETTEENTRY *entries) { - IWineD3DResourceImpl *res; + struct wined3d_resource *resource; TRACE("palette %p, flags %#x, start %u, count %u, entries %p.\n", palette, flags, start, count, entries); @@ -131,11 +131,11 @@ HRESULT CDECL wined3d_palette_set_entries(struct wined3d_palette *palette, } /* If the palette is attached to the render target, update all render targets */ - LIST_FOR_EACH_ENTRY(res, &palette->device->resources, IWineD3DResourceImpl, resource.resource_list_entry) + LIST_FOR_EACH_ENTRY(resource, &palette->device->resources, struct wined3d_resource, resource_list_entry) { - if (IWineD3DResource_GetType((IWineD3DResource *)res) == WINED3DRTYPE_SURFACE) + if (resource->resourceType == WINED3DRTYPE_SURFACE) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)res; + IWineD3DSurfaceImpl *surface = surface_from_resource(resource); if (surface->palette == palette) surface->surface_ops->surface_realize_palette(surface); } diff --git a/dlls/wined3d/resource.c b/dlls/wined3d/resource.c index d43cdfa5bf6..5a9d5d69dbf 100644 --- a/dlls/wined3d/resource.c +++ b/dlls/wined3d/resource.c @@ -43,30 +43,28 @@ struct private_data DWORD size; }; -HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE resource_type, +HRESULT resource_init(struct wined3d_resource *resource, WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format *format, WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_resource_ops *resource_ops) { - struct IWineD3DResourceClass *r = &resource->resource; - - r->device = device; - r->resourceType = resource_type; - r->ref = 1; - r->pool = pool; - r->format = format; - r->usage = usage; - r->size = size; - r->priority = 0; - r->parent = parent; - r->parent_ops = parent_ops; - r->resource_ops = resource_ops; - list_init(&r->privateData); + resource->device = device; + resource->resourceType = resource_type; + resource->ref = 1; + resource->pool = pool; + resource->format = format; + resource->usage = usage; + resource->size = size; + resource->priority = 0; + resource->parent = parent; + resource->parent_ops = parent_ops; + resource->resource_ops = resource_ops; + list_init(&resource->privateData); if (size) { - r->heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size + RESOURCE_ALIGNMENT); - if (!r->heapMemory) + resource->heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size + RESOURCE_ALIGNMENT); + if (!resource->heapMemory) { ERR("Out of memory!\n"); return WINED3DERR_OUTOFVIDEOMEMORY; @@ -74,9 +72,10 @@ HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE } else { - r->heapMemory = NULL; + resource->heapMemory = NULL; } - r->allocatedMemory = (BYTE *)(((ULONG_PTR)r->heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1)); + resource->allocatedMemory = (BYTE *)(((ULONG_PTR)resource->heapMemory + + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1)); /* Check that we have enough video ram left */ if (pool == WINED3DPOOL_DEFAULT) @@ -84,7 +83,7 @@ HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE if (size > IWineD3DDevice_GetAvailableTextureMem((IWineD3DDevice *)device)) { ERR("Out of adapter memory\n"); - HeapFree(GetProcessHeap(), 0, r->heapMemory); + HeapFree(GetProcessHeap(), 0, resource->heapMemory); return WINED3DERR_OUTOFVIDEOMEMORY; } WineD3DAdapterChangeGLRam(device, size); @@ -95,7 +94,7 @@ HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE return WINED3D_OK; } -void resource_cleanup(struct IWineD3DResourceImpl *resource) +void resource_cleanup(struct wined3d_resource *resource) { struct private_data *data; struct list *e1, *e2; @@ -103,13 +102,13 @@ void resource_cleanup(struct IWineD3DResourceImpl *resource) TRACE("Cleaning up resource %p.\n", resource); - if (resource->resource.pool == WINED3DPOOL_DEFAULT) + if (resource->pool == WINED3DPOOL_DEFAULT) { - TRACE("Decrementing device memory pool by %u.\n", resource->resource.size); - WineD3DAdapterChangeGLRam(resource->resource.device, -resource->resource.size); + TRACE("Decrementing device memory pool by %u.\n", resource->size); + WineD3DAdapterChangeGLRam(resource->device, -resource->size); } - LIST_FOR_EACH_SAFE(e1, e2, &resource->resource.privateData) + LIST_FOR_EACH_SAFE(e1, e2, &resource->privateData) { data = LIST_ENTRY(e1, struct private_data, entry); hr = resource_free_private_data(resource, &data->tag); @@ -117,27 +116,27 @@ void resource_cleanup(struct IWineD3DResourceImpl *resource) ERR("Failed to free private data when destroying resource %p, hr = %#x.\n", resource, hr); } - HeapFree(GetProcessHeap(), 0, resource->resource.heapMemory); - resource->resource.allocatedMemory = 0; - resource->resource.heapMemory = 0; + HeapFree(GetProcessHeap(), 0, resource->heapMemory); + resource->allocatedMemory = 0; + resource->heapMemory = 0; - if (resource->resource.device) - device_resource_released(resource->resource.device, resource); + if (resource->device) + device_resource_released(resource->device, resource); } -void resource_unload(IWineD3DResourceImpl *resource) +void resource_unload(struct wined3d_resource *resource) { - context_resource_unloaded(resource->resource.device, - resource, resource->resource.resourceType); + context_resource_unloaded(resource->device, + resource, resource->resourceType); } -static struct private_data *resource_find_private_data(const struct IWineD3DResourceImpl *This, REFGUID tag) +static struct private_data *resource_find_private_data(const struct wined3d_resource *resource, REFGUID tag) { struct private_data *data; struct list *entry; TRACE("Searching for private data %s\n", debugstr_guid(tag)); - LIST_FOR_EACH(entry, &This->resource.privateData) + LIST_FOR_EACH(entry, &resource->privateData) { data = LIST_ENTRY(entry, struct private_data, entry); if (IsEqualGUID(&data->tag, tag)) { @@ -149,7 +148,7 @@ static struct private_data *resource_find_private_data(const struct IWineD3DReso return NULL; } -HRESULT resource_set_private_data(struct IWineD3DResourceImpl *resource, REFGUID guid, +HRESULT resource_set_private_data(struct wined3d_resource *resource, REFGUID guid, const void *data, DWORD data_size, DWORD flags) { struct private_data *d; @@ -188,12 +187,12 @@ HRESULT resource_set_private_data(struct IWineD3DResourceImpl *resource, REFGUID d->size = data_size; memcpy(d->ptr.data, data, data_size); } - list_add_tail(&resource->resource.privateData, &d->entry); + list_add_tail(&resource->privateData, &d->entry); return WINED3D_OK; } -HRESULT resource_get_private_data(const struct IWineD3DResourceImpl *resource, REFGUID guid, void *data, DWORD *data_size) +HRESULT resource_get_private_data(const struct wined3d_resource *resource, REFGUID guid, void *data, DWORD *data_size) { const struct private_data *d; @@ -212,7 +211,7 @@ HRESULT resource_get_private_data(const struct IWineD3DResourceImpl *resource, R if (d->flags & WINED3DSPD_IUNKNOWN) { *(IUnknown **)data = d->ptr.object; - if (resource->resource.device->wined3d->dxVersion != 7) + if (resource->device->wined3d->dxVersion != 7) { /* D3D8 and D3D9 addref the private data, DDraw does not. This * can't be handled in ddraw because it doesn't know if the @@ -227,7 +226,7 @@ HRESULT resource_get_private_data(const struct IWineD3DResourceImpl *resource, R return WINED3D_OK; } -HRESULT resource_free_private_data(struct IWineD3DResourceImpl *resource, REFGUID guid) +HRESULT resource_free_private_data(struct wined3d_resource *resource, REFGUID guid) { struct private_data *data; @@ -252,22 +251,27 @@ HRESULT resource_free_private_data(struct IWineD3DResourceImpl *resource, REFGUI return WINED3D_OK; } -DWORD resource_set_priority(struct IWineD3DResourceImpl *resource, DWORD priority) +DWORD resource_set_priority(struct wined3d_resource *resource, DWORD priority) { - DWORD prev = resource->resource.priority; - resource->resource.priority = priority; + DWORD prev = resource->priority; + resource->priority = priority; TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev); return prev; } -DWORD resource_get_priority(const struct IWineD3DResourceImpl *resource) +DWORD resource_get_priority(const struct wined3d_resource *resource) { - TRACE("resource %p, returning %u.\n", resource, resource->resource.priority); - return resource->resource.priority; + TRACE("resource %p, returning %u.\n", resource, resource->priority); + return resource->priority; } -WINED3DRESOURCETYPE resource_get_type(const struct IWineD3DResourceImpl *resource) +WINED3DRESOURCETYPE resource_get_type(const struct wined3d_resource *resource) { - TRACE("resource %p, returning %#x.\n", resource, resource->resource.resourceType); - return resource->resource.resourceType; + TRACE("resource %p, returning %#x.\n", resource, resource->resourceType); + return resource->resourceType; +} + +void * CDECL wined3d_resource_get_parent(const struct wined3d_resource *resource) +{ + return resource->parent; } diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c index 2761ca48e29..1f9a7fd7713 100644 --- a/dlls/wined3d/state.c +++ b/dlls/wined3d/state.c @@ -503,7 +503,7 @@ static void state_alpha(DWORD state, struct wined3d_stateblock *stateblock, stru if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB) { - IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[0]; + IWineD3DSurfaceImpl *surf = surface_from_resource(texture->baseTexture.sub_resources[0]); if (surf->CKeyFlags & WINEDDSD_CKSRCBLT) { @@ -3196,7 +3196,7 @@ void tex_alphaop(DWORD state, struct wined3d_stateblock *stateblock, struct wine if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB) { - IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[0]; + IWineD3DSurfaceImpl *surf = surface_from_resource(texture->baseTexture.sub_resources[0]); if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask) { diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 1021c6382aa..b0f9dc694ec 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -89,7 +89,7 @@ static void surface_cleanup(IWineD3DSurfaceImpl *This) HeapFree(GetProcessHeap(), 0, This->palette9); - resource_cleanup((IWineD3DResourceImpl *)This); + resource_cleanup(&This->resource); } void surface_set_container(IWineD3DSurfaceImpl *surface, enum wined3d_container_type type, IWineD3DBase *container) @@ -433,17 +433,17 @@ static void surface_remove_pbo(IWineD3DSurfaceImpl *surface, const struct wined3 } /* Do not call while under the GL lock. */ -static void surface_unload(IWineD3DResourceImpl *resource) +static void surface_unload(struct wined3d_resource *resource) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)resource; - IWineD3DDeviceImpl *device = resource->resource.device; + IWineD3DSurfaceImpl *surface = surface_from_resource(resource); + IWineD3DDeviceImpl *device = resource->device; const struct wined3d_gl_info *gl_info; renderbuffer_entry_t *entry, *entry2; struct wined3d_context *context; TRACE("surface %p.\n", surface); - if (resource->resource.pool == WINED3DPOOL_DEFAULT) + if (resource->pool == WINED3DPOOL_DEFAULT) { /* Default pool resources are supposed to be destroyed before Reset is called. * Implicit resources stay however. So this means we have an implicit render target @@ -597,8 +597,8 @@ HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type, return WINED3DERR_INVALIDCALL; } - hr = resource_init((IWineD3DResourceImpl *)surface, WINED3DRTYPE_SURFACE, device, - resource_size, usage, format, pool, parent, parent_ops, &surface_resource_ops); + hr = resource_init(&surface->resource, WINED3DRTYPE_SURFACE, device, resource_size, + usage, format, pool, parent, parent_ops, &surface_resource_ops); if (FAILED(hr)) { WARN("Failed to initialize resource, returning %#x.\n", hr); @@ -1751,7 +1751,7 @@ void surface_prepare_texture(IWineD3DSurfaceImpl *surface, const struct wined3d_ for (i = 0; i < sub_count; ++i) { - IWineD3DSurfaceImpl *s = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *s = surface_from_resource(texture->baseTexture.sub_resources[i]); surface_prepare_texture_internal(s, gl_info, srgb); } @@ -2761,8 +2761,8 @@ void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back) { back->texture_name_srgb = front->texture_name_srgb; front->texture_name_srgb = tmp; - resource_unload((IWineD3DResourceImpl *)back); - resource_unload((IWineD3DResourceImpl *)front); + resource_unload(&back->resource); + resource_unload(&front->resource); } { @@ -4685,6 +4685,7 @@ const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl = IWineD3DSurfaceImpl_PreLoad, IWineD3DBaseSurfaceImpl_GetType, /* IWineD3DSurface */ + IWineD3DBaseSurfaceImpl_GetResource, IWineD3DBaseSurfaceImpl_GetDesc, IWineD3DSurfaceImpl_Map, IWineD3DSurfaceImpl_Unmap, diff --git a/dlls/wined3d/surface_base.c b/dlls/wined3d/surface_base.c index 65d632751e8..37a1309b059 100644 --- a/dlls/wined3d/surface_base.c +++ b/dlls/wined3d/surface_base.c @@ -114,33 +114,33 @@ ULONG WINAPI IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface *iface) { HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface *iface, REFGUID riid, const void *data, DWORD data_size, DWORD flags) { - return resource_set_private_data((IWineD3DResourceImpl *)iface, riid, data, data_size, flags); + return resource_set_private_data(&((IWineD3DSurfaceImpl *)iface)->resource, riid, data, data_size, flags); } HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPrivateData(IWineD3DSurface *iface, REFGUID guid, void *data, DWORD *data_size) { - return resource_get_private_data((IWineD3DResourceImpl *)iface, guid, data, data_size); + return resource_get_private_data(&((IWineD3DSurfaceImpl *)iface)->resource, guid, data, data_size); } HRESULT WINAPI IWineD3DBaseSurfaceImpl_FreePrivateData(IWineD3DSurface *iface, REFGUID refguid) { - return resource_free_private_data((IWineD3DResourceImpl *)iface, refguid); + return resource_free_private_data(&((IWineD3DSurfaceImpl *)iface)->resource, refguid); } DWORD WINAPI IWineD3DBaseSurfaceImpl_SetPriority(IWineD3DSurface *iface, DWORD priority) { - return resource_set_priority((IWineD3DResourceImpl *)iface, priority); + return resource_set_priority(&((IWineD3DSurfaceImpl *)iface)->resource, priority); } DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface) { - return resource_get_priority((IWineD3DResourceImpl *)iface); + return resource_get_priority(&((IWineD3DSurfaceImpl *)iface)->resource); } WINED3DRESOURCETYPE WINAPI IWineD3DBaseSurfaceImpl_GetType(IWineD3DSurface *iface) { - return resource_get_type((IWineD3DResourceImpl *)iface); + return resource_get_type(&((IWineD3DSurfaceImpl *)iface)->resource); } void * WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface) @@ -150,6 +150,13 @@ void * WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface) return ((IWineD3DSurfaceImpl *)iface)->resource.parent; } +struct wined3d_resource * WINAPI IWineD3DBaseSurfaceImpl_GetResource(IWineD3DSurface *iface) +{ + TRACE("iface %p.\n", iface); + + return &((IWineD3DSurfaceImpl *)iface)->resource; +} + void WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *desc) { IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)iface; diff --git a/dlls/wined3d/surface_gdi.c b/dlls/wined3d/surface_gdi.c index 858dc9b492e..d91bb008829 100644 --- a/dlls/wined3d/surface_gdi.c +++ b/dlls/wined3d/surface_gdi.c @@ -54,7 +54,7 @@ void surface_gdi_cleanup(IWineD3DSurfaceImpl *This) HeapFree(GetProcessHeap(), 0, This->palette9); - resource_cleanup((IWineD3DResourceImpl *)This); + resource_cleanup(&This->resource); } static void gdi_surface_realize_palette(IWineD3DSurfaceImpl *surface) @@ -451,6 +451,7 @@ const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl = IWineGDISurfaceImpl_PreLoad, IWineD3DBaseSurfaceImpl_GetType, /* IWineD3DSurface */ + IWineD3DBaseSurfaceImpl_GetResource, IWineD3DBaseSurfaceImpl_GetDesc, IWineGDISurfaceImpl_Map, IWineGDISurfaceImpl_Unmap, diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 1c629ebbe6d..df52996ff2e 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -48,7 +48,7 @@ static HRESULT texture_bind(IWineD3DBaseTextureImpl *texture, BOOL srgb) for (i = 0; i < texture->baseTexture.level_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(texture->baseTexture.sub_resources[i]); surface_set_texture_name(surface, gl_tex->name, texture->baseTexture.is_srgb); } @@ -128,7 +128,7 @@ static void texture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB s { for (i = 0; i < texture->baseTexture.level_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(texture->baseTexture.sub_resources[i]); if (palette9_changed(surface)) { TRACE("Reloading surface because the d3d8/9 palette was changed.\n"); @@ -146,7 +146,7 @@ static void texture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB s { for (i = 0; i < texture->baseTexture.level_count; ++i) { - surface_load((IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i], srgb_mode); + surface_load(surface_from_resource(texture->baseTexture.sub_resources[i]), srgb_mode); } } else @@ -161,18 +161,19 @@ static void texture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB s } /* Do not call while under the GL lock. */ -static void texture_unload(IWineD3DResourceImpl *resource) +static void texture_unload(struct wined3d_resource *resource) { - IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)resource; + IWineD3DBaseTextureImpl *texture = basetexture_from_resource(resource); unsigned int i; TRACE("texture %p.\n", texture); for (i = 0; i < texture->baseTexture.level_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[i]; + struct wined3d_resource *sub_resource = texture->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(sub_resource); - surface->resource.resource_ops->resource_unload((IWineD3DResourceImpl *)surface); + sub_resource->resource_ops->resource_unload(sub_resource); surface_set_texture_name(surface, 0, FALSE); /* Delete rgb name */ surface_set_texture_name(surface, 0, TRUE); /* delete srgb name */ } @@ -199,7 +200,7 @@ static void texture_cleanup(IWineD3DTextureImpl *This) for (i = 0; i < This->baseTexture.level_count; ++i) { - IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)This->baseTexture.sub_resources[i]; + IWineD3DSurfaceImpl *surface = surface_from_resource(This->baseTexture.sub_resources[i]); if (surface) { /* Clean out the texture name we gave to the surface so that the @@ -265,28 +266,28 @@ static ULONG WINAPI IWineD3DTextureImpl_Release(IWineD3DTexture *iface) { static HRESULT WINAPI IWineD3DTextureImpl_SetPrivateData(IWineD3DTexture *iface, REFGUID riid, const void *data, DWORD data_size, DWORD flags) { - return resource_set_private_data((IWineD3DResourceImpl *)iface, riid, data, data_size, flags); + return resource_set_private_data(&((IWineD3DTextureImpl *)iface)->resource, riid, data, data_size, flags); } static HRESULT WINAPI IWineD3DTextureImpl_GetPrivateData(IWineD3DTexture *iface, REFGUID guid, void *data, DWORD *data_size) { - return resource_get_private_data((IWineD3DResourceImpl *)iface, guid, data, data_size); + return resource_get_private_data(&((IWineD3DTextureImpl *)iface)->resource, guid, data, data_size); } static HRESULT WINAPI IWineD3DTextureImpl_FreePrivateData(IWineD3DTexture *iface, REFGUID refguid) { - return resource_free_private_data((IWineD3DResourceImpl *)iface, refguid); + return resource_free_private_data(&((IWineD3DTextureImpl *)iface)->resource, refguid); } static DWORD WINAPI IWineD3DTextureImpl_SetPriority(IWineD3DTexture *iface, DWORD priority) { - return resource_set_priority((IWineD3DResourceImpl *)iface, priority); + return resource_set_priority(&((IWineD3DTextureImpl *)iface)->resource, priority); } static DWORD WINAPI IWineD3DTextureImpl_GetPriority(IWineD3DTexture *iface) { - return resource_get_priority((IWineD3DResourceImpl *)iface); + return resource_get_priority(&((IWineD3DTextureImpl *)iface)->resource); } /* Do not call while under the GL lock. */ @@ -297,7 +298,7 @@ static void WINAPI IWineD3DTextureImpl_PreLoad(IWineD3DTexture *iface) static WINED3DRESOURCETYPE WINAPI IWineD3DTextureImpl_GetType(IWineD3DTexture *iface) { - return resource_get_type((IWineD3DResourceImpl *)iface); + return resource_get_type(&((IWineD3DTextureImpl *)iface)->resource); } static void * WINAPI IWineD3DTextureImpl_GetParent(IWineD3DTexture *iface) @@ -350,17 +351,17 @@ static HRESULT WINAPI IWineD3DTextureImpl_GetLevelDesc(IWineD3DTexture *iface, UINT sub_resource_idx, WINED3DSURFACE_DESC *desc) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, desc %p.\n", iface, sub_resource_idx, desc); - if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - IWineD3DSurface_GetDesc(surface, desc); + IWineD3DSurface_GetDesc((IWineD3DSurface *)surface_from_resource(sub_resource), desc); return WINED3D_OK; } @@ -369,18 +370,18 @@ static HRESULT WINAPI IWineD3DTextureImpl_GetSurfaceLevel(IWineD3DTexture *iface UINT sub_resource_idx, IWineD3DSurface **surface) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *s; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, surface %p.\n", iface, sub_resource_idx, surface); - if (!(s = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - IWineD3DSurface_AddRef(s); - *surface = s; + *surface = (IWineD3DSurface *)surface_from_resource(sub_resource); + IWineD3DSurface_AddRef(*surface); TRACE("Returning surface %p.\n", *surface); @@ -391,44 +392,44 @@ static HRESULT WINAPI IWineD3DTextureImpl_Map(IWineD3DTexture *iface, UINT sub_resource_idx, WINED3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, locked_rect %p, rect %s, flags %#x.\n", iface, sub_resource_idx, locked_rect, wine_dbgstr_rect(rect), flags); - if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_Map(surface, locked_rect, rect, flags); + return IWineD3DSurface_Map((IWineD3DSurface *)surface_from_resource(sub_resource), locked_rect, rect, flags); } static HRESULT WINAPI IWineD3DTextureImpl_Unmap(IWineD3DTexture *iface, UINT sub_resource_idx) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurface *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx); - if (!(surface = (IWineD3DSurface *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - return IWineD3DSurface_Unmap(surface); + return IWineD3DSurface_Unmap((IWineD3DSurface *)surface_from_resource(sub_resource)); } static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, const RECT *dirty_rect) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DSurfaceImpl *surface; + struct wined3d_resource *sub_resource; TRACE("iface %p, dirty_rect %s.\n", iface, wine_dbgstr_rect(dirty_rect)); - if (!(surface = (IWineD3DSurfaceImpl *)basetexture_get_sub_resource(texture, 0))) + if (!(sub_resource = basetexture_get_sub_resource(texture, 0))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; @@ -436,7 +437,7 @@ static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, c texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_srgb.dirty = TRUE; - surface_add_dirty_rect(surface, dirty_rect); + surface_add_dirty_rect(surface_from_resource(sub_resource), dirty_rect); return WINED3D_OK; } @@ -625,7 +626,7 @@ HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT surface_set_container((IWineD3DSurfaceImpl *)surface, WINED3D_CONTAINER_TEXTURE, (IWineD3DBase *)texture); surface_set_texture_target((IWineD3DSurfaceImpl *)surface, texture->baseTexture.target); - texture->baseTexture.sub_resources[i] = (IWineD3DResourceImpl *)surface; + texture->baseTexture.sub_resources[i] = &((IWineD3DSurfaceImpl *)surface)->resource; TRACE("Created surface level %u @ %p.\n", i, surface); /* Calculate the next mipmap level. */ tmp_w = max(1, tmp_w >> 1); diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 4c91644fbde..07a2a74ea73 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -2858,7 +2858,7 @@ void gen_ffp_frag_op(struct wined3d_stateblock *stateblock, struct ffp_frag_sett if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB) { - IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *)texture->baseTexture.sub_resources[0]; + IWineD3DSurfaceImpl *surf = surface_from_resource(texture->baseTexture.sub_resources[0]); if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask) { diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index 2b98de32afd..ab1c831a71e 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -65,7 +65,6 @@ static ULONG STDMETHODCALLTYPE rendertarget_view_Release(IWineD3DRendertargetVie if (!refcount) { - IWineD3DResource_Release((IWineD3DResource *)This->resource); HeapFree(GetProcessHeap(), 0, This); } @@ -84,12 +83,11 @@ static void * STDMETHODCALLTYPE rendertarget_view_GetParent(IWineD3DRendertarget /* IWineD3DRendertargetView methods */ static HRESULT STDMETHODCALLTYPE rendertarget_view_GetResource(IWineD3DRendertargetView *iface, - IWineD3DResource **resource) + struct wined3d_resource **resource) { struct wined3d_rendertarget_view *This = (struct wined3d_rendertarget_view *)iface; - IWineD3DResource_AddRef((IWineD3DResource *)This->resource); - *resource = (IWineD3DResource *)This->resource; + *resource = This->resource; return WINED3D_OK; } @@ -107,11 +105,10 @@ static const struct IWineD3DRendertargetViewVtbl wined3d_rendertarget_view_vtbl }; void wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view, - struct IWineD3DResourceImpl *resource, void *parent) + struct wined3d_resource *resource, void *parent) { view->vtbl = &wined3d_rendertarget_view_vtbl; view->refcount = 1; - IWineD3DResource_AddRef((IWineD3DResource *)resource); view->resource = resource; view->parent = parent; } diff --git a/dlls/wined3d/volume.c b/dlls/wined3d/volume.c index e5d3cd73542..7c98cc989b5 100644 --- a/dlls/wined3d/volume.c +++ b/dlls/wined3d/volume.c @@ -119,7 +119,7 @@ void volume_load(IWineD3DVolumeImpl *volume, UINT level, BOOL srgb_mode) } /* Do not call while under the GL lock. */ -static void volume_unload(IWineD3DResourceImpl *resource) +static void volume_unload(struct wined3d_resource *resource) { TRACE("texture %p.\n", resource); @@ -167,7 +167,7 @@ static ULONG WINAPI IWineD3DVolumeImpl_Release(IWineD3DVolume *iface) { if (!ref) { - resource_cleanup((IWineD3DResourceImpl *)iface); + resource_cleanup(&This->resource); This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent); HeapFree(GetProcessHeap(), 0, This); } @@ -187,28 +187,28 @@ static void * WINAPI IWineD3DVolumeImpl_GetParent(IWineD3DVolume *iface) static HRESULT WINAPI IWineD3DVolumeImpl_SetPrivateData(IWineD3DVolume *iface, REFGUID riid, const void *data, DWORD data_size, DWORD flags) { - return resource_set_private_data((IWineD3DResourceImpl *)iface, riid, data, data_size, flags); + return resource_set_private_data(&((IWineD3DVolumeImpl *)iface)->resource, riid, data, data_size, flags); } static HRESULT WINAPI IWineD3DVolumeImpl_GetPrivateData(IWineD3DVolume *iface, REFGUID guid, void *data, DWORD *data_size) { - return resource_get_private_data((IWineD3DResourceImpl *)iface, guid, data, data_size); + return resource_get_private_data(&((IWineD3DVolumeImpl *)iface)->resource, guid, data, data_size); } static HRESULT WINAPI IWineD3DVolumeImpl_FreePrivateData(IWineD3DVolume *iface, REFGUID refguid) { - return resource_free_private_data((IWineD3DResourceImpl *)iface, refguid); + return resource_free_private_data(&((IWineD3DVolumeImpl *)iface)->resource, refguid); } static DWORD WINAPI IWineD3DVolumeImpl_SetPriority(IWineD3DVolume *iface, DWORD priority) { - return resource_set_priority((IWineD3DResourceImpl *)iface, priority); + return resource_set_priority(&((IWineD3DVolumeImpl *)iface)->resource, priority); } static DWORD WINAPI IWineD3DVolumeImpl_GetPriority(IWineD3DVolume *iface) { - return resource_get_priority((IWineD3DResourceImpl *)iface); + return resource_get_priority(&((IWineD3DVolumeImpl *)iface)->resource); } /* Do not call while under the GL lock. */ @@ -218,7 +218,7 @@ static void WINAPI IWineD3DVolumeImpl_PreLoad(IWineD3DVolume *iface) { static WINED3DRESOURCETYPE WINAPI IWineD3DVolumeImpl_GetType(IWineD3DVolume *iface) { - return resource_get_type((IWineD3DResourceImpl *)iface); + return resource_get_type(&((IWineD3DVolumeImpl *)iface)->resource); } static void WINAPI IWineD3DVolumeImpl_GetDesc(IWineD3DVolume *iface, WINED3DVOLUME_DESC *desc) @@ -344,7 +344,7 @@ HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT volume->lpVtbl = &IWineD3DVolume_Vtbl; - hr = resource_init((IWineD3DResourceImpl *)volume, WINED3DRTYPE_VOLUME, device, + hr = resource_init(&volume->resource, WINED3DRTYPE_VOLUME, device, width * height * depth * format->byte_count, usage, format, pool, parent, parent_ops, &volume_resource_ops); if (FAILED(hr)) diff --git a/dlls/wined3d/volumetexture.c b/dlls/wined3d/volumetexture.c index 757cd96377b..6ebd1c2f859 100644 --- a/dlls/wined3d/volumetexture.c +++ b/dlls/wined3d/volumetexture.c @@ -61,14 +61,14 @@ static void volumetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3D { for (i = 0; i < texture->baseTexture.level_count; ++i) { - volume_load((IWineD3DVolumeImpl *)texture->baseTexture.sub_resources[i], i, srgb_mode); + volume_load(volume_from_resource(texture->baseTexture.sub_resources[i]), i, srgb_mode); } } else if (srgb_was_toggled) { for (i = 0; i < texture->baseTexture.level_count; ++i) { - IWineD3DVolumeImpl *volume = (IWineD3DVolumeImpl *)texture->baseTexture.sub_resources[i]; + IWineD3DVolumeImpl *volume = volume_from_resource(texture->baseTexture.sub_resources[i]); volume_add_dirty_box(volume, NULL); volume_load(volume, i, srgb_mode); } @@ -85,17 +85,17 @@ static void volumetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3D } /* Do not call while under the GL lock. */ -static void volumetexture_unload(IWineD3DResourceImpl *resource) +static void volumetexture_unload(struct wined3d_resource *resource) { - IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)resource; + IWineD3DBaseTextureImpl *texture = basetexture_from_resource(resource); unsigned int i; TRACE("texture %p.\n", texture); for (i = 0; i < texture->baseTexture.level_count; ++i) { - IWineD3DResourceImpl *resource = texture->baseTexture.sub_resources[i]; - resource->resource.resource_ops->resource_unload(resource); + struct wined3d_resource *sub_resource = texture->baseTexture.sub_resources[i]; + sub_resource->resource_ops->resource_unload(sub_resource); } basetexture_unload(texture); @@ -120,7 +120,7 @@ static void volumetexture_cleanup(IWineD3DVolumeTextureImpl *This) for (i = 0; i < This->baseTexture.level_count; ++i) { - IWineD3DVolumeImpl *volume = (IWineD3DVolumeImpl *)This->baseTexture.sub_resources[i]; + IWineD3DVolumeImpl *volume = volume_from_resource(This->baseTexture.sub_resources[i]); if (volume) { @@ -180,28 +180,28 @@ static ULONG WINAPI IWineD3DVolumeTextureImpl_Release(IWineD3DVolumeTexture *ifa static HRESULT WINAPI IWineD3DVolumeTextureImpl_SetPrivateData(IWineD3DVolumeTexture *iface, REFGUID riid, const void *data, DWORD data_size, DWORD flags) { - return resource_set_private_data((IWineD3DResourceImpl *)iface, riid, data, data_size, flags); + return resource_set_private_data(&((IWineD3DVolumeTextureImpl *)iface)->resource, riid, data, data_size, flags); } static HRESULT WINAPI IWineD3DVolumeTextureImpl_GetPrivateData(IWineD3DVolumeTexture *iface, REFGUID guid, void *data, DWORD *data_size) { - return resource_get_private_data((IWineD3DResourceImpl *)iface, guid, data, data_size); + return resource_get_private_data(&((IWineD3DVolumeTextureImpl *)iface)->resource, guid, data, data_size); } static HRESULT WINAPI IWineD3DVolumeTextureImpl_FreePrivateData(IWineD3DVolumeTexture *iface, REFGUID refguid) { - return resource_free_private_data((IWineD3DResourceImpl *)iface, refguid); + return resource_free_private_data(&((IWineD3DVolumeTextureImpl *)iface)->resource, refguid); } static DWORD WINAPI IWineD3DVolumeTextureImpl_SetPriority(IWineD3DVolumeTexture *iface, DWORD priority) { - return resource_set_priority((IWineD3DResourceImpl *)iface, priority); + return resource_set_priority(&((IWineD3DVolumeTextureImpl *)iface)->resource, priority); } static DWORD WINAPI IWineD3DVolumeTextureImpl_GetPriority(IWineD3DVolumeTexture *iface) { - return resource_get_priority((IWineD3DResourceImpl *)iface); + return resource_get_priority(&((IWineD3DVolumeTextureImpl *)iface)->resource); } static void WINAPI IWineD3DVolumeTextureImpl_PreLoad(IWineD3DVolumeTexture *iface) @@ -211,7 +211,7 @@ static void WINAPI IWineD3DVolumeTextureImpl_PreLoad(IWineD3DVolumeTexture *ifac static WINED3DRESOURCETYPE WINAPI IWineD3DVolumeTextureImpl_GetType(IWineD3DVolumeTexture *iface) { - return resource_get_type((IWineD3DResourceImpl *)iface); + return resource_get_type(&((IWineD3DVolumeTextureImpl *)iface)->resource); } static void * WINAPI IWineD3DVolumeTextureImpl_GetParent(IWineD3DVolumeTexture *iface) @@ -264,17 +264,17 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_GetLevelDesc(IWineD3DVolumeTextu UINT sub_resource_idx, WINED3DVOLUME_DESC *desc) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DVolume *volume; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, desc %p.\n", iface, sub_resource_idx, desc); - if (!(volume = (IWineD3DVolume *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - IWineD3DVolume_GetDesc(volume, desc); + IWineD3DVolume_GetDesc((IWineD3DVolume *)volume_from_resource(sub_resource), desc); return WINED3D_OK; } @@ -283,18 +283,18 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_GetVolumeLevel(IWineD3DVolumeTex UINT sub_resource_idx, IWineD3DVolume **volume) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DVolume *v; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, volume %p.\n", iface, sub_resource_idx, volume); - if (!(v= (IWineD3DVolume *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - IWineD3DVolume_AddRef(v); - *volume = v; + *volume = (IWineD3DVolume *)volume_from_resource(sub_resource); + IWineD3DVolume_AddRef(*volume); TRACE("Returning volume %p.\n", *volume); @@ -305,44 +305,45 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_Map(IWineD3DVolumeTexture *iface UINT sub_resource_idx, WINED3DLOCKED_BOX *locked_box, const WINED3DBOX *box, DWORD flags) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DVolume *volume; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u, locked_box %p, box %p, flags %#x.\n", iface, sub_resource_idx, locked_box, box, flags); - if (!(volume = (IWineD3DVolume *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - return IWineD3DVolume_Map(volume, locked_box, box, flags); + return IWineD3DVolume_Map((IWineD3DVolume *)volume_from_resource(sub_resource), + locked_box, box, flags); } static HRESULT WINAPI IWineD3DVolumeTextureImpl_Unmap(IWineD3DVolumeTexture *iface, UINT sub_resource_idx) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DVolume *volume; + struct wined3d_resource *sub_resource; TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx); - if (!(volume = (IWineD3DVolume *)basetexture_get_sub_resource(texture, sub_resource_idx))) + if (!(sub_resource = basetexture_get_sub_resource(texture, sub_resource_idx))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; } - return IWineD3DVolume_Unmap(volume); + return IWineD3DVolume_Unmap((IWineD3DVolume *)volume_from_resource(sub_resource)); } static HRESULT WINAPI IWineD3DVolumeTextureImpl_AddDirtyBox(IWineD3DVolumeTexture *iface, const WINED3DBOX *dirty_box) { IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; - IWineD3DVolumeImpl *volume; + struct wined3d_resource *sub_resource; TRACE("iface %p, dirty_box %p.\n", iface, dirty_box); - if (!(volume = (IWineD3DVolumeImpl *)basetexture_get_sub_resource(texture, 0))) + if (!(sub_resource = basetexture_get_sub_resource(texture, 0))) { WARN("Failed to get sub-resource.\n"); return WINED3DERR_INVALIDCALL; @@ -350,7 +351,7 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_AddDirtyBox(IWineD3DVolumeTextur texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_srgb.dirty = TRUE; - volume_add_dirty_box(volume, dirty_box); + volume_add_dirty_box(volume_from_resource(sub_resource), dirty_box); return WINED3D_OK; } @@ -473,7 +474,7 @@ HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT /* Set its container to this texture. */ volume_set_container((IWineD3DVolumeImpl *)volume, texture); - texture->baseTexture.sub_resources[i] = (IWineD3DResourceImpl *)volume; + texture->baseTexture.sub_resources[i] = &((IWineD3DVolumeImpl *)volume)->resource; /* Calculate the next mipmap level. */ tmp_w = max(1, tmp_w >> 1); diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec index b6562eefe60..971bf25571e 100644 --- a/dlls/wined3d/wined3d.spec +++ b/dlls/wined3d/wined3d.spec @@ -44,6 +44,8 @@ @ cdecl wined3d_query_incref(ptr) @ cdecl wined3d_query_issue(ptr long) +@ cdecl wined3d_resource_get_parent(ptr) + @ cdecl wined3d_stateblock_apply(ptr) @ cdecl wined3d_stateblock_capture(ptr) @ cdecl wined3d_stateblock_decref(ptr) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 0cc9aafb378..3b09feea119 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -57,7 +57,6 @@ typedef struct IWineD3DDeviceImpl IWineD3DDeviceImpl; typedef struct IWineD3DSwapChainImpl IWineD3DSwapChainImpl; struct IWineD3DBaseShaderImpl; struct IWineD3DBaseTextureImpl; -struct IWineD3DResourceImpl; /* Texture format fixups */ @@ -1227,9 +1226,9 @@ struct wined3d_context *context_get_current(void) DECLSPEC_HIDDEN; DWORD context_get_tls_idx(void) DECLSPEC_HIDDEN; void context_release(struct wined3d_context *context) DECLSPEC_HIDDEN; void context_resource_released(struct IWineD3DDeviceImpl *device, - struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) DECLSPEC_HIDDEN; + struct wined3d_resource *resource, WINED3DRESOURCETYPE type) DECLSPEC_HIDDEN; void context_resource_unloaded(struct IWineD3DDeviceImpl *device, - struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) DECLSPEC_HIDDEN; + struct wined3d_resource *resource, WINED3DRESOURCETYPE type) DECLSPEC_HIDDEN; BOOL context_set_current(struct wined3d_context *ctx) DECLSPEC_HIDDEN; void context_set_draw_buffer(struct wined3d_context *context, GLenum buffer) DECLSPEC_HIDDEN; void context_set_tls_idx(DWORD idx) DECLSPEC_HIDDEN; @@ -1776,8 +1775,8 @@ HRESULT device_init(IWineD3DDeviceImpl *device, struct wined3d *wined3d, void device_preload_textures(IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN; LRESULT device_process_message(IWineD3DDeviceImpl *device, HWND window, BOOL unicode, UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc) DECLSPEC_HIDDEN; -void device_resource_add(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; -void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; +void device_resource_add(struct IWineD3DDeviceImpl *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN; +void device_resource_released(struct IWineD3DDeviceImpl *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN; void device_stream_info_from_declaration(IWineD3DDeviceImpl *This, BOOL use_vshader, struct wined3d_stream_info *stream_info, BOOL *fixup) DECLSPEC_HIDDEN; void device_switch_onscreen_ds(IWineD3DDeviceImpl *device, struct wined3d_context *context, @@ -1795,15 +1794,12 @@ static inline BOOL isStateDirty(struct wined3d_context *context, DWORD state) struct wined3d_resource_ops { - void (*resource_unload)(struct IWineD3DResourceImpl *resource); + void (*resource_unload)(struct wined3d_resource *resource); }; -typedef struct IWineD3DResourceClass +struct wined3d_resource { - /* IUnknown fields */ - LONG ref; /* Note: Ref counting not required */ - - /* WineD3DResource Information */ + LONG ref; WINED3DRESOURCETYPE resourceType; IWineD3DDeviceImpl *device; WINED3DPOOL pool; @@ -1819,29 +1815,22 @@ typedef struct IWineD3DResourceClass void *parent; const struct wined3d_parent_ops *parent_ops; const struct wined3d_resource_ops *resource_ops; -} IWineD3DResourceClass; +}; -typedef struct IWineD3DResourceImpl -{ - /* IUnknown & WineD3DResource Information */ - const IWineD3DResourceVtbl *lpVtbl; - IWineD3DResourceClass resource; -} IWineD3DResourceImpl; - -void resource_cleanup(struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; -HRESULT resource_free_private_data(struct IWineD3DResourceImpl *resource, REFGUID guid) DECLSPEC_HIDDEN; -DWORD resource_get_priority(const struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; -HRESULT resource_get_private_data(const struct IWineD3DResourceImpl *resource, REFGUID guid, +void resource_cleanup(struct wined3d_resource *resource) DECLSPEC_HIDDEN; +HRESULT resource_free_private_data(struct wined3d_resource *resource, REFGUID guid) DECLSPEC_HIDDEN; +DWORD resource_get_priority(const struct wined3d_resource *resource) DECLSPEC_HIDDEN; +HRESULT resource_get_private_data(const struct wined3d_resource *resource, REFGUID guid, void *data, DWORD *data_size) DECLSPEC_HIDDEN; -HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE resource_type, +HRESULT resource_init(struct wined3d_resource *resource, WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format *format, WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_resource_ops *resource_ops) DECLSPEC_HIDDEN; -WINED3DRESOURCETYPE resource_get_type(const struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; -DWORD resource_set_priority(struct IWineD3DResourceImpl *resource, DWORD priority) DECLSPEC_HIDDEN; -HRESULT resource_set_private_data(struct IWineD3DResourceImpl *resource, REFGUID guid, +WINED3DRESOURCETYPE resource_get_type(const struct wined3d_resource *resource) DECLSPEC_HIDDEN; +DWORD resource_set_priority(struct wined3d_resource *resource, DWORD priority) DECLSPEC_HIDDEN; +HRESULT resource_set_private_data(struct wined3d_resource *resource, REFGUID guid, const void *data, DWORD data_size, DWORD flags) DECLSPEC_HIDDEN; -void resource_unload(IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; +void resource_unload(struct wined3d_resource *resource) DECLSPEC_HIDDEN; /* Tests show that the start address of resources is 32 byte aligned */ #define RESOURCE_ALIGNMENT 16 @@ -1886,14 +1875,11 @@ struct wined3d_texture_ops void (*texture_preload)(struct IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB srgb); }; -/***************************************************************************** - * IWineD3DBaseTexture implementation structure (extends IWineD3DResourceImpl) - */ typedef struct IWineD3DBaseTextureClass { const struct wined3d_texture_ops *texture_ops; struct gl_texture texture_rgb, texture_srgb; - IWineD3DResourceImpl **sub_resources; + struct wined3d_resource **sub_resources; UINT layer_count; UINT level_count; float pow2Matrix[16]; @@ -1912,11 +1898,16 @@ typedef struct IWineD3DBaseTextureImpl { /* IUnknown & WineD3DResource Information */ const IWineD3DBaseTextureVtbl *lpVtbl; - IWineD3DResourceClass resource; + struct wined3d_resource resource; IWineD3DBaseTextureClass baseTexture; } IWineD3DBaseTextureImpl; +static inline IWineD3DBaseTextureImpl *basetexture_from_resource(struct wined3d_resource *resource) +{ + return CONTAINING_RECORD(resource, IWineD3DBaseTextureImpl, resource); +} + void basetexture_apply_state_changes(IWineD3DBaseTextureImpl *texture, const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1], const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN; @@ -1926,7 +1917,7 @@ void basetexture_generate_mipmaps(IWineD3DBaseTextureImpl *texture) DECLSPEC_HID WINED3DTEXTUREFILTERTYPE basetexture_get_autogen_filter_type(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN; DWORD basetexture_get_level_count(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN; DWORD basetexture_get_lod(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN; -IWineD3DResourceImpl *basetexture_get_sub_resource(IWineD3DBaseTextureImpl *texture, +struct wined3d_resource *basetexture_get_sub_resource(IWineD3DBaseTextureImpl *texture, UINT sub_resource_idx) DECLSPEC_HIDDEN; HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_texture_ops *texture_ops, UINT layer_count, UINT level_count, WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device, @@ -1945,7 +1936,7 @@ typedef struct IWineD3DTextureImpl { /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */ const IWineD3DTextureVtbl *lpVtbl; - IWineD3DResourceClass resource; + struct wined3d_resource resource; IWineD3DBaseTextureClass baseTexture; /* IWineD3DTexture */ @@ -1964,7 +1955,7 @@ typedef struct IWineD3DCubeTextureImpl { /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */ const IWineD3DCubeTextureVtbl *lpVtbl; - IWineD3DResourceClass resource; + struct wined3d_resource resource; IWineD3DBaseTextureClass baseTexture; } IWineD3DCubeTextureImpl; @@ -1986,7 +1977,7 @@ typedef struct IWineD3DVolumeImpl { /* IUnknown & WineD3DResource fields */ const IWineD3DVolumeVtbl *lpVtbl; - IWineD3DResourceClass resource; + struct wined3d_resource resource; /* WineD3DVolume Information */ WINED3DVOLUMET_DESC currentDesc; @@ -1998,6 +1989,11 @@ typedef struct IWineD3DVolumeImpl BOOL dirty; } IWineD3DVolumeImpl; +static inline IWineD3DVolumeImpl *volume_from_resource(struct wined3d_resource *resource) +{ + return CONTAINING_RECORD(resource, IWineD3DVolumeImpl, resource); +} + void volume_add_dirty_box(struct IWineD3DVolumeImpl *volume, const WINED3DBOX *dirty_box) DECLSPEC_HIDDEN; HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT width, UINT height, UINT depth, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool, @@ -2012,7 +2008,7 @@ typedef struct IWineD3DVolumeTextureImpl { /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */ const IWineD3DVolumeTextureVtbl *lpVtbl; - IWineD3DResourceClass resource; + struct wined3d_resource resource; IWineD3DBaseTextureClass baseTexture; } IWineD3DVolumeTextureImpl; @@ -2094,7 +2090,7 @@ struct IWineD3DSurfaceImpl { /* IUnknown & IWineD3DResource Information */ const IWineD3DSurfaceVtbl *lpVtbl; - IWineD3DResourceClass resource; + struct wined3d_resource resource; /* IWineD3DSurface fields */ const struct wined3d_surface_ops *surface_ops; @@ -2154,6 +2150,11 @@ struct IWineD3DSurfaceImpl extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl DECLSPEC_HIDDEN; extern const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl DECLSPEC_HIDDEN; +static inline IWineD3DSurfaceImpl *surface_from_resource(struct wined3d_resource *resource) +{ + return CONTAINING_RECORD(resource, IWineD3DSurfaceImpl, resource); +} + void surface_add_dirty_rect(IWineD3DSurfaceImpl *surface, const RECT *dirty_rect) DECLSPEC_HIDDEN; void surface_bind(IWineD3DSurfaceImpl *surface, BOOL srgb) DECLSPEC_HIDDEN; HRESULT surface_color_fill(IWineD3DSurfaceImpl *s, const RECT *rect, const WINED3DCOLORVALUE *color) DECLSPEC_HIDDEN; @@ -2195,6 +2196,7 @@ HRESULT WINAPI IWineD3DBaseSurfaceImpl_FreePrivateData(IWineD3DSurface *iface, R DWORD WINAPI IWineD3DBaseSurfaceImpl_SetPriority(IWineD3DSurface *iface, DWORD PriorityNew) DECLSPEC_HIDDEN; DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface) DECLSPEC_HIDDEN; WINED3DRESOURCETYPE WINAPI IWineD3DBaseSurfaceImpl_GetType(IWineD3DSurface *iface) DECLSPEC_HIDDEN; +struct wined3d_resource * WINAPI IWineD3DBaseSurfaceImpl_GetResource(IWineD3DSurface *iface) DECLSPEC_HIDDEN; void WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *desc) DECLSPEC_HIDDEN; HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD flags) DECLSPEC_HIDDEN; HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetFlipStatus(IWineD3DSurface *iface, DWORD flags) DECLSPEC_HIDDEN; @@ -2524,7 +2526,7 @@ struct wined3d_map_range struct wined3d_buffer { const struct IWineD3DBufferVtbl *vtbl; - IWineD3DResourceClass resource; + struct wined3d_resource resource; struct wined3d_buffer_desc desc; @@ -2550,6 +2552,11 @@ struct wined3d_buffer UINT *conversion_shift; /* NULL if no shifted conversion */ }; +static inline struct wined3d_buffer *buffer_from_resource(struct wined3d_resource *resource) +{ + return CONTAINING_RECORD(resource, struct wined3d_buffer, resource); +} + const BYTE *buffer_get_memory(struct wined3d_buffer *buffer, const struct wined3d_gl_info *gl_info, GLuint *buffer_object) DECLSPEC_HIDDEN; BYTE *buffer_get_sysmem(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN; @@ -2563,12 +2570,12 @@ struct wined3d_rendertarget_view const struct IWineD3DRendertargetViewVtbl *vtbl; LONG refcount; - struct IWineD3DResourceImpl *resource; + struct wined3d_resource *resource; void *parent; }; void wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view, - struct IWineD3DResourceImpl *resource, void *parent) DECLSPEC_HIDDEN; + struct wined3d_resource *resource, void *parent) DECLSPEC_HIDDEN; /***************************************************************************** * IWineD3DSwapChainImpl implementation structure (extends IUnknown) diff --git a/include/wine/wined3d.idl b/include/wine/wined3d.idl index ae34d1aed33..6ba3ffd1d72 100644 --- a/include/wine/wined3d.idl +++ b/include/wine/wined3d.idl @@ -2105,7 +2105,6 @@ struct wined3d_parent_ops void (__stdcall *wined3d_object_destroyed)(void *parent); }; -interface IWineD3DResource; interface IWineD3DSurface; interface IWineD3DVolume; interface IWineD3DSwapChain; @@ -2114,6 +2113,7 @@ struct wined3d; struct wined3d_clipper; struct wined3d_palette; struct wined3d_query; +struct wined3d_resource; struct wined3d_stateblock; struct wined3d_vertex_declaration; @@ -2178,7 +2178,7 @@ interface IWineD3DDeviceParent : IUnknown ); } typedef ULONG (__stdcall *D3DCB_DESTROYSWAPCHAINFN)(IWineD3DSwapChain *pSwapChain); -typedef HRESULT (__stdcall *D3DCB_ENUMRESOURCES)(IWineD3DResource *resource, void *pData); +typedef HRESULT (__stdcall *D3DCB_ENUMRESOURCES)(struct wined3d_resource *resource, void *pData); [ object, @@ -2231,7 +2231,7 @@ interface IWineD3DResource : IWineD3DBase interface IWineD3DRendertargetView : IWineD3DBase { HRESULT GetResource( - [out] IWineD3DResource **resource + [out] struct wined3d_resource **resource ); } @@ -2242,6 +2242,8 @@ interface IWineD3DRendertargetView : IWineD3DBase ] interface IWineD3DSurface : IWineD3DResource { + struct wined3d_resource *GetResource( + ); void GetDesc( [out] WINED3DSURFACE_DESC *desc ); @@ -2523,6 +2525,8 @@ interface IWineD3DSwapChain : IWineD3DBase ] interface IWineD3DBuffer : IWineD3DResource { + struct wined3d_resource *GetResource( + ); HRESULT Map( [in] UINT offset, [in] UINT size, @@ -2632,7 +2636,7 @@ interface IWineD3DDevice : IUnknown [out] IWineD3DSurface **surface ); HRESULT CreateRendertargetView( - [in] IWineD3DResource *resource, + [in] struct wined3d_resource *resource, [in] void *parent, [out] IWineD3DRendertargetView **rendertarget_view ); @@ -3251,6 +3255,8 @@ WINED3DQUERYTYPE __cdecl wined3d_query_get_type(const struct wined3d_query *quer ULONG __cdecl wined3d_query_incref(struct wined3d_query *query); HRESULT __cdecl wined3d_query_issue(struct wined3d_query *query, DWORD flags); +void * __cdecl wined3d_resource_get_parent(const struct wined3d_resource *resource); + HRESULT __cdecl wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock); HRESULT __cdecl wined3d_stateblock_capture(struct wined3d_stateblock *stateblock); ULONG __cdecl wined3d_stateblock_decref(struct wined3d_stateblock *stateblock);