resource.c File Reference

#include "wined3d_private.h"
#include "wined3d_gl.h"
#include "wined3d_vk.h"

Include dependency graph for resource.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3d)
	WINE_DECLARE_DEBUG_CHANNEL (d3d_perf)
static void	resource_check_usage (uint32_t usage, unsigned int access)
HRESULT	resource_init (struct wined3d_resource *resource, struct wined3d_device *device, enum wined3d_resource_type type, const struct wined3d_format *format, enum wined3d_multisample_type multisample_type, unsigned int multisample_quality, uint32_t usage, unsigned int bind_flags, unsigned int access, unsigned int width, unsigned int height, unsigned int depth, unsigned int size, void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_resource_ops *resource_ops)
static void	wined3d_resource_destroy_object (void *object)
void	resource_cleanup (struct wined3d_resource *resource)
void	resource_unload (struct wined3d_resource *resource)
unsigned int CDECL	wined3d_resource_set_priority (struct wined3d_resource *resource, unsigned int priority)
unsigned int CDECL	wined3d_resource_get_priority (const struct wined3d_resource *resource)
void *CDECL	wined3d_resource_get_parent (const struct wined3d_resource *resource)
void CDECL	wined3d_resource_set_parent (struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
void CDECL	wined3d_resource_get_desc (const struct wined3d_resource *resource, struct wined3d_resource_desc *desc)
HRESULT CDECL	wined3d_resource_map (struct wined3d_resource *resource, unsigned int sub_resource_idx, struct wined3d_map_desc *map_desc, const struct wined3d_box *box, uint32_t flags)
HRESULT CDECL	wined3d_resource_unmap (struct wined3d_resource *resource, unsigned int sub_resource_idx)
void CDECL	wined3d_resource_preload (struct wined3d_resource *resource)
static BOOL	wined3d_resource_allocate_sysmem (struct wined3d_resource *resource)
BOOL	wined3d_resource_prepare_sysmem (struct wined3d_resource *resource)
void	wined3d_resource_free_sysmem (struct wined3d_resource *resource)
GLbitfield	wined3d_resource_gl_storage_flags (const struct wined3d_resource *resource)
GLbitfield	wined3d_resource_gl_map_flags (const struct wined3d_bo_gl *bo, DWORD d3d_flags)
GLenum	wined3d_resource_gl_legacy_map_flags (DWORD d3d_flags)
BOOL	wined3d_resource_is_offscreen (struct wined3d_resource *resource)
void	wined3d_resource_update_draw_binding (struct wined3d_resource *resource)
const struct wined3d_format *	wined3d_resource_get_decompress_format (const struct wined3d_resource *resource)
unsigned int	wined3d_resource_get_sample_count (const struct wined3d_resource *resource)
HRESULT	wined3d_resource_check_box_dimensions (struct wined3d_resource *resource, unsigned int sub_resource_idx, const struct wined3d_box *box)
VkAccessFlags	vk_access_mask_from_bind_flags (uint32_t bind_flags)
VkPipelineStageFlags	vk_pipeline_stage_mask_from_bind_flags (uint32_t bind_flags)
void *	resource_offset_map_pointer (struct wined3d_resource *resource, unsigned int sub_resource_idx, uint8_t *base_memory, const struct wined3d_box *box)
void	wined3d_resource_memory_colour_fill (struct wined3d_resource *resource, const struct wined3d_map_desc *map, const struct wined3d_color *colour, const struct wined3d_box *box, bool full_subresource)

Function Documentation

resource_check_usage()

static void resource_check_usage ( uint32_t  usage, unsigned int  access  )

static

Definition at line 31 of file resource.c.

{
    static const uint32_t handled = WINED3DUSAGE_DYNAMIC
            | WINED3DUSAGE_STATICDECL
            | WINED3DUSAGE_OVERLAY
            | WINED3DUSAGE_SCRATCH
            | WINED3DUSAGE_MANAGED
            | WINED3DUSAGE_CS
            | WINED3DUSAGE_LEGACY_CUBEMAP
            | ~WINED3DUSAGE_MASK;
 
    /* Write-only CPU access is supposed to result in write-combined mappings
     * being returned. OpenGL doesn't give us explicit control over that, but
     * the hints and access flags we set for typical access patterns on
     * dynamic resources should in theory have the same effect on the OpenGL
     * driver. */
 
    if (usage & ~handled)
        FIXME("Unhandled usage flags %#x.\n", usage & ~handled);
    if (usage & WINED3DUSAGE_DYNAMIC && access & WINED3D_RESOURCE_ACCESS_MAP_R)
        WARN_(d3d_perf)("WINED3DUSAGE_DYNAMIC used with WINED3D_RESOURCE_ACCESS_MAP_R.\n");
}

Referenced by resource_init().

resource_cleanup()

void resource_cleanup

(

struct wined3d_resource *

resource

)

Definition at line 224 of file resource.c.

{
    TRACE("Cleaning up resource %p.\n", resource);
 
    if (!(resource->access & WINED3D_RESOURCE_ACCESS_CPU) && resource->usage & WINED3DUSAGE_VIDMEM_ACCOUNTING)
    {
        TRACE("Decrementing device memory pool by %u.\n", resource->size);
        adapter_adjust_memory(resource->device->adapter, (INT64)0 - resource->size);
    }
 
    if (!(resource->usage & WINED3DUSAGE_CS))
        device_resource_released(resource->device, resource);
 
    wined3d_resource_reference(resource);
    wined3d_cs_destroy_object(resource->device->cs, wined3d_resource_destroy_object, resource);
}

Referenced by wined3d_buffer_cleanup(), wined3d_buffer_init(), and wined3d_texture_cleanup().

resource_init()

HRESULT resource_init	(	struct wined3d_resource *	resource,
		struct wined3d_device *	device,
		enum wined3d_resource_type	type,
		const struct wined3d_format *	format,
		enum wined3d_multisample_type	multisample_type,
		unsigned int	multisample_quality,
		uint32_t	usage,
		unsigned int	bind_flags,
		unsigned int	access,
		unsigned int	width,
		unsigned int	height,
		unsigned int	depth,
		unsigned int	size,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops,
		const struct wined3d_resource_ops *	resource_ops
	)

Definition at line 54 of file resource.c.

{
    enum wined3d_gl_resource_type base_type = WINED3D_GL_RES_TYPE_COUNT;
    enum wined3d_gl_resource_type gl_type = WINED3D_GL_RES_TYPE_COUNT;
    unsigned int i;
 
    static const struct
    {
        enum wined3d_resource_type type;
        DWORD cube_usage;
        enum wined3d_gl_resource_type gl_type;
    }
    resource_types[] =
    {
        {WINED3D_RTYPE_BUFFER,      0,                              WINED3D_GL_RES_TYPE_BUFFER},
        {WINED3D_RTYPE_TEXTURE_1D,  0,                              WINED3D_GL_RES_TYPE_TEX_1D},
        {WINED3D_RTYPE_TEXTURE_2D,  0,                              WINED3D_GL_RES_TYPE_TEX_2D},
        {WINED3D_RTYPE_TEXTURE_2D,  0,                              WINED3D_GL_RES_TYPE_RB},
        {WINED3D_RTYPE_TEXTURE_2D,  WINED3DUSAGE_LEGACY_CUBEMAP,    WINED3D_GL_RES_TYPE_TEX_CUBE},
        {WINED3D_RTYPE_TEXTURE_3D,  0,                              WINED3D_GL_RES_TYPE_TEX_3D},
    };
 
    resource_check_usage(usage, access);
 
    if (usage & WINED3DUSAGE_SCRATCH && access & WINED3D_RESOURCE_ACCESS_GPU)
    {
        ERR("Trying to create a scratch resource with access flags %s.\n",
                wined3d_debug_resource_access(access));
        return WINED3DERR_INVALIDCALL;
    }
 
    if (bind_flags & (WINED3D_BIND_RENDER_TARGET | WINED3D_BIND_DEPTH_STENCIL))
    {
        if ((access & (WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_GPU)) != WINED3D_RESOURCE_ACCESS_GPU)
        {
            WARN("Bind flags %s are incompatible with resource access %s.\n",
                    wined3d_debug_bind_flags(bind_flags), wined3d_debug_resource_access(access));
            return WINED3DERR_INVALIDCALL;
        }
 
        /* Dynamic and managed usages are incompatible with GPU writes. */
        if (usage & (WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_MANAGED))
        {
            WARN("Bind flags %s are incompatible with resource usage %s.\n",
                    wined3d_debug_bind_flags(bind_flags), debug_d3dusage(usage));
            return WINED3DERR_INVALIDCALL;
        }
    }
 
    if (!size)
        ERR("Attempting to create a zero-sized resource.\n");
 
    for (i = 0; i < ARRAY_SIZE(resource_types); ++i)
    {
        if (resource_types[i].type != type
                || resource_types[i].cube_usage != (usage & WINED3DUSAGE_LEGACY_CUBEMAP))
            continue;
 
        gl_type = resource_types[i].gl_type;
        if (base_type == WINED3D_GL_RES_TYPE_COUNT)
            base_type = gl_type;
 
        if (type == WINED3D_RTYPE_BUFFER)
            break;
 
        if ((bind_flags & WINED3D_BIND_RENDER_TARGET)
                && !(format->caps[gl_type] & WINED3D_FORMAT_CAP_RENDERTARGET))
        {
            WARN("Format %s cannot be used for render targets.\n", debug_d3dformat(format->id));
            continue;
        }
        if ((bind_flags & WINED3D_BIND_DEPTH_STENCIL)
                && !(format->caps[gl_type] & WINED3D_FORMAT_CAP_DEPTH_STENCIL))
        {
            WARN("Format %s cannot be used for depth/stencil buffers.\n", debug_d3dformat(format->id));
            continue;
        }
        if ((bind_flags & WINED3D_BIND_SHADER_RESOURCE)
                && !(format->caps[gl_type] & WINED3D_FORMAT_CAP_TEXTURE))
        {
            WARN("Format %s cannot be used for texturing.\n", debug_d3dformat(format->id));
            continue;
        }
        break;
    }
 
    if (base_type != WINED3D_GL_RES_TYPE_COUNT && i == ARRAY_SIZE(resource_types))
    {
        if (usage & WINED3DUSAGE_SCRATCH)
        {
            /* Needed for proper format information. */
            gl_type = base_type;
        }
        else
        {
            WARN("Did not find a suitable GL resource type for resource type %s.\n",
                    debug_d3dresourcetype(type));
            return WINED3DERR_INVALIDCALL;
        }
    }
 
    if (base_type != WINED3D_GL_RES_TYPE_COUNT
            && (format->attrs & (WINED3D_FORMAT_ATTR_BLOCKS | WINED3D_FORMAT_ATTR_BLOCKS_NO_VERIFY))
            == WINED3D_FORMAT_ATTR_BLOCKS)
    {
        UINT width_mask = format->block_width - 1;
        UINT height_mask = format->block_height - 1;
        if (width & width_mask || height & height_mask)
            return WINED3DERR_INVALIDCALL;
    }
 
    resource->ref = 1;
    resource->device = device;
    resource->type = type;
    resource->gl_type = gl_type;
    resource->format = format;
    resource->format_attrs = format->attrs;
    if (gl_type < WINED3D_GL_RES_TYPE_COUNT)
        resource->format_caps = format->caps[gl_type];
    resource->multisample_type = multisample_type;
    resource->multisample_quality = multisample_quality;
    resource->usage = usage;
    resource->bind_flags = bind_flags;
    if (resource->format_attrs & WINED3D_FORMAT_ATTR_MAPPABLE)
        access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    resource->access = access;
    resource->width = width;
    resource->height = height;
    resource->depth = depth;
    resource->size = size;
    resource->priority = 0;
    resource->parent = parent;
    resource->parent_ops = parent_ops;
    resource->resource_ops = resource_ops;
    resource->map_binding = WINED3D_LOCATION_SYSMEM;
    resource->heap_pointer = NULL;
    resource->heap_memory = NULL;
 
    /* Check that we have enough video ram left */
    if (!(access & WINED3D_RESOURCE_ACCESS_CPU) && usage & WINED3DUSAGE_VIDMEM_ACCOUNTING)
    {
        if (size > wined3d_device_get_available_texture_mem(device))
        {
            ERR("Out of adapter memory.\n");
            return WINED3DERR_OUTOFVIDEOMEMORY;
        }
        adapter_adjust_memory(device->adapter, size);
    }
 
    if (!(usage & WINED3DUSAGE_CS))
        device_resource_add(device, resource);
 
    return WINED3D_OK;
}

Referenced by wined3d_buffer_init(), and wined3d_texture_init().

resource_offset_map_pointer()

void * resource_offset_map_pointer	(	struct wined3d_resource *	resource,
		unsigned int	sub_resource_idx,
		uint8_t *	base_memory,
		const struct wined3d_box *	box
	)

Definition at line 574 of file resource.c.

{
    const struct wined3d_format *format = resource->format;
    unsigned int row_pitch, slice_pitch;
 
    wined3d_resource_get_sub_resource_map_pitch(resource, sub_resource_idx, &row_pitch, &slice_pitch);
 
    if ((resource->format_attrs & (WINED3D_FORMAT_ATTR_BLOCKS | WINED3D_FORMAT_ATTR_BROKEN_PITCH))
            == WINED3D_FORMAT_ATTR_BLOCKS)
    {
        /* Compressed textures are block based, so calculate the offset of
         * the block that contains the top-left pixel of the mapped box. */
        return base_memory
                + (box->front * slice_pitch)
                + ((box->top / format->block_height) * row_pitch)
                + ((box->left / format->block_width) * format->block_byte_count);
    }
    else
    {
        return base_memory
                + (box->front * slice_pitch)
                + (box->top * row_pitch)
                + (box->left * format->byte_count);
    }
}

Referenced by texture_resource_sub_resource_map(), and wined3d_cs_map_upload_bo().

resource_unload()

void resource_unload

(

struct wined3d_resource *

resource

)

Definition at line 241 of file resource.c.

{
    if (resource->map_count)
        ERR("Resource %p is being unloaded while mapped.\n", resource);
}

Referenced by buffer_resource_unload(), and texture_resource_unload().

vk_access_mask_from_bind_flags()

VkAccessFlags vk_access_mask_from_bind_flags

(

uint32_t

bind_flags

)

Definition at line 526 of file resource.c.

{
    VkAccessFlags flags = 0;
 
    if (bind_flags & WINED3D_BIND_VERTEX_BUFFER)
        flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
    if (bind_flags & WINED3D_BIND_INDEX_BUFFER)
        flags |= VK_ACCESS_INDEX_READ_BIT;
    if (bind_flags & WINED3D_BIND_CONSTANT_BUFFER)
        flags |= VK_ACCESS_UNIFORM_READ_BIT;
    if (bind_flags & WINED3D_BIND_SHADER_RESOURCE)
        flags |= VK_ACCESS_SHADER_READ_BIT;
    if (bind_flags & WINED3D_BIND_UNORDERED_ACCESS)
        flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
    if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
        flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
    if (bind_flags & WINED3D_BIND_RENDER_TARGET)
        flags |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
        flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
    if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
        flags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
 
    return flags;
}

Referenced by vk_blitter_blit(), wined3d_buffer_vk_barrier(), wined3d_shader_resource_view_vk_generate_mipmap(), wined3d_swapchain_vk_blit(), wined3d_texture_vk_barrier(), wined3d_texture_vk_clear(), wined3d_texture_vk_download_data(), wined3d_texture_vk_upload_data(), and wined3d_unordered_access_view_vk_clear().

vk_pipeline_stage_mask_from_bind_flags()

VkPipelineStageFlags vk_pipeline_stage_mask_from_bind_flags

(

uint32_t

bind_flags

)

Definition at line 552 of file resource.c.

{
    VkPipelineStageFlags flags = 0;
 
    if (bind_flags & (WINED3D_BIND_VERTEX_BUFFER | WINED3D_BIND_INDEX_BUFFER))
        flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
    if (bind_flags & (WINED3D_BIND_CONSTANT_BUFFER | WINED3D_BIND_SHADER_RESOURCE | WINED3D_BIND_UNORDERED_ACCESS))
        flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
                | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
                | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
    if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
        flags |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
    if (bind_flags & WINED3D_BIND_RENDER_TARGET)
        flags |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
        flags |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
    if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
        flags |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
 
    return flags;
}

Referenced by wined3d_buffer_vk_barrier(), wined3d_texture_vk_barrier(), and wined3d_unordered_access_view_vk_clear().

WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL

(

d3d_perf

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

d3d

)

wined3d_resource_allocate_sysmem()

static BOOL wined3d_resource_allocate_sysmem ( struct wined3d_resource *  resource )

static

Definition at line 316 of file resource.c.

{
    /* Overallocate and add padding to the allocated pointer, to guard against
     * games (for instance Railroad Tycoon 2) writing before the locked resource
     * memory pointer.
     */
    static const SIZE_T align = RESOURCE_ALIGNMENT;
    void *mem;
 
    if (!(mem = calloc(1, resource->size + align)))
    {
        ERR("Failed to allocate system memory.\n");
        return FALSE;
    }
 
    resource->heap_memory = (void *)(((ULONG_PTR)mem + align) & ~(RESOURCE_ALIGNMENT - 1));
    resource->heap_pointer = mem;
 
    return TRUE;
}

Referenced by wined3d_resource_prepare_sysmem().

wined3d_resource_check_box_dimensions()

HRESULT wined3d_resource_check_box_dimensions	(	struct wined3d_resource *	resource,
		unsigned int	sub_resource_idx,
		const struct wined3d_box *	box
	)

Definition at line 488 of file resource.c.

{
    const struct wined3d_format *format = resource->format;
    struct wined3d_sub_resource_desc desc;
    unsigned int width_mask, height_mask;
 
    wined3d_resource_get_sub_resource_desc(resource, sub_resource_idx, &desc);
 
    if (box->left >= box->right || box->right > desc.width
            || box->top >= box->bottom || box->bottom > desc.height
            || box->front >= box->back || box->back > desc.depth)
    {
        WARN("Box %s is invalid.\n", debug_box(box));
        return WINEDDERR_INVALIDRECT;
    }
 
    if (resource->format_attrs & WINED3D_FORMAT_ATTR_BLOCKS)
    {
        /* This assumes power of two block sizes, but NPOT block sizes would
         * be silly anyway.
         *
         * This also assumes that the format's block depth is 1. */
        width_mask = format->block_width - 1;
        height_mask = format->block_height - 1;
 
        if ((box->left & width_mask) || (box->top & height_mask)
                || (box->right & width_mask && box->right != desc.width)
                || (box->bottom & height_mask && box->bottom != desc.height))
        {
            WARN("Box %s is misaligned for %ux%u blocks.\n", debug_box(box), format->block_width, format->block_height);
            return WINED3DERR_INVALIDCALL;
        }
    }
 
    return WINED3D_OK;
}

Referenced by wined3d_device_context_blt(), wined3d_device_context_clear_rendertarget_view(), wined3d_device_context_clear_sysmem_texture(), wined3d_device_context_copy_sub_resource_region(), wined3d_device_context_map(), and wined3d_texture_add_dirty_region().

wined3d_resource_destroy_object()

static void wined3d_resource_destroy_object ( void *  object )

static

Definition at line 214 of file resource.c.

{
    struct wined3d_resource *resource = object;
 
    TRACE("resource %p.\n", resource);
 
    wined3d_resource_free_sysmem(resource);
    context_resource_released(resource->device, resource);
}

Referenced by resource_cleanup().

wined3d_resource_free_sysmem()

void wined3d_resource_free_sysmem

(

struct wined3d_resource *

resource

)

Definition at line 345 of file resource.c.

{
    if (!resource->heap_memory)
        return;
    resource->heap_memory = NULL;
 
    free(resource->heap_pointer);
    resource->heap_pointer = NULL;
}

Referenced by wined3d_buffer_evict_sysmem(), wined3d_resource_destroy_object(), wined3d_texture_evict_sysmem(), and wined3d_texture_update_desc().

wined3d_resource_get_decompress_format()

const struct wined3d_format * wined3d_resource_get_decompress_format

(

const struct wined3d_resource *

resource

)

Definition at line 447 of file resource.c.

{
    const struct wined3d_adapter *adapter = resource->device->adapter;
    if (resource->format_caps & (WINED3D_FORMAT_CAP_SRGB_READ | WINED3D_FORMAT_CAP_SRGB_WRITE)
            && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL))
        return wined3d_get_format(adapter, WINED3DFMT_B8G8R8A8_UNORM_SRGB, resource->bind_flags);
    return wined3d_get_format(adapter, WINED3DFMT_B8G8R8A8_UNORM, resource->bind_flags);
}

