static HRESULT wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view,
const struct wined3d_view_desc *desc, struct wined3d_resource *resource,
void *parent, const struct wined3d_parent_ops *parent_ops)
{
BOOL allow_srgb_toggle = FALSE;
view->refcount = 1;
view->parent = parent;
view->parent_ops = parent_ops;
if (resource->type != WINED3D_RTYPE_BUFFER)
{
struct wined3d_texture *texture = texture_from_resource(resource);
if (texture->swapchain)
allow_srgb_toggle = TRUE;
}
if (!(view->format = validate_resource_view(desc, resource, TRUE, allow_srgb_toggle)))
return E_INVALIDARG;
view->format_flags = view->format->flags[resource->gl_type];
view->desc = *desc;
if (resource->type == WINED3D_RTYPE_BUFFER)
{
view->sub_resource_idx = 0;
view->layer_count = 1;
view->width = desc->u.buffer.count;
view->height = 1;
}
else
{
struct wined3d_texture *texture = texture_from_resource(resource);
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->layer_count = desc->u.texture.layer_count;
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);
}
wined3d_resource_incref(view->resource = resource);
wined3d_cs_init_object(resource->device->cs, wined3d_render_target_view_cs_init, view);
return WINED3D_OK;
}
static void wined3d_shader_resource_view_cs_init(void *object)
{
struct wined3d_shader_resource_view *view = object;
struct wined3d_resource *resource = view->resource;
const struct wined3d_format *view_format;
const struct wined3d_gl_info *gl_info;
const struct wined3d_view_desc *desc;
GLenum view_target;
view_format = view->format;
gl_info = &resource->device->adapter->gl_info;
desc = &view->desc;
if (resource->type == WINED3D_RTYPE_BUFFER)
{
struct wined3d_buffer *buffer = buffer_from_resource(resource);
struct wined3d_context *context;
context = context_acquire(resource->device, NULL, 0);
create_buffer_view(&view->gl_view, context, desc, buffer, view_format);
context_release(context);
}
else
{
struct wined3d_texture *texture = texture_from_resource(resource);
view_target = get_texture_view_target(gl_info, desc, texture);
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
&& !is_stencil_view_format(view_format))
{
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)
{
create_texture_view(&view->gl_view, view_target, desc, texture, view_format);
}
else if (wined3d_format_is_depth_view(resource->format->id, view_format->id))
{
create_texture_view(&view->gl_view, view_target, desc, texture, resource->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_release(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 (wined3d_format_is_typeless(view->format))
{
WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view->format->id));
return E_INVALIDARG;
}
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
|| desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx)
return E_INVALIDARG;
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;
}
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;
}
static void wined3d_unordered_access_view_cs_init(void *object)
{
struct wined3d_unordered_access_view *view = object;
struct wined3d_resource *resource = view->resource;
struct wined3d_view_desc *desc = &view->desc;
const struct wined3d_gl_info *gl_info;
gl_info = &resource->device->adapter->gl_info;
if (resource->type == WINED3D_RTYPE_BUFFER)
{
struct wined3d_buffer *buffer = buffer_from_resource(resource);
struct wined3d_context *context;
context = context_acquire(resource->device, NULL, 0);
gl_info = context->gl_info;
create_buffer_view(&view->gl_view, context, desc, buffer, view->format);
if (desc->flags & (WINED3D_VIEW_BUFFER_COUNTER | WINED3D_VIEW_BUFFER_APPEND))
{
static const GLuint initial_value = 0;
GL_EXTCALL(glGenBuffers(1, &view->counter_bo));
GL_EXTCALL(glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, view->counter_bo));
GL_EXTCALL(glBufferData(GL_ATOMIC_COUNTER_BUFFER,
sizeof(initial_value), &initial_value, GL_STATIC_DRAW));
checkGLcall("create atomic counter buffer");
}
context_release(context);
}
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.layer_idx || desc->u.texture.layer_count != depth_or_layer_count)
{
create_texture_view(&view->gl_view, get_texture_view_target(gl_info, desc, texture),
desc, texture, view->format);
}
}
wined3d_resource_release(resource);
}
void wined3d_rendertarget_view_validate_location(struct wined3d_rendertarget_view *view, DWORD location)
{
struct wined3d_resource *resource = view->resource;
unsigned int i, sub_resource_idx, layer_count;
struct wined3d_texture *texture;
if (resource->type == WINED3D_RTYPE_BUFFER)
{
FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
return;
}
texture = texture_from_resource(resource);
sub_resource_idx = view->sub_resource_idx;
layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
wined3d_texture_validate_location(texture, sub_resource_idx, location);
}
void wined3d_rendertarget_view_load_location(struct wined3d_rendertarget_view *view,
struct wined3d_context *context, DWORD location)
{
struct wined3d_resource *resource = view->resource;
unsigned int i, sub_resource_idx, layer_count;
struct wined3d_texture *texture;
if (resource->type == WINED3D_RTYPE_BUFFER)
{
wined3d_buffer_load_location(buffer_from_resource(resource), context, location);
return;
}
texture = texture_from_resource(resource);
sub_resource_idx = view->sub_resource_idx;
layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? view->layer_count : 1;
for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
wined3d_texture_load_location(texture, sub_resource_idx, context, location);
}
static void wined3d_view_invalidate_location(struct wined3d_resource *resource,
const struct wined3d_view_desc *desc, DWORD location)
{
unsigned int i, sub_resource_idx, layer_count;
struct wined3d_texture *texture;
if (resource->type == WINED3D_RTYPE_BUFFER)
{
wined3d_buffer_invalidate_location(buffer_from_resource(resource), location);
return;
}
texture = texture_from_resource(resource);
sub_resource_idx = desc->u.texture.layer_idx * texture->level_count + desc->u.texture.level_idx;
layer_count = resource->type != WINED3D_RTYPE_TEXTURE_3D ? desc->u.texture.layer_count : 1;
for (i = 0; i < layer_count; ++i, sub_resource_idx += texture->level_count)
wined3d_texture_invalidate_location(texture, sub_resource_idx, location);
}
BOOL wined3d_resource_is_offscreen(struct wined3d_resource *resource)
{
struct wined3d_swapchain *swapchain;
/* Only 2D texture resources can be onscreen. */
if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
return TRUE;
/* Not on a swapchain - must be offscreen */
if (!(swapchain = texture_from_resource(resource)->swapchain))
return TRUE;
/* The front buffer is always onscreen */
if (resource == &swapchain->front_buffer->resource)
return FALSE;
/* If the swapchain is rendered to an FBO, the backbuffer is
* offscreen, otherwise onscreen */
return swapchain->render_to_fbo;
}
void wined3d_rendertarget_view_get_drawable_size(const struct wined3d_rendertarget_view *view,
const struct wined3d_context *context, unsigned int *width, unsigned int *height)
{
const struct wined3d_texture *texture;
if (view->resource->type != WINED3D_RTYPE_TEXTURE_2D)
{
*width = view->width;
*height = view->height;
return;
}
texture = texture_from_resource(view->resource);
if (texture->swapchain)
{
/* The drawable size of an onscreen drawable is the surface size.
* (Actually: The window size, but the surface is created in window
* size.) */
*width = texture->resource.width;
*height = texture->resource.height;
}
else if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
{
const struct wined3d_swapchain *swapchain = context->swapchain;
/* The drawable size of a backbuffer / aux buffer offscreen target is
* the size of the current context's drawable, which is the size of
* the back buffer of the swapchain the active context belongs to. */
*width = swapchain->desc.backbuffer_width;
*height = swapchain->desc.backbuffer_height;
}
else
{
unsigned int level_idx = view->sub_resource_idx % texture->level_count;
/* The drawable size of an FBO target is the OpenGL texture size,
* which is the power of two size. */
*width = wined3d_texture_get_level_pow2_width(texture, level_idx);
*height = wined3d_texture_get_level_pow2_height(texture, level_idx);
}
}
void CDECL wined3d_shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view)
{
struct wined3d_texture *texture;
TRACE("view %p.\n", view);
if (view->resource->type == WINED3D_RTYPE_BUFFER)
{
WARN("Called on buffer resource %p.\n", view->resource);
return;
}
texture = texture_from_resource(view->resource);
if (!(texture->flags & WINED3D_TEXTURE_GENERATE_MIPMAPS))
{
WARN("Texture without the WINED3D_TEXTURE_GENERATE_MIPMAPS flag, ignoring.\n");
return;
}
wined3d_cs_emit_generate_mipmaps(view->resource->device->cs, view);
}
static void wined3d_render_target_view_cs_init(void *object)
{
struct wined3d_rendertarget_view *view = object;
struct wined3d_resource *resource = view->resource;
const struct wined3d_view_desc *desc = &view->desc;
if (resource->type == WINED3D_RTYPE_BUFFER)
{
FIXME("Not implemented for resources %s.\n", debug_d3dresourcetype(resource->type));
}
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 (resource->format->id != view->format->id
|| (view->layer_count != 1 && view->layer_count != depth_or_layer_count))
{
if (resource->format->gl_view_class != view->format->gl_view_class)
{
FIXME("Render target view not supported, resource format %s, view format %s.\n",
debug_d3dformat(resource->format->id), debug_d3dformat(view->format->id));
return;
}
if (texture->swapchain && texture->swapchain->desc.backbuffer_count > 1)
{
FIXME("Swapchain views not supported.\n");
return;
}
create_texture_view(&view->gl_view, texture->target, desc, texture, view->format);
}
}
}
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);
if (desc->u.texture.level_idx >= texture->level_count
|| desc->u.texture.layer_idx >= texture->layer_count
|| desc->u.texture.layer_count > texture->layer_count - desc->u.texture.layer_idx)
return WINED3DERR_INVALIDCALL;
view->sub_resource_idx = desc->u.texture.layer_idx * texture->level_count + desc->u.texture.level_idx;
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;
}
static HRESULT wined3d_unordered_access_view_init(struct wined3d_unordered_access_view *view,
const struct wined3d_unordered_access_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);
if (wined3d_format_is_typeless(view->format))
{
WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view->format->id));
return E_INVALIDARG;
}
if (resource->type != WINED3D_RTYPE_BUFFER)
{
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
|| desc->u.texture.layer_count > depth_or_layer_count - desc->u.texture.layer_idx)
return E_INVALIDARG;
}
wined3d_resource_incref(view->resource = resource);
return WINED3D_OK;
}
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_1D, 0, GL_TEXTURE_1D},
{GL_TEXTURE_1D, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_1D_ARRAY},
{GL_TEXTURE_1D_ARRAY, 0, GL_TEXTURE_1D},
{GL_TEXTURE_1D_ARRAY, WINED3D_VIEW_TEXTURE_ARRAY, GL_TEXTURE_1D_ARRAY},
{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 (wined3d_format_is_typeless(view_format))
{
WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(view_format->id));
return E_INVALIDARG;
}
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_count
|| 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_count
|| desc->u.texture.layer_idx >= texture->layer_count
|| desc->u.texture.layer_count > texture->layer_count - desc->u.texture.layer_idx)
return E_INVALIDARG;
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;
}
void shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view)
{
struct wined3d_texture *texture = texture_from_resource(view->resource);
unsigned int i, j, layer_count, level_count, base_level, max_level;
const struct wined3d_gl_info *gl_info;
struct wined3d_context *context;
struct gl_texture *gl_tex;
DWORD location;
BOOL srgb;
TRACE("view %p.\n", view);
context = context_acquire(view->resource->device, NULL, 0);
gl_info = context->gl_info;
layer_count = view->desc.u.texture.layer_count;
level_count = view->desc.u.texture.level_count;
base_level = view->desc.u.texture.level_idx;
max_level = base_level + level_count - 1;
srgb = !!(texture->flags & WINED3D_TEXTURE_IS_SRGB);
location = srgb ? WINED3D_LOCATION_TEXTURE_SRGB : WINED3D_LOCATION_TEXTURE_RGB;
for (i = 0; i < layer_count; ++i)
wined3d_texture_load_location(texture, i * level_count + base_level, context, location);
if (view->gl_view.name)
{
shader_resource_view_bind_and_dirtify(view, context);
}
else
{
wined3d_texture_bind_and_dirtify(texture, context, srgb);
gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, base_level);
gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, max_level);
}
if (gl_info->supported[ARB_SAMPLER_OBJECTS])
GL_EXTCALL(glBindSampler(context->active_texture, 0));
gl_tex = wined3d_texture_get_gl_texture(texture, srgb);
if (context->d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
{
gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_SRGB_DECODE_EXT,
GL_SKIP_DECODE_EXT);
gl_tex->sampler_desc.srgb_decode = FALSE;
}
gl_info->fbo_ops.glGenerateMipmap(texture->target);
checkGLcall("glGenerateMipMap()");
for (i = 0; i < layer_count; ++i)
{
for (j = base_level + 1; j <= max_level; ++j)
{
wined3d_texture_validate_location(texture, i * level_count + j, location);
wined3d_texture_invalidate_location(texture, i * level_count + j, ~location);
}
}
if (!view->gl_view.name)
{
gl_tex->base_level = base_level;
gl_info->gl_ops.gl.p_glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, texture->level_count - 1);
}
context_release(context);
}
static const struct wined3d_format *validate_resource_view(const struct wined3d_view_desc *desc,
struct wined3d_resource *resource, BOOL mip_slice, BOOL allow_srgb_toggle)
{
const struct wined3d_gl_info *gl_info = &resource->device->adapter->gl_info;
const struct wined3d_format *format;
format = wined3d_get_format(gl_info, desc->format_id, resource->usage);
if (resource->type == WINED3D_RTYPE_BUFFER && (desc->flags & WINED3D_VIEW_BUFFER_RAW))
{
if (format->id != WINED3DFMT_R32_TYPELESS)
{
WARN("Invalid format %s for raw buffer view.\n", debug_d3dformat(format->id));
return NULL;
}
format = wined3d_get_format(gl_info, WINED3DFMT_R32_UINT, resource->usage);
}
if (wined3d_format_is_typeless(format))
{
WARN("Trying to create view for typeless format %s.\n", debug_d3dformat(format->id));
return NULL;
}
if (resource->type == WINED3D_RTYPE_BUFFER)
{
struct wined3d_buffer *buffer = buffer_from_resource(resource);
unsigned int buffer_size, element_size;
if (buffer->desc.structure_byte_stride)
{
if (desc->format_id != WINED3DFMT_UNKNOWN)
{
WARN("Invalid format %s for structured buffer view.\n", debug_d3dformat(desc->format_id));
return NULL;
}
format = wined3d_get_format(gl_info, WINED3DFMT_R32_UINT, resource->usage);
element_size = buffer->desc.structure_byte_stride;
}
else
{
element_size = format->byte_count;
}
if (!element_size)
return NULL;
buffer_size = buffer->resource.size / element_size;
if (desc->u.buffer.start_idx >= buffer_size
|| desc->u.buffer.count > buffer_size - desc->u.buffer.start_idx)
return NULL;
}
else
{
struct wined3d_texture *texture = texture_from_resource(resource);
unsigned int depth_or_layer_count;
if (resource->format->id != format->id && !wined3d_format_is_typeless(resource->format)
&& (!allow_srgb_toggle || !wined3d_formats_are_srgb_variants(resource->format->id, format->id)))
{
WARN("Trying to create incompatible view for non typeless format %s.\n",
debug_d3dformat(format->id));
return NULL;
}
if (mip_slice && 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_count
|| (mip_slice && desc->u.texture.level_count != 1)
|| 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_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 NULL;
}
return format;
}