dlls/wined3d/view.c

   1 /*
   2  * Copyright 2009, 2011 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include "wined3d_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  26
  27 ULONG CDECL wined3d_rendertarget_view_incref(struct wined3d_rendertarget_view *view)
  28 {
  29     ULONG refcount = InterlockedIncrement(&view->refcount);
  30
  31     TRACE("%p increasing refcount to %u.\n", view, refcount);
  32
  33     return refcount;
  34 }
  35
  36 ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *view)
  37 {
  38     ULONG refcount = InterlockedDecrement(&view->refcount);
  39
  40     TRACE("%p decreasing refcount to %u.\n", view, refcount);
  41
  42     if (!refcount)
  43     {
  44         /* Call wined3d_object_destroyed() before releasing the resource,
  45          * since releasing the resource may end up destroying the parent. */
  46         view->parent_ops->wined3d_object_destroyed(view->parent);
  47         wined3d_resource_decref(view->resource);
  48         HeapFree(GetProcessHeap(), 0, view);
  49     }
  50
  51     return refcount;
  52 }
  53
  54 void * CDECL wined3d_rendertarget_view_get_parent(const struct wined3d_rendertarget_view *view)
  55 {
  56     TRACE("view %p.\n", view);
  57
  58     return view->parent;
  59 }
  60
  61 void * CDECL wined3d_rendertarget_view_get_sub_resource_parent(const struct wined3d_rendertarget_view *view)
  62 {
  63     struct wined3d_texture *texture;
  64
  65     TRACE("view %p.\n", view);
  66
  67     if (view->resource->type == WINED3D_RTYPE_BUFFER)
  68         return wined3d_buffer_get_parent(buffer_from_resource(view->resource));
  69
  70     texture = texture_from_resource(view->resource);
  71
  72     return wined3d_resource_get_parent(texture->sub_resources[view->sub_resource_idx].resource);
  73 }
  74
  75 void CDECL wined3d_rendertarget_view_set_parent(struct wined3d_rendertarget_view *view, void *parent)
  76 {
  77     TRACE("view %p, parent %p.\n", view, parent);
  78
  79     view->parent = parent;
  80 }
  81
  82 struct wined3d_resource * CDECL wined3d_rendertarget_view_get_resource(const struct wined3d_rendertarget_view *view)
  83 {
  84     TRACE("view %p.\n", view);
  85
  86     return view->resource;
  87 }
  88
  89 static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view,
  90         const struct wined3d_rendertarget_view_desc *desc, struct wined3d_resource *resource,
  91         void *parent, const struct wined3d_parent_ops *parent_ops)
  92 {
  93     const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
  94
  95     view->refcount = 1;
  96     view->parent = parent;
  97     view->parent_ops = parent_ops;
  98
  99     view->format = wined3d_get_format(gl_info, desc->format_id);
 100     view->format_flags = view->format->flags[resource->gl_type];
 101     if (resource->type == WINED3D_RTYPE_BUFFER)
 102     {
 103         view->sub_resource_idx = 0;
 104         view->buffer_offset = desc->u.buffer.start_idx;
 105         view->width = desc->u.buffer.count;
 106         view->height = 1;
 107         view->depth = 1;
 108     }
 109     else
 110     {
 111         struct wined3d_texture *texture = texture_from_resource(resource);
 112
 113         if (desc->u.texture.level_idx >= texture->level_count
 114                 || desc->u.texture.layer_idx >= texture->layer_count
 115                 || desc->u.texture.layer_count > texture->layer_count - desc->u.texture.layer_idx)
 116             return WINED3DERR_INVALIDCALL;
 117         view->sub_resource_idx = desc->u.texture.layer_idx * texture->level_count + desc->u.texture.level_idx;
 118         view->buffer_offset = 0;
 119         view->width = wined3d_texture_get_level_width(texture, desc->u.texture.level_idx);
 120         view->height = wined3d_texture_get_level_height(texture, desc->u.texture.level_idx);
 121         view->depth = desc->u.texture.layer_count;
 122     }
 123     wined3d_resource_incref(view->resource = resource);
 124
 125     return WINED3D_OK;
 126 }
 127
 128 HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_rendertarget_view_desc *desc,
 129         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
 130         struct wined3d_rendertarget_view **view)
 131 {
 132     struct wined3d_rendertarget_view *object;
 133     HRESULT hr;
 134
 135     TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n",
 136             desc, resource, parent, parent_ops, view);
 137
 138     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 139         return E_OUTOFMEMORY;
 140
 141     if (FAILED(hr = wined3d_rendertarget_view_init(object, desc, resource, parent, parent_ops)))
 142     {
 143         HeapFree(GetProcessHeap(), 0, object);
 144         WARN("Failed to initialise view, hr %#x.\n", hr);
 145         return hr;
 146     }
 147
 148     TRACE("Created render target view %p.\n", object);
 149     *view = object;
 150
 151     return hr;
 152 }
 153
 154 HRESULT CDECL wined3d_rendertarget_view_create_from_sub_resource(struct wined3d_texture *texture,
 155         unsigned int sub_resource_idx, void *parent, const struct wined3d_parent_ops *parent_ops,
 156         struct wined3d_rendertarget_view **view)
 157 {
 158     struct wined3d_rendertarget_view_desc desc;
 159
 160     TRACE("texture %p, sub_resource_idx %u, parent %p, parent_ops %p, view %p.\n",
 161             texture, sub_resource_idx, parent, parent_ops, view);
 162
 163     desc.format_id = texture->resource.format->id;
 164     desc.u.texture.level_idx = sub_resource_idx % texture->level_count;
 165     desc.u.texture.layer_idx = sub_resource_idx / texture->level_count;
 166     desc.u.texture.layer_count = 1;
 167
 168     return wined3d_rendertarget_view_create(&desc, &texture->resource, parent, parent_ops, view);
 169 }
 170
 171 ULONG CDECL wined3d_shader_resource_view_incref(struct wined3d_shader_resource_view *view)
 172 {
 173     ULONG refcount = InterlockedIncrement(&view->refcount);
 174
 175     TRACE("%p increasing refcount to %u.\n", view, refcount);
 176
 177     return refcount;
 178 }
 179
 180 ULONG CDECL wined3d_shader_resource_view_decref(struct wined3d_shader_resource_view *view)
 181 {
 182     ULONG refcount = InterlockedDecrement(&view->refcount);
 183
 184     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 185
 186     if (!refcount)
 187     {
 188         /* Call wined3d_object_destroyed() before releasing the resource,
 189          * since releasing the resource may end up destroying the parent. */
 190         view->parent_ops->wined3d_object_destroyed(view->parent);
 191         wined3d_resource_decref(view->resource);
 192         HeapFree(GetProcessHeap(), 0, view);
 193     }
 194
 195     return refcount;
 196 }
 197
 198 void * CDECL wined3d_shader_resource_view_get_parent(const struct wined3d_shader_resource_view *view)
 199 {
 200     TRACE("view %p.\n", view);
 201
 202     return view->parent;
 203 }
 204
 205 HRESULT CDECL wined3d_shader_resource_view_create(struct wined3d_resource *resource, void *parent,
 206         const struct wined3d_parent_ops *parent_ops, struct wined3d_shader_resource_view **view)
 207 {
 208     struct wined3d_shader_resource_view *object;
 209
 210     TRACE("resource %p, parent %p, parent_ops %p, view %p.\n", resource, parent, parent_ops, view);
 211
 212     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 213         return E_OUTOFMEMORY;
 214
 215     object->refcount = 1;
 216     object->resource = resource;
 217     wined3d_resource_incref(resource);
 218     object->parent = parent;
 219     object->parent_ops = parent_ops;
 220
 221     TRACE("Created shader resource view %p.\n", object);
 222     *view = object;
 223
 224     return WINED3D_OK;
 225 }