Referenced by wined3d_texture_gl_prepare_texture(), and wined3d_texture_gl_upload_data().

wined3d_resource_get_desc()

void CDECL wined3d_resource_get_desc	(	const struct wined3d_resource *	resource,
		struct wined3d_resource_desc *	desc
	)

Definition at line 280 of file resource.c.

{
    desc->resource_type = resource->type;
    desc->format = resource->format->id;
    desc->multisample_type = resource->multisample_type;
    desc->multisample_quality = resource->multisample_quality;
    desc->usage = resource->usage;
    desc->bind_flags = resource->bind_flags;
    desc->access = resource->access;
    desc->width = resource->width;
    desc->height = resource->height;
    desc->depth = resource->depth;
    desc->size = resource->size;
}

Referenced by d3d11_texture2d_GetDesc(), d3d8_device_upload_sysmem_index_buffer(), d3d8_device_upload_sysmem_vertex_buffers(), d3d8_indexbuffer_GetDesc(), d3d8_vertexbuffer_GetDesc(), d3d9_device_upload_sysmem_index_buffer(), d3d9_device_upload_sysmem_vertex_buffers(), d3d9_indexbuffer_GetDesc(), d3d9_vertexbuffer_GetDesc(), d3d_vertex_buffer7_GetVertexBufferDesc(), d3d_vertex_buffer7_Lock(), ddraw_surface7_SetSurfaceDesc(), ddraw_surface_reserve_memory(), dxgi_device_parent_register_swapchain_texture(), dxgi_resource_GetUsage(), dxgi_resource_init(), dxgi_surface_GetDesc(), fixup_texture_alpha_op(), reset_enum_callback(), and resolve_depth_buffer().

