ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Make IWineD3DResourceImpl an independent structure.

This commit is contained in:
Henri Verbeet 2011-03-01 09:47:56 +01:00 committed by Alexandre Julliard
parent 1674ca1ebd
commit 1de6adfbae
21 changed files with 416 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
dlls/d3d10core/view.c
View File

@ -25,7 +25,7 @@
WINE_DEFAULT_DEBUG_CHANNEL(d3d10core); 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; D3D10_RESOURCE_DIMENSION dimension;
@ -34,10 +34,10 @@ static IWineD3DResource *wined3d_resource_from_resource(ID3D10Resource *resource
switch(dimension) switch(dimension)
{ {
case D3D10_RESOURCE_DIMENSION_BUFFER: 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: case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
return (IWineD3DResource *)((struct d3d10_texture2d *)resource)->wined3d_surface; return IWineD3DSurface_GetResource(((struct d3d10_texture2d *)resource)->wined3d_surface);
default: default:
FIXME("Unhandled resource dimension %#x.\n", dimension); FIXME("Unhandled resource dimension %#x.\n", dimension);
@ -374,7 +374,7 @@ static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTa
ID3D10Resource **resource) ID3D10Resource **resource)
{ {
struct d3d10_rendertarget_view *This = (struct d3d10_rendertarget_view *)iface; struct d3d10_rendertarget_view *This = (struct d3d10_rendertarget_view *)iface;
IWineD3DResource *wined3d_resource; struct wined3d_resource *wined3d_resource;
IUnknown *parent; IUnknown *parent;
HRESULT hr; HRESULT hr;
@ -388,9 +388,8 @@ static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTa
return; return;
} }
parent = IWineD3DResource_GetParent(wined3d_resource); parent = wined3d_resource_get_parent(wined3d_resource);
hr = IUnknown_QueryInterface(parent, &IID_ID3D10Resource, (void **)&resource); hr = IUnknown_QueryInterface(parent, &IID_ID3D10Resource, (void **)&resource);
IWineD3DResource_Release(wined3d_resource);
if (FAILED(hr)) if (FAILED(hr))
{ {
ERR("Resource parent isn't a d3d10 resource, hr %#x\n", 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, HRESULT d3d10_rendertarget_view_init(struct d3d10_rendertarget_view *view, struct d3d10_device *device,
ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc) ID3D10Resource *resource, const D3D10_RENDER_TARGET_VIEW_DESC *desc)
{ {
IWineD3DResource *wined3d_resource; struct wined3d_resource *wined3d_resource;
HRESULT hr; HRESULT hr;
view->vtbl = &d3d10_rendertarget_view_vtbl; view->vtbl = &d3d10_rendertarget_view_vtbl;

16
dlls/d3d9/device.c
View File

@ -529,27 +529,28 @@ static UINT WINAPI IDirect3DDevice9Impl_GetNumberOfSwapChains(IDirect3DDevice9Ex
return count; 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; BOOL *resources_ok = data;
D3DRESOURCETYPE type; D3DRESOURCETYPE type;
HRESULT ret = S_OK; HRESULT ret = S_OK;
WINED3DSURFACE_DESC surface_desc; D3DSURFACE_DESC surface_desc;
WINED3DVOLUME_DESC volume_desc; D3DVOLUME_DESC volume_desc;
D3DINDEXBUFFER_DESC index_desc; D3DINDEXBUFFER_DESC index_desc;
D3DVERTEXBUFFER_DESC vertex_desc; D3DVERTEXBUFFER_DESC vertex_desc;
WINED3DPOOL pool; WINED3DPOOL pool;
IDirect3DResource9 *parent; IDirect3DResource9 *parent;
parent = IWineD3DResource_GetParent(resource); parent = wined3d_resource_get_parent(resource);
type = IDirect3DResource9_GetType(parent); type = IDirect3DResource9_GetType(parent);
switch(type) { switch(type) {
case D3DRTYPE_SURFACE: case D3DRTYPE_SURFACE:
IWineD3DSurface_GetDesc((IWineD3DSurface *) resource, &surface_desc); IDirect3DSurface9_GetDesc((IDirect3DSurface9 *)parent, &surface_desc);
pool = surface_desc.pool; pool = surface_desc.Pool;
break; break;
case D3DRTYPE_VOLUME: case D3DRTYPE_VOLUME:
IWineD3DVolume_GetDesc((IWineD3DVolume *) resource, &volume_desc); IDirect3DVolume9_GetDesc((IDirect3DVolume9 *)parent, &volume_desc);
pool = volume_desc.Pool; pool = volume_desc.Pool;
break; break;
@ -583,7 +584,6 @@ static HRESULT WINAPI reset_enum_callback(IWineD3DResource *resource, void *data
*resources_ok = FALSE; *resources_ok = FALSE;
} }
} }
IWineD3DResource_Release(resource);
return ret; return ret;
} }

10
dlls/wined3d/basetexture.c
View File

@ -34,7 +34,7 @@ HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_
{ {
HRESULT hr; 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); 0, usage, format, pool, parent, parent_ops, resource_ops);
if (FAILED(hr)) if (FAILED(hr))
{ {
@ -48,7 +48,7 @@ HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_
if (!texture->baseTexture.sub_resources) if (!texture->baseTexture.sub_resources)
{ {
ERR("Failed to allocate sub-resource array.\n"); ERR("Failed to allocate sub-resource array.\n");
resource_cleanup((IWineD3DResourceImpl *)texture); resource_cleanup(&texture->resource);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
@ -79,10 +79,10 @@ void basetexture_cleanup(IWineD3DBaseTextureImpl *texture)
{ {
basetexture_unload(texture); basetexture_unload(texture);
HeapFree(GetProcessHeap(), 0, texture->baseTexture.sub_resources); 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; 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_rgb.dirty = TRUE;
texture->baseTexture.texture_srgb.dirty = TRUE; texture->baseTexture.texture_srgb.dirty = TRUE;
resource_unload((IWineD3DResourceImpl *)texture); resource_unload(&texture->resource);
} }
DWORD basetexture_set_lod(IWineD3DBaseTextureImpl *texture, DWORD lod) DWORD basetexture_set_lod(IWineD3DBaseTextureImpl *texture, DWORD lod)

76
dlls/wined3d/buffer.c
View File

@ -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. */ /* 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; struct wined3d_context *context;
context = context_acquire(device, NULL); context = context_acquire(device, NULL);
/* Download the buffer, but don't permanently enable double buffering */ /* 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); buffer_get_sysmem(buffer, context->gl_info);
This->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER; buffer->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER;
} }
delete_gl_buffer(This, context->gl_info); delete_gl_buffer(buffer, context->gl_info);
This->flags |= WINED3D_BUFFER_CREATEBO; /* Recreate the buffer object next load */ buffer->flags |= WINED3D_BUFFER_CREATEBO; /* Recreate the buffer object next load */
buffer_clear_dirty_areas(This); buffer_clear_dirty_areas(buffer);
context_release(context); context_release(context);
HeapFree(GetProcessHeap(), 0, This->conversion_shift); HeapFree(GetProcessHeap(), 0, buffer->conversion_shift);
This->conversion_shift = NULL; buffer->conversion_shift = NULL;
HeapFree(GetProcessHeap(), 0, This->conversion_map); HeapFree(GetProcessHeap(), 0, buffer->conversion_map);
This->conversion_map = NULL; buffer->conversion_map = NULL;
This->stride = 0; buffer->stride = 0;
This->conversion_stride = 0; buffer->conversion_stride = 0;
This->flags &= ~WINED3D_BUFFER_HASDESC; buffer->flags &= ~WINED3D_BUFFER_HASDESC;
} }
resource_unload(resource); resource_unload(resource);
@ -741,8 +741,8 @@ static ULONG STDMETHODCALLTYPE buffer_Release(IWineD3DBuffer *iface)
if (!refcount) if (!refcount)
{ {
buffer_unload((IWineD3DResourceImpl *)This); buffer_unload(&This->resource);
resource_cleanup((IWineD3DResourceImpl *)iface); resource_cleanup(&This->resource);
This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent); This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent);
HeapFree(GetProcessHeap(), 0, This->maps); HeapFree(GetProcessHeap(), 0, This->maps);
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
@ -764,28 +764,28 @@ static void * STDMETHODCALLTYPE buffer_GetParent(IWineD3DBuffer *iface)
static HRESULT STDMETHODCALLTYPE buffer_SetPrivateData(IWineD3DBuffer *iface, static HRESULT STDMETHODCALLTYPE buffer_SetPrivateData(IWineD3DBuffer *iface,
REFGUID guid, const void *data, DWORD data_size, DWORD flags) 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, static HRESULT STDMETHODCALLTYPE buffer_GetPrivateData(IWineD3DBuffer *iface,
REFGUID guid, void *data, DWORD *data_size) 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) 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) 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) 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 */ /* 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"); 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; This->flags &= ~WINED3D_BUFFER_CREATEBO;
/* The stream source state handler might have read the memory of the vertex buffer already /* 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) if(This->full_conversion_count > VB_MAXFULLCONVERSIONS)
{ {
FIXME("Too many full buffer conversions, stopping converting\n"); FIXME("Too many full buffer conversions, stopping converting\n");
buffer_unload((IWineD3DResourceImpl *)This); buffer_unload(&This->resource);
This->flags &= ~WINED3D_BUFFER_CREATEBO; This->flags &= ~WINED3D_BUFFER_CREATEBO;
IWineD3DDeviceImpl_MarkStateDirty(device, STATE_STREAMSRC); IWineD3DDeviceImpl_MarkStateDirty(device, STATE_STREAMSRC);
goto end; goto end;
@ -1190,7 +1190,7 @@ end:
static WINED3DRESOURCETYPE STDMETHODCALLTYPE buffer_GetType(IWineD3DBuffer *iface) static WINED3DRESOURCETYPE STDMETHODCALLTYPE buffer_GetType(IWineD3DBuffer *iface)
{ {
return resource_get_type((IWineD3DResourceImpl *)iface); return resource_get_type(&((struct wined3d_buffer *)iface)->resource);
} }
/* IWineD3DBuffer methods */ /* IWineD3DBuffer methods */
@ -1245,6 +1245,13 @@ static GLbitfield buffer_gl_map_flags(DWORD d3d_flags)
return ret; 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) static HRESULT STDMETHODCALLTYPE buffer_Map(IWineD3DBuffer *iface, UINT offset, UINT size, BYTE **data, DWORD flags)
{ {
struct wined3d_buffer *This = (struct wined3d_buffer *)iface; struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
@ -1450,6 +1457,7 @@ static const struct IWineD3DBufferVtbl wined3d_buffer_vtbl =
buffer_PreLoad, buffer_PreLoad,
buffer_GetType, buffer_GetType,
/* IWineD3DBuffer methods */ /* IWineD3DBuffer methods */
buffer_GetResource,
buffer_Map, buffer_Map,
buffer_Unmap, buffer_Unmap,
buffer_GetDesc, buffer_GetDesc,
@ -1477,8 +1485,8 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device,
buffer->vtbl = &wined3d_buffer_vtbl; buffer->vtbl = &wined3d_buffer_vtbl;
hr = resource_init((IWineD3DResourceImpl *)buffer, WINED3DRTYPE_BUFFER, hr = resource_init(&buffer->resource, WINED3DRTYPE_BUFFER, device, size,
device, size, usage, format, pool, parent, parent_ops, &buffer_resource_ops); usage, format, pool, parent, parent_ops, &buffer_resource_ops);
if (FAILED(hr)) if (FAILED(hr))
{ {
WARN("Failed to initialize resource, hr %#x\n", 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)) if (FAILED(hr))
{ {
ERR("Failed to map buffer, hr %#x\n", hr); ERR("Failed to map buffer, hr %#x\n", hr);
buffer_unload((IWineD3DResourceImpl *)buffer); buffer_unload(&buffer->resource);
resource_cleanup((IWineD3DResourceImpl *)buffer); resource_cleanup(&buffer->resource);
return hr; return hr;
} }
@ -1538,8 +1546,8 @@ HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device,
if (!buffer->maps) if (!buffer->maps)
{ {
ERR("Out of memory\n"); ERR("Out of memory\n");
buffer_unload((IWineD3DResourceImpl *)buffer); buffer_unload(&buffer->resource);
resource_cleanup((IWineD3DResourceImpl *)buffer); resource_cleanup(&buffer->resource);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
buffer->maps_size = 1; buffer->maps_size = 1;

8
dlls/wined3d/context.c
View File

@ -690,14 +690,14 @@ static void context_queue_fbo_entry_destruction(struct wined3d_context *context,
} }
void context_resource_released(struct IWineD3DDeviceImpl *device, void context_resource_released(struct IWineD3DDeviceImpl *device,
struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) struct wined3d_resource *resource, WINED3DRESOURCETYPE type)
{ {
if (!device->d3d_initialized) return; if (!device->d3d_initialized) return;
switch (type) switch (type)
{ {
case WINED3DRTYPE_SURFACE: 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); context_queue_fbo_entry_destruction);
break; break;
@ -712,12 +712,12 @@ static void context_detach_fbo_entry(struct wined3d_context *context, struct fbo
} }
void context_resource_unloaded(struct IWineD3DDeviceImpl *device, void context_resource_unloaded(struct IWineD3DDeviceImpl *device,
struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) struct wined3d_resource *resource, WINED3DRESOURCETYPE type)
{ {
switch (type) switch (type)
{ {
case WINED3DRTYPE_SURFACE: 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); context_detach_fbo_entry);
break; break;

64
dlls/wined3d/cubetexture.c
View File

@ -43,7 +43,7 @@ static HRESULT cubetexture_bind(IWineD3DBaseTextureImpl *texture, BOOL srgb)
for (i = 0; i < sub_count; ++i) 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) if (texture->baseTexture.is_srgb)
surface_set_texture_name(surface, texture->baseTexture.texture_srgb.name, TRUE); 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) 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)) if (palette9_changed(surface))
{ {
@ -122,7 +122,7 @@ static void cubetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSR
{ {
for (i = 0; i < sub_count; ++i) 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 else
@ -137,9 +137,9 @@ static void cubetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSR
} }
/* Do not call while under the GL lock. */ /* 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 sub_count = texture->baseTexture.level_count * texture->baseTexture.layer_count;
UINT i; UINT i;
@ -147,9 +147,10 @@ static void cubetexture_unload(IWineD3DResourceImpl *resource)
for (i = 0; i < sub_count; ++i) 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, TRUE);
surface_set_texture_name(surface, 0, FALSE); surface_set_texture_name(surface, 0, FALSE);
} }
@ -177,7 +178,7 @@ static void cubetexture_cleanup(IWineD3DCubeTextureImpl *This)
for (i = 0; i < sub_count; ++i) 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) if (surface)
{ {
@ -241,28 +242,28 @@ static ULONG WINAPI IWineD3DCubeTextureImpl_Release(IWineD3DCubeTexture *iface)
static HRESULT WINAPI IWineD3DCubeTextureImpl_SetPrivateData(IWineD3DCubeTexture *iface, static HRESULT WINAPI IWineD3DCubeTextureImpl_SetPrivateData(IWineD3DCubeTexture *iface,
REFGUID riid, const void *data, DWORD data_size, DWORD flags) 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, static HRESULT WINAPI IWineD3DCubeTextureImpl_GetPrivateData(IWineD3DCubeTexture *iface,
REFGUID guid, void *data, DWORD *data_size) 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) 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) 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) 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. */ /* 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) 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) static void * WINAPI IWineD3DCubeTextureImpl_GetParent(IWineD3DCubeTexture *iface)
@ -326,17 +327,17 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_GetLevelDesc(IWineD3DCubeTexture *
UINT sub_resource_idx, WINED3DSURFACE_DESC *desc) UINT sub_resource_idx, WINED3DSURFACE_DESC *desc)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
IWineD3DSurface_GetDesc(surface, desc); IWineD3DSurface_GetDesc((IWineD3DSurface *)surface_from_resource(sub_resource), desc);
return WINED3D_OK; return WINED3D_OK;
} }
@ -345,19 +346,19 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_GetCubeMapSurface(IWineD3DCubeText
UINT sub_resource_idx, IWineD3DSurface **surface) UINT sub_resource_idx, IWineD3DSurface **surface)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
IWineD3DSurface *s; struct wined3d_resource *sub_resource;
TRACE("iface %p, sub_resource_idx %u, surface %p.\n", TRACE("iface %p, sub_resource_idx %u, surface %p.\n",
iface, sub_resource_idx, surface); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
IWineD3DSurface_AddRef(s); *surface = (IWineD3DSurface *)surface_from_resource(sub_resource);
*surface = s; IWineD3DSurface_AddRef(*surface);
TRACE("Returning surface %p.\n", *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) UINT sub_resource_idx, WINED3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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", 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); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; 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, static HRESULT WINAPI IWineD3DCubeTextureImpl_Unmap(IWineD3DCubeTexture *iface,
UINT sub_resource_idx) UINT sub_resource_idx)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
IWineD3DSurface *surface; struct wined3d_resource *sub_resource;
TRACE("iface %p, sub_resource_idx %u.\n", TRACE("iface %p, sub_resource_idx %u.\n",
iface, sub_resource_idx); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
return IWineD3DSurface_Unmap(surface); return IWineD3DSurface_Unmap((IWineD3DSurface *)surface_from_resource(sub_resource));
} }
static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture *iface, static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture *iface,
@ -405,12 +407,12 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture *
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
UINT sub_resource_idx = face * texture->baseTexture.level_count; 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", TRACE("iface %p, face %u, dirty_rect %s.\n",
iface, face, wine_dbgstr_rect(dirty_rect)); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
@ -418,7 +420,7 @@ static HRESULT WINAPI IWineD3DCubeTextureImpl_AddDirtyRect(IWineD3DCubeTexture *
texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_rgb.dirty = TRUE;
texture->baseTexture.texture_srgb.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; 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_container((IWineD3DSurfaceImpl *)surface, WINED3D_CONTAINER_TEXTURE, (IWineD3DBase *)texture);
surface_set_texture_target((IWineD3DSurfaceImpl *)surface, cube_targets[j]); 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); TRACE("Created surface level %u @ %p.\n", i, surface);
} }
tmp_w = max(1, tmp_w >> 1); tmp_w = max(1, tmp_w >> 1);

181
dlls/wined3d/device.c
View File

@ -867,14 +867,13 @@ static ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
if (!list_empty(&This->resources)) if (!list_empty(&This->resources))
{ {
IWineD3DResourceImpl *resource; struct wined3d_resource *resource;
FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This); 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", 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, 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; struct wined3d_rendertarget_view *object;
@ -1093,7 +1092,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_CreateRendertargetView(IWineD3DDevice *
return E_OUTOFMEMORY; 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); TRACE("Created render target view %p.\n", object);
*rendertarget_view = (IWineD3DRendertargetView *)object; *rendertarget_view = (IWineD3DRendertargetView *)object;
@ -2102,12 +2101,11 @@ err_out:
return hr; 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); TRACE("Unloading resource %p.\n", resource);
((IWineD3DResourceImpl *)resource)->resource.resource_ops->resource_unload((IWineD3DResourceImpl *)resource); resource->resource_ops->resource_unload(resource);
IWineD3DResource_Release(resource);
return S_OK; return S_OK;
} }
@ -5726,7 +5724,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_ColorFill(IWineD3DDevice *iface,
static void WINAPI IWineD3DDeviceImpl_ClearRendertargetView(IWineD3DDevice *iface, static void WINAPI IWineD3DDeviceImpl_ClearRendertargetView(IWineD3DDevice *iface,
IWineD3DRendertargetView *rendertarget_view, const WINED3DCOLORVALUE *color) IWineD3DRendertargetView *rendertarget_view, const WINED3DCOLORVALUE *color)
{ {
IWineD3DResource *resource; struct wined3d_resource *resource;
HRESULT hr; HRESULT hr;
hr = IWineD3DRendertargetView_GetResource(rendertarget_view, &resource); hr = IWineD3DRendertargetView_GetResource(rendertarget_view, &resource);
@ -5736,17 +5734,14 @@ static void WINAPI IWineD3DDeviceImpl_ClearRendertargetView(IWineD3DDevice *ifac
return; return;
} }
if (IWineD3DResource_GetType(resource) != WINED3DRTYPE_SURFACE) if (resource->resourceType != WINED3DRTYPE_SURFACE)
{ {
FIXME("Only supported on surface resources\n"); FIXME("Only supported on surface resources\n");
IWineD3DResource_Release(resource);
return; 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); if (FAILED(hr)) ERR("Color fill failed, hr %#x.\n", hr);
IWineD3DResource_Release(resource);
} }
/* rendertarget and depth stencil functions */ /* rendertarget and depth stencil functions */
@ -6099,13 +6094,16 @@ static BOOL WINAPI IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOO
return oldVisible; 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); TRACE("checking resource %p for eviction\n", resource);
if(((IWineD3DResourceImpl *) resource)->resource.pool == WINED3DPOOL_MANAGED) {
TRACE("Evicting %p\n", resource); if (resource->pool == WINED3DPOOL_MANAGED)
((IWineD3DResourceImpl *)resource)->resource.resource_ops->resource_unload((IWineD3DResourceImpl *)resource); {
TRACE("Evicting %p.\n", resource);
resource->resource_ops->resource_unload(resource);
} }
IWineD3DResource_Release(resource);
return S_OK; 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); 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); 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; unsigned int i;
TRACE("device %p, resource %p, type %s.\n", device, resource, debug_d3dresourcetype(type)); 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) switch (type)
{ {
case WINED3DRTYPE_SURFACE: 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); if (device->render_targets[i] == surface)
device->render_targets[i] = NULL; {
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) if (device->depth_stencil == surface)
{ {
ERR("Surface %p is still in use as depth/stencil buffer.\n", resource); ERR("Surface %p is still in use as depth/stencil buffer.\n", surface);
device->depth_stencil = NULL; device->depth_stencil = NULL;
}
} }
break; break;
@ -6675,57 +6677,62 @@ void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3D
case WINED3DRTYPE_VOLUMETEXTURE: case WINED3DRTYPE_VOLUMETEXTURE:
for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i) 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", 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; device->stateBlock->state.textures[i] = NULL;
} }
if (device->updateStateBlock != device->stateBlock 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", 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; device->updateStateBlock->state.textures[i] = NULL;
} }
} }
break; break;
case WINED3DRTYPE_BUFFER: case WINED3DRTYPE_BUFFER:
for (i = 0; i < MAX_STREAMS; ++i)
{ {
if (device->stateBlock struct wined3d_buffer *buffer = buffer_from_resource(resource);
&& device->stateBlock->state.streams[i].buffer == (struct wined3d_buffer *)resource)
for (i = 0; i < MAX_STREAMS; ++i)
{ {
ERR("Buffer %p is still in use by stateblock %p, stream %u.\n", if (device->stateBlock && device->stateBlock->state.streams[i].buffer == buffer)
resource, device->stateBlock, i); {
device->stateBlock->state.streams[i].buffer = NULL; 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 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", ERR("Buffer %p is still in use by stateblock %p as index buffer.\n",
resource, device->updateStateBlock, i); buffer, device->updateStateBlock);
device->updateStateBlock->state.streams[i].buffer = NULL; 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; break;
@ -6739,38 +6746,42 @@ void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3D
TRACE("Resource released.\n"); 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; IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
IWineD3DResourceImpl *resource, *cursor; struct wined3d_resource *resource, *cursor;
HRESULT ret;
TRACE("(%p)->(%p,%p)\n", This, pCallback, pData);
LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) { TRACE("iface %p, callback %p, data %p.\n", iface, callback, data);
TRACE("enumerating resource %p\n", resource);
IWineD3DResource_AddRef((IWineD3DResource *) resource); LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &This->resources, struct wined3d_resource, resource_list_entry)
ret = pCallback((IWineD3DResource *) resource, pData); {
if(ret == S_FALSE) { TRACE("enumerating resource %p.\n", resource);
TRACE("Canceling enumeration\n"); if (callback(resource, data) == S_FALSE)
{
TRACE("Canceling enumeration.\n");
break; break;
} }
} }
return WINED3D_OK; return WINED3D_OK;
} }
static HRESULT WINAPI IWineD3DDeviceImpl_GetSurfaceFromDC(IWineD3DDevice *iface, HDC dc, IWineD3DSurface **surface) static HRESULT WINAPI IWineD3DDeviceImpl_GetSurfaceFromDC(IWineD3DDevice *iface, HDC dc, IWineD3DSurface **surface)
{ {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface; IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
IWineD3DResourceImpl *resource; 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 (resource->resourceType == WINED3DRTYPE_SURFACE)
if (type == 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); TRACE("Found surface %p for dc %p.\n", s, dc);
*surface = (IWineD3DSurface *)resource; *surface = (IWineD3DSurface *)s;
return WINED3D_OK; return WINED3D_OK;
} }
} }

