| /* |
| * Copyright 2009, 2011 Henri Verbeet for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| * |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include "wined3d_private.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(d3d); |
| |
| ULONG CDECL wined3d_rendertarget_view_incref(struct wined3d_rendertarget_view *view) |
| { |
| ULONG refcount = InterlockedIncrement(&view->refcount); |
| |
| TRACE("%p increasing refcount to %u.\n", view, refcount); |
| |
| return refcount; |
| } |
| |
| ULONG CDECL wined3d_rendertarget_view_decref(struct wined3d_rendertarget_view *view) |
| { |
| ULONG refcount = InterlockedDecrement(&view->refcount); |
| |
| TRACE("%p decreasing refcount to %u.\n", view, refcount); |
| |
| if (!refcount) |
| { |
| /* Call wined3d_object_destroyed() before releasing the resource, |
| * since releasing the resource may end up destroying the parent. */ |
| view->parent_ops->wined3d_object_destroyed(view->parent); |
| wined3d_resource_decref(view->resource); |
| HeapFree(GetProcessHeap(), 0, view); |
| } |
| |
| return refcount; |
| } |
| |
| void * CDECL wined3d_rendertarget_view_get_parent(const struct wined3d_rendertarget_view *view) |
| { |
| TRACE("view %p.\n", view); |
| |
| return view->parent; |
| } |
| |
| void * CDECL wined3d_rendertarget_view_get_sub_resource_parent(const struct wined3d_rendertarget_view *view) |
| { |
| struct wined3d_texture *texture; |
| |
| TRACE("view %p.\n", view); |
| |
| if (view->resource->type == WINED3D_RTYPE_BUFFER) |
| return wined3d_buffer_get_parent(buffer_from_resource(view->resource)); |
| |
| texture = texture_from_resource(view->resource); |
| |
| return texture->sub_resources[view->sub_resource_idx].parent; |
| } |
| |
| void CDECL wined3d_rendertarget_view_set_parent(struct wined3d_rendertarget_view *view, void *parent) |
| { |
| TRACE("view %p, parent %p.\n", view, parent); |
| |
| view->parent = parent; |
| } |
| |
| struct wined3d_resource * CDECL wined3d_rendertarget_view_get_resource(const struct wined3d_rendertarget_view *view) |
| { |
| TRACE("view %p.\n", view); |
| |
| return view->resource; |
| } |
| |
| static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view, |
| const struct wined3d_rendertarget_view_desc *desc, struct wined3d_resource *resource, |
| void *parent, const struct wined3d_parent_ops *parent_ops) |
| { |
| const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info; |
| |
| view->refcount = 1; |
| view->parent = parent; |
| view->parent_ops = parent_ops; |
| |
| view->format = wined3d_get_format(gl_info, desc->format_id); |
| view->format_flags = view->format->flags[resource->gl_type]; |
| if (resource->type == WINED3D_RTYPE_BUFFER) |
| { |
| view->sub_resource_idx = 0; |
| view->buffer_offset = desc->u.buffer.start_idx; |
| view->width = desc->u.buffer.count; |
| view->height = 1; |
| view->depth = 1; |
| } |
| else |
| { |
| struct wined3d_texture *texture = texture_from_resource(resource); |
| unsigned int depth_or_layer_count; |
| |
| if (resource->type == WINED3D_RTYPE_TEXTURE_3D) |
| depth_or_layer_count = wined3d_texture_get_level_depth(texture, desc->u.texture.level_idx); |
| else |
| depth_or_layer_count = texture->layer_count; |
| |
| if (desc->u.texture.level_idx >= texture->level_count |
| || desc->u.texture.layer_idx >= depth_or_layer_count |
| || desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx) |
| return WINED3DERR_INVALIDCALL; |
| |
| view->sub_resource_idx = desc->u.texture.level_idx; |
| if (resource->type != WINED3D_RTYPE_TEXTURE_3D) |
| view->sub_resource_idx += desc->u.texture.layer_idx * texture->level_count; |
| view->buffer_offset = 0; |
| view->width = wined3d_texture_get_level_width(texture, desc->u.texture.level_idx); |
| view->height = wined3d_texture_get_level_height(texture, desc->u.texture.level_idx); |
| view->depth = desc->u.texture.layer_count; |
| } |
| wined3d_resource_incref(view->resource = resource); |
| |
| return WINED3D_OK; |
| } |
| |
| HRESULT CDECL wined3d_rendertarget_view_create(const struct wined3d_rendertarget_view_desc *desc, |
| struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops, |
| struct wined3d_rendertarget_view **view) |
| { |
| struct wined3d_rendertarget_view *object; |
| HRESULT hr; |
| |
| TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n", |
| desc, resource, parent, parent_ops, view); |
| |
| if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) |
| return E_OUTOFMEMORY; |
| |
| if (FAILED(hr = wined3d_rendertarget_view_init(object, desc, resource, parent, parent_ops))) |
| { |
| HeapFree(GetProcessHeap(), 0, object); |
| WARN("Failed to initialise view, hr %#x.\n", hr); |
| return hr; |
| } |
| |
| TRACE("Created render target view %p.\n", object); |
| *view = object; |
| |
| return hr; |
| } |
| |
| HRESULT CDECL wined3d_rendertarget_view_create_from_sub_resource(struct wined3d_texture *texture, |
| unsigned int sub_resource_idx, void *parent, const struct wined3d_parent_ops *parent_ops, |
| struct wined3d_rendertarget_view **view) |
| { |
| struct wined3d_rendertarget_view_desc desc; |
| |
| TRACE("texture %p, sub_resource_idx %u, parent %p, parent_ops %p, view %p.\n", |
| texture, sub_resource_idx, parent, parent_ops, view); |
| |
| desc.format_id = texture->resource.format->id; |
| desc.u.texture.level_idx = sub_resource_idx % texture->level_count; |
| desc.u.texture.layer_idx = sub_resource_idx / texture->level_count; |
| desc.u.texture.layer_count = 1; |
| |
| return wined3d_rendertarget_view_create(&desc, &texture->resource, parent, parent_ops, view); |
| } |
| |
| ULONG CDECL wined3d_shader_resource_view_incref(struct wined3d_shader_resource_view *view) |
| { |
| ULONG refcount = InterlockedIncrement(&view->refcount); |
| |
| TRACE("%p increasing refcount to %u.\n", view, refcount); |
| |
| return refcount; |
| } |
| |
| ULONG CDECL wined3d_shader_resource_view_decref(struct wined3d_shader_resource_view *view) |
| { |
| ULONG refcount = InterlockedDecrement(&view->refcount); |
| |
| TRACE("%p decreasing refcount to %u.\n", view, refcount); |
| |
| if (!refcount) |
| { |
| if (view->object) |
| { |
| const struct wined3d_gl_info *gl_info; |
| struct wined3d_context *context; |
| |
| context = context_acquire(view->resource->device, NULL); |
| gl_info = context->gl_info; |
| gl_info->gl_ops.gl.p_glDeleteTextures(1, &view->object); |
| checkGLcall("glDeleteTextures"); |
| context_release(context); |
| } |
| /* Call wined3d_object_destroyed() before releasing the resource, |
| * since releasing the resource may end up destroying the parent. */ |
| view->parent_ops->wined3d_object_destroyed(view->parent); |
| wined3d_resource_decref(view->resource); |
| HeapFree(GetProcessHeap(), 0, view); |
| } |
| |
| return refcount; |
| } |
| |
| void * CDECL wined3d_shader_resource_view_get_parent(const struct wined3d_shader_resource_view *view) |
| { |
| TRACE("view %p.\n", view); |
| |
| return view->parent; |
| } |
| |
| static void wined3d_shader_resource_view_create_texture_view(struct wined3d_shader_resource_view *view, |
| const struct wined3d_shader_resource_view_desc *desc, struct wined3d_texture *texture, |
| const struct wined3d_format *view_format) |
| { |
| const struct wined3d_gl_info *gl_info; |
| struct wined3d_context *context; |
| struct gl_texture *gl_texture; |
| |
| context = context_acquire(texture->resource.device, NULL); |
| gl_info = context->gl_info; |
| |
| if (!gl_info->supported[ARB_TEXTURE_VIEW]) |
| { |
| context_release(context); |
| FIXME("OpenGL implementation does not support texture views.\n"); |
| return; |
| } |
| |
| wined3d_texture_prepare_texture(texture, context, FALSE); |
| gl_texture = wined3d_texture_get_gl_texture(texture, FALSE); |
| |
| gl_info->gl_ops.gl.p_glGenTextures(1, &view->object); |
| GL_EXTCALL(glTextureView(view->object, view->target, gl_texture->name, view_format->glInternal, |
| desc->u.texture.level_idx, desc->u.texture.level_count, |
| desc->u.texture.layer_idx, desc->u.texture.layer_count)); |
| checkGLcall("Create texture view"); |
| |
| context_release(context); |
| } |
| |
| static HRESULT wined3d_shader_resource_view_init(struct wined3d_shader_resource_view *view, |
| const struct wined3d_shader_resource_view_desc *desc, struct wined3d_resource *resource, |
| void *parent, const struct wined3d_parent_ops *parent_ops) |
| { |
| static const struct |
| { |
| GLenum texture_target; |
| unsigned int view_flags; |
| GLenum view_target; |
| } |
| view_types[] = |
| { |
| {GL_TEXTURE_2D, 0, GL_TEXTURE_2D}, |
| {GL_TEXTURE_2D, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY}, |
| {GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_2D}, |
| {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_2D_ARRAY}, |
| {GL_TEXTURE_2D_ARRAY, WINED3D_VIEW_TEXTURE_CUBE, GL_TEXTURE_CUBE_MAP}, |
| {GL_TEXTURE_3D, 0, GL_TEXTURE_3D}, |
| }; |
| |
| const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info; |
| const struct wined3d_format *view_format; |
| |
| view_format = wined3d_get_format(gl_info, desc->format_id); |
| if (view_format->id == view_format->typeless_id) |
| { |
| WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view_format->id)); |
| return E_FAIL; |
| } |
| |
| view->refcount = 1; |
| view->parent = parent; |
| view->parent_ops = parent_ops; |
| |
| view->target = GL_NONE; |
| view->object = 0; |
| |
| if (resource->type == WINED3D_RTYPE_BUFFER) |
| { |
| FIXME("Buffer shader resource views not supported.\n"); |
| } |
| else |
| { |
| struct wined3d_texture *texture = texture_from_resource(resource); |
| unsigned int i; |
| |
| if (desc->u.texture.level_idx >= texture->level_count |
| || desc->u.texture.level_count > texture->level_count - desc->u.texture.level_idx |
| || desc->u.texture.layer_idx >= texture->layer_count |
| || desc->u.texture.layer_count > texture->layer_count - desc->u.texture.layer_idx) |
| return E_FAIL; |
| |
| view->target = texture->target; |
| for (i = 0; i < ARRAY_SIZE(view_types); ++i) |
| { |
| if (view_types[i].texture_target == texture->target && view_types[i].view_flags == desc->flags) |
| { |
| view->target = view_types[i].view_target; |
| break; |
| } |
| } |
| if (i == ARRAY_SIZE(view_types)) |
| FIXME("Unhandled view flags %#x for texture target %#x.\n", desc->flags, texture->target); |
| |
| if (resource->format->id == view_format->id && texture->target == view->target |
| && !desc->u.texture.level_idx && desc->u.texture.level_count == texture->level_count |
| && !desc->u.texture.layer_idx && desc->u.texture.layer_count == texture->layer_count) |
| { |
| TRACE("Creating identity shader resource view.\n"); |
| } |
| else if (texture->swapchain && texture->swapchain->desc.backbuffer_count > 1) |
| { |
| FIXME("Swapchain shader resource views not supported.\n"); |
| } |
| else if (resource->format->typeless_id == view_format->typeless_id |
| && resource->format->gl_view_class == view_format->gl_view_class) |
| { |
| wined3d_shader_resource_view_create_texture_view(view, desc, texture, view_format); |
| } |
| else |
| { |
| FIXME("Shader resource view not supported, resource format %s, view format %s.\n", |
| debug_d3dformat(resource->format->id), debug_d3dformat(view_format->id)); |
| } |
| } |
| wined3d_resource_incref(view->resource = resource); |
| |
| return WINED3D_OK; |
| } |
| |
| HRESULT CDECL wined3d_shader_resource_view_create(const struct wined3d_shader_resource_view_desc *desc, |
| struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops, |
| struct wined3d_shader_resource_view **view) |
| { |
| struct wined3d_shader_resource_view *object; |
| HRESULT hr; |
| |
| TRACE("desc %p, resource %p, parent %p, parent_ops %p, view %p.\n", |
| desc, resource, parent, parent_ops, view); |
| |
| if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) |
| return E_OUTOFMEMORY; |
| |
| if (FAILED(hr = wined3d_shader_resource_view_init(object, desc, resource, parent, parent_ops))) |
| { |
| HeapFree(GetProcessHeap(), 0, object); |
| WARN("Failed to initialise view, hr %#x.\n", hr); |
| return hr; |
| } |
| |
| TRACE("Created shader resource view %p.\n", object); |
| *view = object; |
| |
| return WINED3D_OK; |
| } |
| |
| void wined3d_shader_resource_view_bind(struct wined3d_shader_resource_view *view, |
| struct wined3d_context *context) |
| { |
| struct wined3d_texture *texture; |
| |
| if (view->object) |
| { |
| context_bind_texture(context, view->target, view->object); |
| return; |
| } |
| |
| if (view->resource->type == WINED3D_RTYPE_BUFFER) |
| { |
| FIXME("Buffer shader resources not supported.\n"); |
| return; |
| } |
| |
| texture = wined3d_texture_from_resource(view->resource); |
| wined3d_texture_bind(texture, context, FALSE); |
| } |