wined3d_resource_get_parent()

void *CDECL wined3d_resource_get_parent

(

const struct wined3d_resource *

resource

)

Definition at line 269 of file resource.c.

{
    return resource->parent;
}

Referenced by reset_enum_callback().

wined3d_resource_get_priority()

unsigned int CDECL wined3d_resource_get_priority

(

const struct wined3d_resource *

resource

)

Definition at line 263 of file resource.c.

{
    TRACE("resource %p, returning %u.\n", resource, resource->priority);
    return resource->priority;
}

Referenced by d3d8_indexbuffer_GetPriority(), d3d8_texture_2d_GetPriority(), d3d8_texture_3d_GetPriority(), d3d8_texture_cube_GetPriority(), d3d8_vertexbuffer_GetPriority(), d3d9_indexbuffer_GetPriority(), d3d9_texture_2d_GetPriority(), d3d9_texture_3d_GetPriority(), d3d9_texture_cube_GetPriority(), d3d9_vertexbuffer_GetPriority(), and ddraw_surface7_GetPriority().

wined3d_resource_get_sample_count()

unsigned int wined3d_resource_get_sample_count

(

const struct wined3d_resource *

resource

)

Definition at line 456 of file resource.c.

{
    const struct wined3d_format *format = resource->format;
 
    /* TODO: NVIDIA expose their Coverage Sample Anti-Aliasing (CSAA)
     * feature through type == MULTISAMPLE_XX and quality != 0. This could
     * be mapped to GL_NV_framebuffer_multisample_coverage.
     *
     * AMD have a similar feature called Enhanced Quality Anti-Aliasing
     * (EQAA), but it does not have an equivalent OpenGL extension. */
 
    /* We advertise as many WINED3D_MULTISAMPLE_NON_MASKABLE quality
     * levels as the count of advertised multisample types for the texture
     * format. */
    if (resource->multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE)
    {
        unsigned int i, count = 0;
 
        for (i = 0; i < sizeof(format->multisample_types) * CHAR_BIT; ++i)
        {
            if (format->multisample_types & 1u << i)
            {
                if (resource->multisample_quality == count++)
                    break;
            }
        }
        return i + 1;
    }
 
    return resource->multisample_type;
}