8
dlls/wined3d/palette.c
View File

@ -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, HRESULT CDECL wined3d_palette_set_entries(struct wined3d_palette *palette,
DWORD flags, DWORD start, DWORD count, const PALETTEENTRY *entries) 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", TRACE("palette %p, flags %#x, start %u, count %u, entries %p.\n",
palette, flags, start, count, entries); 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 */ /* 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) if (surface->palette == palette)
surface->surface_ops->surface_realize_palette(surface); surface->surface_ops->surface_realize_palette(surface);
} }

102
dlls/wined3d/resource.c
View File

@ -43,30 +43,28 @@ struct private_data
DWORD size; 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, IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format *format,
WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops, WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops,
const struct wined3d_resource_ops *resource_ops) const struct wined3d_resource_ops *resource_ops)
{ {
struct IWineD3DResourceClass *r = &resource->resource; resource->device = device;
resource->resourceType = resource_type;
r->device = device; resource->ref = 1;
r->resourceType = resource_type; resource->pool = pool;
r->ref = 1; resource->format = format;
r->pool = pool; resource->usage = usage;
r->format = format; resource->size = size;
r->usage = usage; resource->priority = 0;
r->size = size; resource->parent = parent;
r->priority = 0; resource->parent_ops = parent_ops;
r->parent = parent; resource->resource_ops = resource_ops;
r->parent_ops = parent_ops; list_init(&resource->privateData);
r->resource_ops = resource_ops;
list_init(&r->privateData);
if (size) if (size)
{ {
r->heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size + RESOURCE_ALIGNMENT); resource->heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size + RESOURCE_ALIGNMENT);
if (!r->heapMemory) if (!resource->heapMemory)
{ {
ERR("Out of memory!\n"); ERR("Out of memory!\n");
return WINED3DERR_OUTOFVIDEOMEMORY; return WINED3DERR_OUTOFVIDEOMEMORY;
@ -74,9 +72,10 @@ HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE
} }
else 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 */ /* Check that we have enough video ram left */
if (pool == WINED3DPOOL_DEFAULT) if (pool == WINED3DPOOL_DEFAULT)
@ -84,7 +83,7 @@ HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE
if (size > IWineD3DDevice_GetAvailableTextureMem((IWineD3DDevice *)device)) if (size > IWineD3DDevice_GetAvailableTextureMem((IWineD3DDevice *)device))
{ {
ERR("Out of adapter memory\n"); ERR("Out of adapter memory\n");
HeapFree(GetProcessHeap(), 0, r->heapMemory); HeapFree(GetProcessHeap(), 0, resource->heapMemory);
return WINED3DERR_OUTOFVIDEOMEMORY; return WINED3DERR_OUTOFVIDEOMEMORY;
} }
WineD3DAdapterChangeGLRam(device, size); WineD3DAdapterChangeGLRam(device, size);
@ -95,7 +94,7 @@ HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE
return WINED3D_OK; return WINED3D_OK;
} }
void resource_cleanup(struct IWineD3DResourceImpl *resource) void resource_cleanup(struct wined3d_resource *resource)
{ {
struct private_data *data; struct private_data *data;
struct list *e1, *e2; struct list *e1, *e2;
@ -103,13 +102,13 @@ void resource_cleanup(struct IWineD3DResourceImpl *resource)
TRACE("Cleaning up resource %p.\n", 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); TRACE("Decrementing device memory pool by %u.\n", resource->size);
WineD3DAdapterChangeGLRam(resource->resource.device, -resource->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); data = LIST_ENTRY(e1, struct private_data, entry);
hr = resource_free_private_data(resource, &data->tag); 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); ERR("Failed to free private data when destroying resource %p, hr = %#x.\n", resource, hr);
} }
HeapFree(GetProcessHeap(), 0, resource->resource.heapMemory); HeapFree(GetProcessHeap(), 0, resource->heapMemory);
resource->resource.allocatedMemory = 0; resource->allocatedMemory = 0;
resource->resource.heapMemory = 0; resource->heapMemory = 0;
if (resource->resource.device) if (resource->device)
device_resource_released(resource->resource.device, resource); device_resource_released(resource->device, resource);
} }
void resource_unload(IWineD3DResourceImpl *resource) void resource_unload(struct wined3d_resource *resource)
{ {
context_resource_unloaded(resource->resource.device, context_resource_unloaded(resource->device,
resource, resource->resource.resourceType); 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 private_data *data;
struct list *entry; struct list *entry;
TRACE("Searching for private data %s\n", debugstr_guid(tag)); 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); data = LIST_ENTRY(entry, struct private_data, entry);
if (IsEqualGUID(&data->tag, tag)) { if (IsEqualGUID(&data->tag, tag)) {
@ -149,7 +148,7 @@ static struct private_data *resource_find_private_data(const struct IWineD3DReso
return NULL; 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) const void *data, DWORD data_size, DWORD flags)
{ {
struct private_data *d; struct private_data *d;
@ -188,12 +187,12 @@ HRESULT resource_set_private_data(struct IWineD3DResourceImpl *resource, REFGUID
d->size = data_size; d->size = data_size;
memcpy(d->ptr.data, data, 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; 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; const struct private_data *d;
@ -212,7 +211,7 @@ HRESULT resource_get_private_data(const struct IWineD3DResourceImpl *resource, R
if (d->flags & WINED3DSPD_IUNKNOWN) if (d->flags & WINED3DSPD_IUNKNOWN)
{ {
*(IUnknown **)data = d->ptr.object; *(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 /* D3D8 and D3D9 addref the private data, DDraw does not. This
* can't be handled in ddraw because it doesn't know if the * 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; 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; struct private_data *data;
@ -252,22 +251,27 @@ HRESULT resource_free_private_data(struct IWineD3DResourceImpl *resource, REFGUI
return WINED3D_OK; 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; DWORD prev = resource->priority;
resource->resource.priority = priority; resource->priority = priority;
TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev); TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev);
return 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); TRACE("resource %p, returning %u.\n", resource, resource->priority);
return 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); TRACE("resource %p, returning %#x.\n", resource, resource->resourceType);
return resource->resource.resourceType; return resource->resourceType;
}
void * CDECL wined3d_resource_get_parent(const struct wined3d_resource *resource)
{
return resource->parent;
} }

4
dlls/wined3d/state.c
View File

@ -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) 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) 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) 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) if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask)
{ {

21
dlls/wined3d/surface.c
View File

@ -89,7 +89,7 @@ static void surface_cleanup(IWineD3DSurfaceImpl *This)
HeapFree(GetProcessHeap(), 0, This->palette9); 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) 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. */ /* 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; IWineD3DSurfaceImpl *surface = surface_from_resource(resource);
IWineD3DDeviceImpl *device = resource->resource.device; IWineD3DDeviceImpl *device = resource->device;
const struct wined3d_gl_info *gl_info; const struct wined3d_gl_info *gl_info;
renderbuffer_entry_t *entry, *entry2; renderbuffer_entry_t *entry, *entry2;
struct wined3d_context *context; struct wined3d_context *context;
TRACE("surface %p.\n", surface); 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. /* 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 * 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; return WINED3DERR_INVALIDCALL;
} }
hr = resource_init((IWineD3DResourceImpl *)surface, WINED3DRTYPE_SURFACE, device, hr = resource_init(&surface->resource, WINED3DRTYPE_SURFACE, device, resource_size,
resource_size, usage, format, pool, parent, parent_ops, &surface_resource_ops); usage, format, pool, parent, parent_ops, &surface_resource_ops);
if (FAILED(hr)) if (FAILED(hr))
{ {
WARN("Failed to initialize resource, returning %#x.\n", 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) 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); 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; back->texture_name_srgb = front->texture_name_srgb;
front->texture_name_srgb = tmp; front->texture_name_srgb = tmp;
resource_unload((IWineD3DResourceImpl *)back); resource_unload(&back->resource);
resource_unload((IWineD3DResourceImpl *)front); resource_unload(&front->resource);
} }
{ {
@ -4685,6 +4685,7 @@ const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
IWineD3DSurfaceImpl_PreLoad, IWineD3DSurfaceImpl_PreLoad,
IWineD3DBaseSurfaceImpl_GetType, IWineD3DBaseSurfaceImpl_GetType,
/* IWineD3DSurface */ /* IWineD3DSurface */
IWineD3DBaseSurfaceImpl_GetResource,
IWineD3DBaseSurfaceImpl_GetDesc, IWineD3DBaseSurfaceImpl_GetDesc,
IWineD3DSurfaceImpl_Map, IWineD3DSurfaceImpl_Map,
IWineD3DSurfaceImpl_Unmap, IWineD3DSurfaceImpl_Unmap,

19
dlls/wined3d/surface_base.c
View File

@ -114,33 +114,33 @@ ULONG WINAPI IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface *iface) {
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface *iface, HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface *iface,
REFGUID riid, const void *data, DWORD data_size, DWORD flags) 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, HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPrivateData(IWineD3DSurface *iface,
REFGUID guid, void *data, DWORD *data_size) 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) 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) 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) 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) 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) void * WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface)
@ -150,6 +150,13 @@ void * WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface)
return ((IWineD3DSurfaceImpl *)iface)->resource.parent; 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) void WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *desc)
{ {
IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)iface; IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)iface;

3
dlls/wined3d/surface_gdi.c
View File

@ -54,7 +54,7 @@ void surface_gdi_cleanup(IWineD3DSurfaceImpl *This)
HeapFree(GetProcessHeap(), 0, This->palette9); HeapFree(GetProcessHeap(), 0, This->palette9);
resource_cleanup((IWineD3DResourceImpl *)This); resource_cleanup(&This->resource);
} }
static void gdi_surface_realize_palette(IWineD3DSurfaceImpl *surface) static void gdi_surface_realize_palette(IWineD3DSurfaceImpl *surface)
@ -451,6 +451,7 @@ const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
IWineGDISurfaceImpl_PreLoad, IWineGDISurfaceImpl_PreLoad,
IWineD3DBaseSurfaceImpl_GetType, IWineD3DBaseSurfaceImpl_GetType,
/* IWineD3DSurface */ /* IWineD3DSurface */
IWineD3DBaseSurfaceImpl_GetResource,
IWineD3DBaseSurfaceImpl_GetDesc, IWineD3DBaseSurfaceImpl_GetDesc,
IWineGDISurfaceImpl_Map, IWineGDISurfaceImpl_Map,
IWineGDISurfaceImpl_Unmap, IWineGDISurfaceImpl_Unmap,

