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; }