Referenced by vk_blitter_blit(), vk_blitter_blit_supported(), wined3d_context_vk_apply_draw_state(), wined3d_render_pass_key_vk_init(), wined3d_shader_resource_view_vk_generate_mipmap(), wined3d_texture_gl_allocate_immutable_storage(), wined3d_texture_gl_prepare_rb(), wined3d_texture_vk_download_data(), wined3d_texture_vk_prepare_texture(), and wined3d_texture_vk_upload_data().

wined3d_resource_gl_legacy_map_flags()

GLenum wined3d_resource_gl_legacy_map_flags

(

DWORD

d3d_flags

)

Definition at line 391 of file resource.c.

{
    switch (d3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE))
    {
        case WINED3D_MAP_READ:
            return GL_READ_ONLY_ARB;
 
        case WINED3D_MAP_WRITE:
            return GL_WRITE_ONLY_ARB;
 
        default:
            return GL_READ_WRITE_ARB;
    }
}

Referenced by wined3d_bo_gl_map().

wined3d_resource_gl_map_flags()

GLbitfield wined3d_resource_gl_map_flags	(	const struct wined3d_bo_gl *	bo,
		DWORD	d3d_flags
	)

Definition at line 373 of file resource.c.

{
    GLbitfield ret = 0;
 
    if (d3d_flags & WINED3D_MAP_WRITE)
    {
        ret |= GL_MAP_WRITE_BIT;
        if (!bo->b.coherent)
            ret |= GL_MAP_FLUSH_EXPLICIT_BIT;
    }
    if (d3d_flags & WINED3D_MAP_READ)
        ret |= GL_MAP_READ_BIT;
    else
        ret |= GL_MAP_UNSYNCHRONIZED_BIT;
 
    return ret;
}