63
dlls/wined3d/texture.c
View File

@ -48,7 +48,7 @@ static HRESULT texture_bind(IWineD3DBaseTextureImpl *texture, BOOL srgb)
for (i = 0; i < texture->baseTexture.level_count; ++i) 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); 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) 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)) if (palette9_changed(surface))
{ {
TRACE("Reloading surface because the d3d8/9 palette was changed.\n"); 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) 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 else
@ -161,18 +161,19 @@ static void texture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB s
} }
/* Do not call while under the GL lock. */ /* 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; unsigned int i;
TRACE("texture %p.\n", texture); TRACE("texture %p.\n", texture);
for (i = 0; i < texture->baseTexture.level_count; ++i) 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, FALSE); /* Delete rgb name */
surface_set_texture_name(surface, 0, TRUE); /* delete srgb 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) 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) if (surface)
{ {
/* Clean out the texture name we gave to the surface so that the /* 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, static HRESULT WINAPI IWineD3DTextureImpl_SetPrivateData(IWineD3DTexture *iface,
REFGUID riid, const void *data, DWORD data_size, DWORD flags) 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, static HRESULT WINAPI IWineD3DTextureImpl_GetPrivateData(IWineD3DTexture *iface,
REFGUID guid, void *data, DWORD *data_size) 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) 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) 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) 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. */ /* 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) 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) 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) UINT sub_resource_idx, WINED3DSURFACE_DESC *desc)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
IWineD3DSurface_GetDesc(surface, desc); IWineD3DSurface_GetDesc((IWineD3DSurface *)surface_from_resource(sub_resource), desc);
return WINED3D_OK; return WINED3D_OK;
} }
@ -369,18 +370,18 @@ static HRESULT WINAPI IWineD3DTextureImpl_GetSurfaceLevel(IWineD3DTexture *iface
UINT sub_resource_idx, IWineD3DSurface **surface) UINT sub_resource_idx, IWineD3DSurface **surface)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
IWineD3DSurface_AddRef(s); *surface = (IWineD3DSurface *)surface_from_resource(sub_resource);
*surface = s; IWineD3DSurface_AddRef(*surface);
TRACE("Returning surface %p.\n", *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) UINT sub_resource_idx, WINED3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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", 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); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; 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) static HRESULT WINAPI IWineD3DTextureImpl_Unmap(IWineD3DTexture *iface, UINT sub_resource_idx)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
IWineD3DSurface *surface; struct wined3d_resource *sub_resource;
TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; 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) static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, const RECT *dirty_rect)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
IWineD3DSurfaceImpl *surface; struct wined3d_resource *sub_resource;
TRACE("iface %p, dirty_rect %s.\n", iface, wine_dbgstr_rect(dirty_rect)); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
@ -436,7 +437,7 @@ static HRESULT WINAPI IWineD3DTextureImpl_AddDirtyRect(IWineD3DTexture *iface, c
texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_rgb.dirty = TRUE;
texture->baseTexture.texture_srgb.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; 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_container((IWineD3DSurfaceImpl *)surface, WINED3D_CONTAINER_TEXTURE, (IWineD3DBase *)texture);
surface_set_texture_target((IWineD3DSurfaceImpl *)surface, texture->baseTexture.target); 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); TRACE("Created surface level %u @ %p.\n", i, surface);
/* Calculate the next mipmap level. */ /* Calculate the next mipmap level. */
tmp_w = max(1, tmp_w >> 1); tmp_w = max(1, tmp_w >> 1);