Referenced by wined3d_bo_gl_map().

wined3d_resource_gl_storage_flags()

GLbitfield wined3d_resource_gl_storage_flags

(

const struct wined3d_resource *

resource

)

Definition at line 355 of file resource.c.

{
    uint32_t access = resource->access;
    GLbitfield flags = 0;
 
    if (resource->usage & WINED3DUSAGE_DYNAMIC)
        flags |= GL_CLIENT_STORAGE_BIT;
    if (!(access & WINED3D_RESOURCE_ACCESS_CPU))
    {
        if (access & WINED3D_RESOURCE_ACCESS_MAP_W)
            flags |= GL_MAP_WRITE_BIT;
        if (access & WINED3D_RESOURCE_ACCESS_MAP_R)
            flags |= GL_MAP_READ_BIT;
    }
 
    return flags;
}

Referenced by adapter_gl_alloc_bo(), and wined3d_buffer_gl_create_buffer_object().

wined3d_resource_is_offscreen()

BOOL wined3d_resource_is_offscreen

(

struct wined3d_resource *

resource

)

Definition at line 406 of file resource.c.

{
    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;
 
    return TRUE;
}

Referenced by ffp_blitter_clear_rendertargets(), texture2d_blt(), texture2d_read_from_framebuffer(), wined3d_context_gl_acquire(), wined3d_context_gl_apply_clear_state(), wined3d_gl_get_internal_format(), wined3d_resource_update_draw_binding(), and wined3d_texture_load_drawable().

wined3d_resource_map()

HRESULT CDECL wined3d_resource_map	(	struct wined3d_resource *	resource,
		unsigned int	sub_resource_idx,
		struct wined3d_map_desc *	map_desc,
		const struct wined3d_box *	box,
		uint32_t	flags
	)

Definition at line 295 of file resource.c.

{
    TRACE("resource %p, sub_resource_idx %u, map_desc %p, box %s, flags %#x.\n",
            resource, sub_resource_idx, map_desc, debug_box(box), flags);
 
    return wined3d_device_context_map(&resource->device->cs->c, resource, sub_resource_idx, map_desc, box, flags);
}

Referenced by d3d10_buffer_Map(), d3d10_texture1d_Map(), d3d10_texture2d_Map(), d3d10_texture3d_Map(), d3d8_device_upload_sysmem_index_buffer(), d3d8_indexbuffer_Lock(), d3d8_surface_LockRect(), d3d8_vertexbuffer_Lock(), d3d8_volume_LockBox(), d3d9_device_upload_sysmem_index_buffer(), d3d9_indexbuffer_Lock(), d3d9_surface_LockRect(), d3d9_vertexbuffer_Lock(), d3d9_volume_LockBox(), d3d_device7_DrawIndexedPrimitiveVB(), d3d_device7_DrawPrimitiveVB(), d3d_execute_buffer_SetExecuteData(), d3d_texture2_Load(), d3d_vertex_buffer7_Lock(), dxgi_surface_Map(), process_vertices_strided(), surface_lock(), wined3d_device_create_cursor_texture(), wined3d_device_process_vertices(), wined3d_device_set_cursor_properties(), and wined3d_streaming_buffer_map().