2
dlls/wined3d/utils.c
View File

@ -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) 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) if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask)
{ {

9
dlls/wined3d/view.c
View File

@ -65,7 +65,6 @@ static ULONG STDMETHODCALLTYPE rendertarget_view_Release(IWineD3DRendertargetVie
if (!refcount) if (!refcount)
{ {
IWineD3DResource_Release((IWineD3DResource *)This->resource);
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
} }
@ -84,12 +83,11 @@ static void * STDMETHODCALLTYPE rendertarget_view_GetParent(IWineD3DRendertarget
/* IWineD3DRendertargetView methods */ /* IWineD3DRendertargetView methods */
static HRESULT STDMETHODCALLTYPE rendertarget_view_GetResource(IWineD3DRendertargetView *iface, static HRESULT STDMETHODCALLTYPE rendertarget_view_GetResource(IWineD3DRendertargetView *iface,
IWineD3DResource **resource) struct wined3d_resource **resource)
{ {
struct wined3d_rendertarget_view *This = (struct wined3d_rendertarget_view *)iface; struct wined3d_rendertarget_view *This = (struct wined3d_rendertarget_view *)iface;
IWineD3DResource_AddRef((IWineD3DResource *)This->resource); *resource = This->resource;
*resource = (IWineD3DResource *)This->resource;
return WINED3D_OK; 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, 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->vtbl = &wined3d_rendertarget_view_vtbl;
view->refcount = 1; view->refcount = 1;
IWineD3DResource_AddRef((IWineD3DResource *)resource);
view->resource = resource; view->resource = resource;
view->parent = parent; view->parent = parent;
} }

18
dlls/wined3d/volume.c
View File

@ -119,7 +119,7 @@ void volume_load(IWineD3DVolumeImpl *volume, UINT level, BOOL srgb_mode)
} }
/* Do not call while under the GL lock. */ /* 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); TRACE("texture %p.\n", resource);
@ -167,7 +167,7 @@ static ULONG WINAPI IWineD3DVolumeImpl_Release(IWineD3DVolume *iface) {
if (!ref) if (!ref)
{ {
resource_cleanup((IWineD3DResourceImpl *)iface); resource_cleanup(&This->resource);
This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent); This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent);
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
} }
@ -187,28 +187,28 @@ static void * WINAPI IWineD3DVolumeImpl_GetParent(IWineD3DVolume *iface)
static HRESULT WINAPI IWineD3DVolumeImpl_SetPrivateData(IWineD3DVolume *iface, static HRESULT WINAPI IWineD3DVolumeImpl_SetPrivateData(IWineD3DVolume *iface,
REFGUID riid, const void *data, DWORD data_size, DWORD flags) 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, static HRESULT WINAPI IWineD3DVolumeImpl_GetPrivateData(IWineD3DVolume *iface,
REFGUID guid, void *data, DWORD *data_size) 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) 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) 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) 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. */ /* 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) 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) 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; 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, width * height * depth * format->byte_count, usage, format, pool,
parent, parent_ops, &volume_resource_ops); parent, parent_ops, &volume_resource_ops);
if (FAILED(hr)) if (FAILED(hr))

61
dlls/wined3d/volumetexture.c
View File

@ -61,14 +61,14 @@ static void volumetexture_preload(IWineD3DBaseTextureImpl *texture, enum WINED3D
{ {
for (i = 0; i < texture->baseTexture.level_count; ++i) 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) else if (srgb_was_toggled)
{ {
for (i = 0; i < texture->baseTexture.level_count; ++i) 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_add_dirty_box(volume, NULL);
volume_load(volume, i, srgb_mode); 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. */ /* 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; unsigned int i;
TRACE("texture %p.\n", texture); TRACE("texture %p.\n", texture);
for (i = 0; i < texture->baseTexture.level_count; ++i) for (i = 0; i < texture->baseTexture.level_count; ++i)
{ {
IWineD3DResourceImpl *resource = texture->baseTexture.sub_resources[i]; struct wined3d_resource *sub_resource = texture->baseTexture.sub_resources[i];
resource->resource.resource_ops->resource_unload(resource); sub_resource->resource_ops->resource_unload(sub_resource);
} }
basetexture_unload(texture); basetexture_unload(texture);
@ -120,7 +120,7 @@ static void volumetexture_cleanup(IWineD3DVolumeTextureImpl *This)
for (i = 0; i < This->baseTexture.level_count; ++i) 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) if (volume)
{ {
@ -180,28 +180,28 @@ static ULONG WINAPI IWineD3DVolumeTextureImpl_Release(IWineD3DVolumeTexture *ifa
static HRESULT WINAPI IWineD3DVolumeTextureImpl_SetPrivateData(IWineD3DVolumeTexture *iface, static HRESULT WINAPI IWineD3DVolumeTextureImpl_SetPrivateData(IWineD3DVolumeTexture *iface,
REFGUID riid, const void *data, DWORD data_size, DWORD flags) 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, static HRESULT WINAPI IWineD3DVolumeTextureImpl_GetPrivateData(IWineD3DVolumeTexture *iface,
REFGUID guid, void *data, DWORD *data_size) 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) 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) 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) 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) 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) 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) static void * WINAPI IWineD3DVolumeTextureImpl_GetParent(IWineD3DVolumeTexture *iface)
@ -264,17 +264,17 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_GetLevelDesc(IWineD3DVolumeTextu
UINT sub_resource_idx, WINED3DVOLUME_DESC *desc) UINT sub_resource_idx, WINED3DVOLUME_DESC *desc)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
IWineD3DVolume_GetDesc(volume, desc); IWineD3DVolume_GetDesc((IWineD3DVolume *)volume_from_resource(sub_resource), desc);
return WINED3D_OK; return WINED3D_OK;
} }
@ -283,18 +283,18 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_GetVolumeLevel(IWineD3DVolumeTex
UINT sub_resource_idx, IWineD3DVolume **volume) UINT sub_resource_idx, IWineD3DVolume **volume)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
} }
IWineD3DVolume_AddRef(v); *volume = (IWineD3DVolume *)volume_from_resource(sub_resource);
*volume = v; IWineD3DVolume_AddRef(*volume);
TRACE("Returning volume %p.\n", *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) UINT sub_resource_idx, WINED3DLOCKED_BOX *locked_box, const WINED3DBOX *box, DWORD flags)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; 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", TRACE("iface %p, sub_resource_idx %u, locked_box %p, box %p, flags %#x.\n",
iface, sub_resource_idx, locked_box, box, flags); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; 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) static HRESULT WINAPI IWineD3DVolumeTextureImpl_Unmap(IWineD3DVolumeTexture *iface, UINT sub_resource_idx)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
IWineD3DVolume *volume; struct wined3d_resource *sub_resource;
TRACE("iface %p, sub_resource_idx %u.\n", iface, sub_resource_idx); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; 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) static HRESULT WINAPI IWineD3DVolumeTextureImpl_AddDirtyBox(IWineD3DVolumeTexture *iface, const WINED3DBOX *dirty_box)
{ {
IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface; IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl *)iface;
IWineD3DVolumeImpl *volume; struct wined3d_resource *sub_resource;
TRACE("iface %p, dirty_box %p.\n", iface, dirty_box); 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"); WARN("Failed to get sub-resource.\n");
return WINED3DERR_INVALIDCALL; return WINED3DERR_INVALIDCALL;
@ -350,7 +351,7 @@ static HRESULT WINAPI IWineD3DVolumeTextureImpl_AddDirtyBox(IWineD3DVolumeTextur
texture->baseTexture.texture_rgb.dirty = TRUE; texture->baseTexture.texture_rgb.dirty = TRUE;
texture->baseTexture.texture_srgb.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; return WINED3D_OK;
} }
@ -473,7 +474,7 @@ HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT
/* Set its container to this texture. */ /* Set its container to this texture. */
volume_set_container((IWineD3DVolumeImpl *)volume, 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. */ /* Calculate the next mipmap level. */
tmp_w = max(1, tmp_w >> 1); tmp_w = max(1, tmp_w >> 1);

2
dlls/wined3d/wined3d.spec
View File

@ -44,6 +44,8 @@
@ cdecl wined3d_query_incref(ptr) @ cdecl wined3d_query_incref(ptr)
@ cdecl wined3d_query_issue(ptr long) @ cdecl wined3d_query_issue(ptr long)
@ cdecl wined3d_resource_get_parent(ptr)
@ cdecl wined3d_stateblock_apply(ptr) @ cdecl wined3d_stateblock_apply(ptr)
@ cdecl wined3d_stateblock_capture(ptr) @ cdecl wined3d_stateblock_capture(ptr)
@ cdecl wined3d_stateblock_decref(ptr) @ cdecl wined3d_stateblock_decref(ptr)

91
dlls/wined3d/wined3d_private.h
View File

@ -57,7 +57,6 @@ typedef struct IWineD3DDeviceImpl IWineD3DDeviceImpl;
typedef struct IWineD3DSwapChainImpl IWineD3DSwapChainImpl; typedef struct IWineD3DSwapChainImpl IWineD3DSwapChainImpl;
struct IWineD3DBaseShaderImpl; struct IWineD3DBaseShaderImpl;
struct IWineD3DBaseTextureImpl; struct IWineD3DBaseTextureImpl;
struct IWineD3DResourceImpl;
/* Texture format fixups */ /* Texture format fixups */
@ -1227,9 +1226,9 @@ struct wined3d_context *context_get_current(void) DECLSPEC_HIDDEN;
DWORD context_get_tls_idx(void) DECLSPEC_HIDDEN; DWORD context_get_tls_idx(void) DECLSPEC_HIDDEN;
void context_release(struct wined3d_context *context) DECLSPEC_HIDDEN; void context_release(struct wined3d_context *context) DECLSPEC_HIDDEN;
void context_resource_released(struct IWineD3DDeviceImpl *device, 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, 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; 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_draw_buffer(struct wined3d_context *context, GLenum buffer) DECLSPEC_HIDDEN;
void context_set_tls_idx(DWORD idx) 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; void device_preload_textures(IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
LRESULT device_process_message(IWineD3DDeviceImpl *device, HWND window, BOOL unicode, LRESULT device_process_message(IWineD3DDeviceImpl *device, HWND window, BOOL unicode,
UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc) DECLSPEC_HIDDEN; 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_add(struct IWineD3DDeviceImpl *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; void device_resource_released(struct IWineD3DDeviceImpl *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
void device_stream_info_from_declaration(IWineD3DDeviceImpl *This, void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
BOOL use_vshader, struct wined3d_stream_info *stream_info, BOOL *fixup) DECLSPEC_HIDDEN; BOOL use_vshader, struct wined3d_stream_info *stream_info, BOOL *fixup) DECLSPEC_HIDDEN;
void device_switch_onscreen_ds(IWineD3DDeviceImpl *device, struct wined3d_context *context, 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 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;
LONG ref; /* Note: Ref counting not required */
/* WineD3DResource Information */
WINED3DRESOURCETYPE resourceType; WINED3DRESOURCETYPE resourceType;
IWineD3DDeviceImpl *device; IWineD3DDeviceImpl *device;
WINED3DPOOL pool; WINED3DPOOL pool;
@ -1819,29 +1815,22 @@ typedef struct IWineD3DResourceClass
void *parent; void *parent;
const struct wined3d_parent_ops *parent_ops; const struct wined3d_parent_ops *parent_ops;
const struct wined3d_resource_ops *resource_ops; const struct wined3d_resource_ops *resource_ops;
} IWineD3DResourceClass; };
typedef struct IWineD3DResourceImpl void resource_cleanup(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
{ HRESULT resource_free_private_data(struct wined3d_resource *resource, REFGUID guid) DECLSPEC_HIDDEN;
/* IUnknown & WineD3DResource Information */ DWORD resource_get_priority(const struct wined3d_resource *resource) DECLSPEC_HIDDEN;
const IWineD3DResourceVtbl *lpVtbl; HRESULT resource_get_private_data(const struct wined3d_resource *resource, REFGUID guid,
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 *data, DWORD *data_size) DECLSPEC_HIDDEN; 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, IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format *format,
WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops, WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops,
const struct wined3d_resource_ops *resource_ops) DECLSPEC_HIDDEN; const struct wined3d_resource_ops *resource_ops) DECLSPEC_HIDDEN;
WINED3DRESOURCETYPE resource_get_type(const struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN; WINED3DRESOURCETYPE resource_get_type(const struct wined3d_resource *resource) DECLSPEC_HIDDEN;
DWORD resource_set_priority(struct IWineD3DResourceImpl *resource, DWORD priority) DECLSPEC_HIDDEN; DWORD resource_set_priority(struct wined3d_resource *resource, DWORD priority) DECLSPEC_HIDDEN;
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) DECLSPEC_HIDDEN; 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 */ /* Tests show that the start address of resources is 32 byte aligned */
#define RESOURCE_ALIGNMENT 16 #define RESOURCE_ALIGNMENT 16
@ -1886,14 +1875,11 @@ struct wined3d_texture_ops
void (*texture_preload)(struct IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB srgb); void (*texture_preload)(struct IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB srgb);
}; };
/*****************************************************************************
* IWineD3DBaseTexture implementation structure (extends IWineD3DResourceImpl)
*/
typedef struct IWineD3DBaseTextureClass typedef struct IWineD3DBaseTextureClass
{ {
const struct wined3d_texture_ops *texture_ops; const struct wined3d_texture_ops *texture_ops;
struct gl_texture texture_rgb, texture_srgb; struct gl_texture texture_rgb, texture_srgb;
IWineD3DResourceImpl **sub_resources; struct wined3d_resource **sub_resources;
UINT layer_count; UINT layer_count;
UINT level_count; UINT level_count;
float pow2Matrix[16]; float pow2Matrix[16];
@ -1912,11 +1898,16 @@ typedef struct IWineD3DBaseTextureImpl
{ {
/* IUnknown & WineD3DResource Information */ /* IUnknown & WineD3DResource Information */
const IWineD3DBaseTextureVtbl *lpVtbl; const IWineD3DBaseTextureVtbl *lpVtbl;
IWineD3DResourceClass resource; struct wined3d_resource resource;
IWineD3DBaseTextureClass baseTexture; IWineD3DBaseTextureClass baseTexture;
} IWineD3DBaseTextureImpl; } IWineD3DBaseTextureImpl;
static inline IWineD3DBaseTextureImpl *basetexture_from_resource(struct wined3d_resource *resource)
{
return CONTAINING_RECORD(resource, IWineD3DBaseTextureImpl, resource);
}
void basetexture_apply_state_changes(IWineD3DBaseTextureImpl *texture, void basetexture_apply_state_changes(IWineD3DBaseTextureImpl *texture,
const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1], const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1],
const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN; 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; WINED3DTEXTUREFILTERTYPE basetexture_get_autogen_filter_type(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
DWORD basetexture_get_level_count(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN; DWORD basetexture_get_level_count(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
DWORD basetexture_get_lod(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; UINT sub_resource_idx) DECLSPEC_HIDDEN;
HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_texture_ops *texture_ops, HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_texture_ops *texture_ops,
UINT layer_count, UINT level_count, WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device, UINT layer_count, UINT level_count, WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device,
@ -1945,7 +1936,7 @@ typedef struct IWineD3DTextureImpl
{ {
/* IUnknown & WineD3DResource/WineD3DBaseTexture Information */ /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
const IWineD3DTextureVtbl *lpVtbl; const IWineD3DTextureVtbl *lpVtbl;
IWineD3DResourceClass resource; struct wined3d_resource resource;
IWineD3DBaseTextureClass baseTexture; IWineD3DBaseTextureClass baseTexture;
/* IWineD3DTexture */ /* IWineD3DTexture */
@ -1964,7 +1955,7 @@ typedef struct IWineD3DCubeTextureImpl
{ {
/* IUnknown & WineD3DResource/WineD3DBaseTexture Information */ /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
const IWineD3DCubeTextureVtbl *lpVtbl; const IWineD3DCubeTextureVtbl *lpVtbl;
IWineD3DResourceClass resource; struct wined3d_resource resource;
IWineD3DBaseTextureClass baseTexture; IWineD3DBaseTextureClass baseTexture;
} IWineD3DCubeTextureImpl; } IWineD3DCubeTextureImpl;
@ -1986,7 +1977,7 @@ typedef struct IWineD3DVolumeImpl
{ {
/* IUnknown & WineD3DResource fields */ /* IUnknown & WineD3DResource fields */
const IWineD3DVolumeVtbl *lpVtbl; const IWineD3DVolumeVtbl *lpVtbl;
IWineD3DResourceClass resource; struct wined3d_resource resource;
/* WineD3DVolume Information */ /* WineD3DVolume Information */
WINED3DVOLUMET_DESC currentDesc; WINED3DVOLUMET_DESC currentDesc;
@ -1998,6 +1989,11 @@ typedef struct IWineD3DVolumeImpl
BOOL dirty; BOOL dirty;
} IWineD3DVolumeImpl; } 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; void volume_add_dirty_box(struct IWineD3DVolumeImpl *volume, const WINED3DBOX *dirty_box) DECLSPEC_HIDDEN;
HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT width, HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT width,
UINT height, UINT depth, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool, 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 */ /* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
const IWineD3DVolumeTextureVtbl *lpVtbl; const IWineD3DVolumeTextureVtbl *lpVtbl;
IWineD3DResourceClass resource; struct wined3d_resource resource;
IWineD3DBaseTextureClass baseTexture; IWineD3DBaseTextureClass baseTexture;
} IWineD3DVolumeTextureImpl; } IWineD3DVolumeTextureImpl;
@ -2094,7 +2090,7 @@ struct IWineD3DSurfaceImpl
{ {
/* IUnknown & IWineD3DResource Information */ /* IUnknown & IWineD3DResource Information */
const IWineD3DSurfaceVtbl *lpVtbl; const IWineD3DSurfaceVtbl *lpVtbl;
IWineD3DResourceClass resource; struct wined3d_resource resource;
/* IWineD3DSurface fields */ /* IWineD3DSurface fields */
const struct wined3d_surface_ops *surface_ops; const struct wined3d_surface_ops *surface_ops;
@ -2154,6 +2150,11 @@ struct IWineD3DSurfaceImpl
extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl DECLSPEC_HIDDEN; extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl DECLSPEC_HIDDEN;
extern const IWineD3DSurfaceVtbl IWineGDISurface_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_add_dirty_rect(IWineD3DSurfaceImpl *surface, const RECT *dirty_rect) DECLSPEC_HIDDEN;
void surface_bind(IWineD3DSurfaceImpl *surface, BOOL srgb) 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; 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_SetPriority(IWineD3DSurface *iface, DWORD PriorityNew) DECLSPEC_HIDDEN;
DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface) DECLSPEC_HIDDEN; DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
WINED3DRESOURCETYPE WINAPI IWineD3DBaseSurfaceImpl_GetType(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; void WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *desc) DECLSPEC_HIDDEN;
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD flags) DECLSPEC_HIDDEN; HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD flags) DECLSPEC_HIDDEN;
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetFlipStatus(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 struct wined3d_buffer
{ {
const struct IWineD3DBufferVtbl *vtbl; const struct IWineD3DBufferVtbl *vtbl;
IWineD3DResourceClass resource; struct wined3d_resource resource;
struct wined3d_buffer_desc desc; struct wined3d_buffer_desc desc;
@ -2550,6 +2552,11 @@ struct wined3d_buffer
UINT *conversion_shift; /* NULL if no shifted conversion */ 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, const BYTE *buffer_get_memory(struct wined3d_buffer *buffer, const struct wined3d_gl_info *gl_info,
GLuint *buffer_object) DECLSPEC_HIDDEN; GLuint *buffer_object) DECLSPEC_HIDDEN;
BYTE *buffer_get_sysmem(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info) 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; const struct IWineD3DRendertargetViewVtbl *vtbl;
LONG refcount; LONG refcount;
struct IWineD3DResourceImpl *resource; struct wined3d_resource *resource;
void *parent; void *parent;
}; };
void wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view, 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) * IWineD3DSwapChainImpl implementation structure (extends IUnknown)

14
include/wine/wined3d.idl
View File

@ -2105,7 +2105,6 @@ struct wined3d_parent_ops
void (__stdcall *wined3d_object_destroyed)(void *parent); void (__stdcall *wined3d_object_destroyed)(void *parent);
}; };
interface IWineD3DResource;
interface IWineD3DSurface; interface IWineD3DSurface;
interface IWineD3DVolume; interface IWineD3DVolume;
interface IWineD3DSwapChain; interface IWineD3DSwapChain;
@ -2114,6 +2113,7 @@ struct wined3d;
struct wined3d_clipper; struct wined3d_clipper;
struct wined3d_palette; struct wined3d_palette;
struct wined3d_query; struct wined3d_query;
struct wined3d_resource;
struct wined3d_stateblock; struct wined3d_stateblock;
struct wined3d_vertex_declaration; struct wined3d_vertex_declaration;
@ -2178,7 +2178,7 @@ interface IWineD3DDeviceParent : IUnknown
); );
} }
typedef ULONG (__stdcall *D3DCB_DESTROYSWAPCHAINFN)(IWineD3DSwapChain *pSwapChain); 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, object,
@ -2231,7 +2231,7 @@ interface IWineD3DResource : IWineD3DBase
interface IWineD3DRendertargetView : IWineD3DBase interface IWineD3DRendertargetView : IWineD3DBase
{ {
HRESULT GetResource( HRESULT GetResource(
[out] IWineD3DResource **resource [out] struct wined3d_resource **resource
); );
} }
@ -2242,6 +2242,8 @@ interface IWineD3DRendertargetView : IWineD3DBase
] ]
interface IWineD3DSurface : IWineD3DResource interface IWineD3DSurface : IWineD3DResource
{ {
struct wined3d_resource *GetResource(
);
void GetDesc( void GetDesc(
[out] WINED3DSURFACE_DESC *desc [out] WINED3DSURFACE_DESC *desc
); );
@ -2523,6 +2525,8 @@ interface IWineD3DSwapChain : IWineD3DBase
] ]
interface IWineD3DBuffer : IWineD3DResource interface IWineD3DBuffer : IWineD3DResource
{ {
struct wined3d_resource *GetResource(
);
HRESULT Map( HRESULT Map(
[in] UINT offset, [in] UINT offset,
[in] UINT size, [in] UINT size,
@ -2632,7 +2636,7 @@ interface IWineD3DDevice : IUnknown
[out] IWineD3DSurface **surface [out] IWineD3DSurface **surface
); );
HRESULT CreateRendertargetView( HRESULT CreateRendertargetView(
[in] IWineD3DResource *resource, [in] struct wined3d_resource *resource,
[in] void *parent, [in] void *parent,
[out] IWineD3DRendertargetView **rendertarget_view [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); ULONG __cdecl wined3d_query_incref(struct wined3d_query *query);
HRESULT __cdecl wined3d_query_issue(struct wined3d_query *query, DWORD flags); 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_apply(const struct wined3d_stateblock *stateblock);
HRESULT __cdecl wined3d_stateblock_capture(struct wined3d_stateblock *stateblock); HRESULT __cdecl wined3d_stateblock_capture(struct wined3d_stateblock *stateblock);
ULONG __cdecl wined3d_stateblock_decref(struct wined3d_stateblock *stateblock); ULONG __cdecl wined3d_stateblock_decref(struct wined3d_stateblock *stateblock);