wined3d_resource_memory_colour_fill()

void wined3d_resource_memory_colour_fill	(	struct wined3d_resource *	resource,
		const struct wined3d_map_desc *	map,
		const struct wined3d_color *	colour,
		const struct wined3d_box *	box,
		bool	full_subresource
	)

Definition at line 601 of file resource.c.

{
    const struct wined3d_format *format = resource->format;
    unsigned int w, h, d, x, y, z, bpp;
    uint8_t *dst, *dst2;
    uint32_t c[4];
 
    /* Fast and simple path for setting everything to zero. The C library's memset is
     * more sophisticated than our code below. Also this works for block formats, which
     * we still need to zero-initialize for newly created resources. */
    if (full_subresource && !colour->r && !colour->g && !colour->b && !colour->a)
    {
        memset(map->data, 0, map->slice_pitch * box->back);
        return;
    }
 
    w = box->right - box->left;
    h = box->bottom - box->top;
    d = box->back - box->front;
 
    dst = (uint8_t *)map->data
            + (box->front * map->slice_pitch)
            + ((box->top / format->block_height) * map->row_pitch)
            + ((box->left / format->block_width) * format->block_byte_count);
 
    wined3d_format_convert_from_float(format, colour, c);
    bpp = format->byte_count;
 
    switch (bpp)
    {
        case 1:
            for (x = 0; x < w; ++x)
            {
                dst[x] = c[0];
            }
            break;
 
        case 2:
            for (x = 0; x < w; ++x)
            {
                ((uint16_t *)dst)[x] = c[0];
            }
            break;
 
        case 3:
        {
            dst2 = dst;
            for (x = 0; x < w; ++x, dst2 += 3)
            {
                dst2[0] = (c[0]      ) & 0xff;
                dst2[1] = (c[0] >>  8) & 0xff;
                dst2[2] = (c[0] >> 16) & 0xff;
            }
            break;
        }
        case 4:
            for (x = 0; x < w; ++x)
            {
                ((uint32_t *)dst)[x] = c[0];
            }
            break;
 
        case 8:
        case 12:
        case 16:
            for (x = 0; x < w; ++x)
                memcpy(((uint8_t *)map->data) + x * bpp, c, bpp);
            break;
 
        default:
            FIXME("Not implemented for bpp %u.\n", bpp);
            return;
    }
 
    dst2 = dst;
    for (y = 1; y < h; ++y)
    {
        dst2 += map->row_pitch;
        memcpy(dst2, dst, w * bpp);
    }
 
    dst2 = dst;
    for (z = 1; z < d; ++z)
    {
        dst2 += map->slice_pitch;
        memcpy(dst2, dst, w * h * bpp);
    }
 
}

Referenced by cpu_blitter_clear_texture(), and wined3d_texture_load_location().

wined3d_resource_preload()

void CDECL wined3d_resource_preload

(

struct wined3d_resource *

resource

)

Definition at line 311 of file resource.c.

{
    wined3d_cs_emit_preload_resource(resource->device->cs, resource);
}

Referenced by d3d8_indexbuffer_PreLoad(), d3d8_texture_preload(), d3d8_vertexbuffer_PreLoad(), d3d9_indexbuffer_PreLoad(), d3d9_surface_PreLoad(), d3d9_texture_preload(), d3d9_vertexbuffer_PreLoad(), and d3d_device7_PreLoad().

wined3d_resource_prepare_sysmem()

BOOL wined3d_resource_prepare_sysmem

(

struct wined3d_resource *

resource

)

Definition at line 337 of file resource.c.

{
    if (resource->heap_memory)
        return TRUE;
 
    return wined3d_resource_allocate_sysmem(resource);
}

Referenced by wined3d_buffer_gl_prepare_location(), wined3d_buffer_init(), wined3d_buffer_no3d_prepare_location(), wined3d_buffer_vk_prepare_location(), wined3d_texture_gl_prepare_location(), wined3d_texture_no3d_prepare_location(), wined3d_texture_update_desc(), and wined3d_texture_vk_prepare_location().

wined3d_resource_set_parent()

void CDECL wined3d_resource_set_parent	(	struct wined3d_resource *	resource,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 274 of file resource.c.

{
    resource->parent = parent;
    resource->parent_ops = parent_ops;
}

Referenced by d3d_texture2d_create(), ddraw_surface7_SetSurfaceDesc(), ddraw_texture_init(), and ddraw_texture_rename_to().

wined3d_resource_set_priority()

unsigned int CDECL wined3d_resource_set_priority	(	struct wined3d_resource *	resource,
		unsigned int	priority
	)

Definition at line 247 of file resource.c.

{
    unsigned int prev;
 
    if (!(resource->usage & WINED3DUSAGE_MANAGED))
    {
        WARN("Called on non-managed resource %p, ignoring.\n", resource);
        return 0;
    }
 
    prev = resource->priority;
    resource->priority = priority;
    TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev);
    return prev;
}

Referenced by d3d8_indexbuffer_SetPriority(), d3d8_texture_2d_SetPriority(), d3d8_texture_3d_SetPriority(), d3d8_texture_cube_SetPriority(), d3d8_vertexbuffer_SetPriority(), d3d9_indexbuffer_SetPriority(), d3d9_texture_2d_SetPriority(), d3d9_texture_3d_SetPriority(), d3d9_texture_cube_SetPriority(), d3d9_vertexbuffer_SetPriority(), and ddraw_surface7_SetPriority().

wined3d_resource_unmap()

HRESULT CDECL wined3d_resource_unmap	(	struct wined3d_resource *	resource,
		unsigned int	sub_resource_idx
	)

Definition at line 304 of file resource.c.

{
    TRACE("resource %p, sub_resource_idx %u.\n", resource, sub_resource_idx);
 
    return wined3d_device_context_unmap(&resource->device->cs->c, resource, sub_resource_idx);
}

Referenced by d3d10_buffer_Unmap(), d3d10_texture1d_Unmap(), d3d10_texture2d_Unmap(), d3d10_texture3d_Unmap(), d3d8_device_upload_sysmem_index_buffer(), d3d8_indexbuffer_Unlock(), d3d8_surface_UnlockRect(), d3d8_vertexbuffer_Unlock(), d3d8_volume_UnlockBox(), d3d9_device_upload_sysmem_index_buffer(), d3d9_indexbuffer_Unlock(), d3d9_surface_UnlockRect(), d3d9_vertexbuffer_Unlock(), d3d9_volume_UnlockBox(), d3d_device7_DrawIndexedPrimitiveVB(), d3d_device7_DrawPrimitiveVB(), d3d_execute_buffer_SetExecuteData(), d3d_texture2_Load(), d3d_vertex_buffer7_Unlock(), ddraw_surface1_Unlock(), dxgi_surface_Unmap(), process_vertices_strided(), wined3d_device_create_cursor_texture(), wined3d_device_process_vertices(), wined3d_device_set_cursor_properties(), and wined3d_streaming_buffer_unmap().

wined3d_resource_update_draw_binding()

void wined3d_resource_update_draw_binding

(

struct wined3d_resource *

resource

)

Definition at line 425 of file resource.c.

{
    const struct wined3d_d3d_info *d3d_info = &resource->device->adapter->d3d_info;
 
    if (!wined3d_resource_is_offscreen(resource))
    {
        resource->draw_binding = WINED3D_LOCATION_DRAWABLE;
    }
    else if (resource->multisample_type)
    {
        resource->draw_binding = d3d_info->multisample_draw_location;
    }
    else if (resource->gl_type == WINED3D_GL_RES_TYPE_RB)
    {
        resource->draw_binding = WINED3D_LOCATION_RB_RESOLVED;
    }
    else
    {
        resource->draw_binding = WINED3D_LOCATION_TEXTURE_RGB;
    }
}

Referenced by swapchain_update_draw_bindings(), wined3d_texture_init(), and wined3d_texture_set_swapchain().