utils.c File Reference

#include "vkd3d_private.h"
#include <errno.h>
#include "vulkan_procs.h"

Include dependency graph for utils.c:

Go to the source code of this file.

Classes
struct	vkd3d_format_compatibility_info

Macros
#define	COLOR   (VK_IMAGE_ASPECT_COLOR_BIT)
#define	DEPTH   (VK_IMAGE_ASPECT_DEPTH_BIT)
#define	STENCIL   (VK_IMAGE_ASPECT_STENCIL_BIT)
#define	DEPTH_STENCIL   (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)
#define	TYPELESS   VKD3D_FORMAT_TYPE_TYPELESS
#define	SINT   VKD3D_FORMAT_TYPE_SINT
#define	UINT   VKD3D_FORMAT_TYPE_UINT
#define	FLAG_TO_STR(f)   if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
#define	FLAG_TO_STR(f, n)   if (flags & f) { strcat(buffer, " | "#n); flags &= ~f; }
#define	FLAG_TO_STR(f)   if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
#define	FLAG_TO_STR(f)   if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
#define	LOAD_GLOBAL_PFN(name)
#define	LOAD_INSTANCE_PFN(name)
#define	LOAD_INSTANCE_OPTIONAL_PFN(name)    procs->name = (void *)global_procs->vkGetInstanceProcAddr(instance, #name);
#define	VK_INSTANCE_PFN   LOAD_INSTANCE_PFN
#define	VK_INSTANCE_EXT_PFN   LOAD_INSTANCE_OPTIONAL_PFN
#define	COPY_PARENT_PFN(name)   procs->name = parent_procs->name;
#define	LOAD_DEVICE_PFN(name)
#define	LOAD_DEVICE_OPTIONAL_PFN(name)    procs->name = (void *)procs->vkGetDeviceProcAddr(device, #name);
#define	VK_INSTANCE_PFN   COPY_PARENT_PFN
#define	VK_DEVICE_PFN   LOAD_DEVICE_PFN
#define	VK_DEVICE_EXT_PFN   LOAD_DEVICE_OPTIONAL_PFN

Functions
static bool	dxgi_format_is_depth_stencil (DXGI_FORMAT dxgi_format)
static HRESULT	vkd3d_init_format_compatibility_lists (struct d3d12_device *device)
static void	vkd3d_cleanup_format_compatibility_lists (struct d3d12_device *device)
static HRESULT	vkd3d_init_depth_stencil_formats (struct d3d12_device *device)
static void	vkd3d_cleanup_depth_stencil_formats (struct d3d12_device *device)
HRESULT	vkd3d_init_format_info (struct d3d12_device *device)
void	vkd3d_cleanup_format_info (struct d3d12_device *device)
static const struct vkd3d_format *	vkd3d_get_depth_stencil_format (const struct d3d12_device *device, DXGI_FORMAT dxgi_format)
const struct vkd3d_format *	vkd3d_get_format (const struct d3d12_device *device, DXGI_FORMAT dxgi_format, bool depth_stencil)
const struct vkd3d_format *	vkd3d_find_uint_format (const struct d3d12_device *device, DXGI_FORMAT dxgi_format)
void	vkd3d_format_copy_data (const struct vkd3d_format *format, const uint8_t *src, unsigned int src_row_pitch, unsigned int src_slice_pitch, uint8_t *dst, unsigned int dst_row_pitch, unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d)
VkFormat	vkd3d_get_vk_format (DXGI_FORMAT format)
DXGI_FORMAT	vkd3d_get_dxgi_format (VkFormat format)
bool	is_valid_feature_level (D3D_FEATURE_LEVEL feature_level)
bool	is_write_resource_state (D3D12_RESOURCE_STATES state)
static bool	is_power_of_two (unsigned int x)
bool	is_valid_resource_state (D3D12_RESOURCE_STATES state)
HRESULT	return_interface (void *iface, REFIID iface_iid, REFIID requested_iid, void **object)
const char *	debug_cpu_handle (D3D12_CPU_DESCRIPTOR_HANDLE handle)
const char *	debug_d3d12_box (const D3D12_BOX *box)
static const char *	debug_d3d12_shader_component (D3D12_SHADER_COMPONENT_MAPPING component)
const char *	debug_d3d12_shader_component_mapping (unsigned int mapping)
const char *	debug_gpu_handle (D3D12_GPU_DESCRIPTOR_HANDLE handle)
const char *	debug_vk_extent_3d (VkExtent3D extent)
const char *	debug_vk_queue_flags (VkQueueFlags flags)
const char *	debug_vk_memory_heap_flags (VkMemoryHeapFlags flags)
const char *	debug_vk_memory_property_flags (VkMemoryPropertyFlags flags)
HRESULT	hresult_from_errno (int rc)
HRESULT	hresult_from_vk_result (VkResult vr)
HRESULT	vkd3d_load_vk_global_procs (struct vkd3d_vk_global_procs *procs, PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr)
HRESULT	vkd3d_load_vk_instance_procs (struct vkd3d_vk_instance_procs *procs, const struct vkd3d_vk_global_procs *global_procs, VkInstance instance)
HRESULT	vkd3d_load_vk_device_procs (struct vkd3d_vk_device_procs *procs, const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device)
bool	vkd3d_get_program_name (char program_name[PATH_MAX])
static struct vkd3d_private_data *	vkd3d_private_store_get_private_data (const struct vkd3d_private_store *store, const GUID *tag)
static HRESULT	vkd3d_private_store_set_private_data (struct vkd3d_private_store *store, const GUID *tag, const void *data, unsigned int data_size, bool is_object)
HRESULT	vkd3d_get_private_data (struct vkd3d_private_store *store, const GUID *tag, unsigned int *out_size, void *out)
HRESULT	vkd3d_set_private_data (struct vkd3d_private_store *store, const GUID *tag, unsigned int data_size, const void *data)
HRESULT	vkd3d_set_private_data_interface (struct vkd3d_private_store *store, const GUID *tag, const IUnknown *object)
VkResult	vkd3d_set_vk_object_name_utf8 (struct d3d12_device *device, uint64_t vk_object, VkDebugReportObjectTypeEXT vk_object_type, const char *name)
HRESULT	vkd3d_set_vk_object_name (struct d3d12_device *device, uint64_t vk_object, VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name)

Variables
static const struct vkd3d_format	vkd3d_formats []
static const struct vkd3d_format	format_b4g4r4a4
static const struct vkd3d_format	vkd3d_depth_stencil_formats []
static const struct vkd3d_format_compatibility_info	vkd3d_format_compatibility_info []

Macro Definition Documentation

COLOR

#define COLOR   (VK_IMAGE_ASPECT_COLOR_BIT)

Definition at line 23 of file utils.c.

COPY_PARENT_PFN

#define COPY_PARENT_PFN

(

name

)

procs->name = parent_procs->name;

Definition at line 847 of file utils.c.

DEPTH

#define DEPTH   (VK_IMAGE_ASPECT_DEPTH_BIT)

Definition at line 24 of file utils.c.

DEPTH_STENCIL

#define DEPTH_STENCIL   (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)

Definition at line 26 of file utils.c.

FLAG_TO_STR [1/4]

#define FLAG_TO_STR

(

f

)

if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }

FLAG_TO_STR [2/4]

#define FLAG_TO_STR

(

f

)

if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }

FLAG_TO_STR [3/4]

#define FLAG_TO_STR

(

f

)

if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }

FLAG_TO_STR [4/4]

#define FLAG_TO_STR	(		f,
			n
	)		if (flags & f) { strcat(buffer, " | "#n); flags &= ~f; }

LOAD_DEVICE_OPTIONAL_PFN

#define LOAD_DEVICE_OPTIONAL_PFN

(

name

)

procs->name = (void *)procs->vkGetDeviceProcAddr(device, #name);

Definition at line 854 of file utils.c.

LOAD_DEVICE_PFN

#define LOAD_DEVICE_PFN

(

name

)

Value:

    if (!(procs->name = (void *)procs->vkGetDeviceProcAddr(device, #name))) \
    { \
        ERR("Could not get device proc addr for '" #name "'.\n"); \
        return E_FAIL; \
    }

Definition at line 848 of file utils.c.

LOAD_GLOBAL_PFN

#define LOAD_GLOBAL_PFN

(

name

)

Value:

    if (!(procs->name = (void *)vkGetInstanceProcAddr(NULL, #name))) \
    { \
        ERR("Could not get global proc addr for '" #name "'.\n"); \
        return E_FAIL; \
    }

Definition at line 804 of file utils.c.

LOAD_INSTANCE_OPTIONAL_PFN

#define LOAD_INSTANCE_OPTIONAL_PFN

(

name

)

procs->name = (void *)global_procs->vkGetInstanceProcAddr(instance, #name);

Definition at line 831 of file utils.c.

LOAD_INSTANCE_PFN

#define LOAD_INSTANCE_PFN

(

name

)

Value:

    if (!(procs->name = (void *)global_procs->vkGetInstanceProcAddr(instance, #name))) \
    { \
        ERR("Could not get instance proc addr for '" #name "'.\n"); \
        return E_FAIL; \
    }

Definition at line 825 of file utils.c.

SINT

#define SINT   VKD3D_FORMAT_TYPE_SINT

Definition at line 28 of file utils.c.

STENCIL

#define STENCIL   (VK_IMAGE_ASPECT_STENCIL_BIT)

Definition at line 25 of file utils.c.

TYPELESS

#define TYPELESS   VKD3D_FORMAT_TYPE_TYPELESS

Definition at line 27 of file utils.c.

UINT

_In_ UINT   VKD3D_FORMAT_TYPE_UINT

Definition at line 29 of file utils.c.

Referenced by __acrt_get_qualified_locale(), __acrt_get_qualified_locale_downlevel(), __crt_MessageBoxA(), CIniPropertyBag::_GetSectionAndName(), _gmtime64_s(), _isctype_l(), _localtime64_s(), CDesktopUpgradePropertyBag::_ReadFlags(), _Success_(), CBandSiteBase::_UpdateBand(), AboutDlgProc(), CBandSiteBase::AddBand(), AddCharacterToCharSet(), AddCodePage(), AllSysInfo(), Anime_FreeInfo(), ApplicationPage_OnEndTask(), ApplicationPage_OnGotoProcess(), ApplicationPage_OnSwitchTo(), ApplicationPage_OnWindowsBringToFront(), ApplicationPage_OnWindowsCascade(), ApplicationPage_OnWindowsMaximize(), ApplicationPage_OnWindowsMinimize(), ApplicationPage_OnWindowsTile(), asn_any_copy(), BuildCodePageList(), cal_return_number(), CalculateBitmapSize(), CTrayClockWnd::CalculateDueTime(), CardRegion::CardRegion(), CBGetTextAreaHeight(), CBindStatusCallback_UpdateProgress(), CBPaintText(), CheckListWndProc(), CLIPFORMAT_UserMarshal(), CLIPFORMAT_UserSize(), CLIPFORMAT_UserUnmarshal(), COMBO_ItemOp(), CommandDir(), CRecycleBin::CompareIDs(), CPlApplet(), CreateFolderFromNameSpace(), CreateStarBitmap(), CreateSysMenu(), DECLARE_INTERFACE_(), DefineDosDeviceW(), DeviceProblemTextW(), DIALOG_GoTo(), DirPrintWideList(), DisplayPageProc(), DlgPreferencesProc(), CDefView::DoColumnContextMenu(), CardRegion::DoFlash(), DoTestEntry(), DumpMenu(), EmbeddedComplexSize(), EMFDC_WriteNamedEscape(), EnableDialogText(), CMenuSite::EnumBands(), EnumFontSizesProc(), ExecuteREBytecode(), ExtractFilesCallback(), ExtractIconExW(), f_read(), f_write(), FGetComponentPath(), FileGetString(), FileStruct_Att(), FontFamilyFillInfo(), FontSizeChange(), FormatByteSize(), FormatFileSizeWithBytes(), ftGdiGetGlyphOutline(), GdipGetImagePaletteSize(), GdipGetSupportedFileExtensions(), gen_numname(), get_fat(), get_ldnumber(), get_support_msi(), BtrfsContextMenu::get_uac_icon(), GetCharacterPlacementW(), GetConsoleIMECommandLine(), GetDevNum(), GetFileTimeString(), GetKnownPath(), GetLocaleInfoW(), CMruNode::GetNodeSlot(), GetRawInputDeviceInfoA(), GetSelectedDriveItem(), GetSelectedItem(), GetSelectedUsageAction(), CFolder::GetUIObjectFromVariant(), GreGetDIBitsInternal(), IdnToNameprepUnicode(), ImageList_Create(), INF_OpenBufferedFileA(), CDrvDefExt::InitGeneralPage(), InitializeRecycleBinDlg(), install_wine_mono(), IntMapVirtualKeyEx(), IntSendCandListCHS(), KeyboardProc(), KeyboardSpeedProc(), LISTBOX_Create(), LISTBOX_DeleteItem(), LISTBOX_FindStringPos(), LISTBOX_InsertItem(), LISTVIEW_RefreshOwnerDraw(), LISTVIEW_ShowFocusRect(), LISTVIEW_WindowProc(), load_string(), locale_return_number(), LogOffDialogProc(), LpkGetCharacterPlacement(), LZCopy(), MainWndProc(), MakeFloatValueString(), MakeSimplePidl(), MD_OnChar(), MD_OnDeadChar(), MD_OnHotKey(), MD_OnKey(), MD_OnSysChar(), MD_OnSysDeadChar(), MD_OnSysKey(), MD_OnUniChar(), MENU_mnu2mnuii(), MenuHelp(), modify_binary_dlgproc(), MonthCalSetupDayTimer(), MouseCommand(), MsgMemorySize(), NdrBaseTypeMemorySize(), NdrSimpleTypeUnmarshall(), NextPathA(), NextPathW(), NICTestRAM(), notify_itemactivate(), NtUserEnableMenuItem(), NtUserGetRawInputDeviceInfo(), NtUserGetRawInputDeviceList(), NtUserRegisterWindowMessage(), NtUserSetWindowWord(), ok_strings_(), CDefView::OnCommand(), CAutoComplete::OnEditKeyDown(), CMainToolbar::OnGetDispInfo(), CShellLink::OnNotify(), OnSelChange(), CInternetToolbar::OnTipText(), CChangeNotifyServer::OnUnRegister(), OptionProc(), OptionsProc(), OverrideFileContent(), ParseMinMaxQuantifier(), ParseQuantifier(), ParseTerm(), performance_tool_ProcessPMsg(), PlaySoundRoutine(), ProgressWindowProc(), push_token(), put_fat(), CInternetToolbar::QIBand(), ReadAndDumpString(), ReadIpConfiguration(), REBAR_DeleteBand(), RecycleBin5_Create(), CBandSiteBase::RemoveBand(), SASWindowProc(), SaveFontSubstitutionSettings(), SetNTPServer(), setSBUpLow(), SettingsPageProc(), SetupCommitFileQueueW(), SetupOpenInfFileExW(), Shell_MergeMenus(), SHEvaluateSystemCommandTemplate(), SHGetFileDescriptionA(), SHInvokeCommandsOnContextMenu(), CNetConnectionPropertyUi::ShowNetworkComponentProperties(), SHParseName(), ShutdownDialogProc(), SndMixerGetLineName(), SndMixerGetProductName(), SnmpUtilVarBindCpy(), STATIC_PaintOwnerDrawfn(), CardRegion::StopFlash(), StrStrCase(), TAB_DrawItemInterior(), Test_CopyImage_Flags(), test_CreateStdAccessibleObject_classes(), test_FileTimeToLocalFileTime(), test_FileTimeToSystemTime(), test_menu_search_bycommand(), test_msidecomposedesc(), test_RegLoadMUIString(), test_sha_ctx(), Test_Write_StreamPosition(), text_buffer_changed(), TOOLBAR_KeyDown(), TreeListEndLabelEdit(), TreeListKeyDown(), TreeListMouseClick(), TreeListMouseNotify(), TreeListStartAutoEdit(), TreeListStartNotifyEdit(), UserpFormatMessages(), UserSetClassLongPtr(), weld_udec3(), WhoamiPrintTable(), wmain(), WritePageFileSettings(), WSHGetBroadcastSockaddr(), and WSHGetWildcardSockaddr().

VK_DEVICE_EXT_PFN

#define VK_DEVICE_EXT_PFN   LOAD_DEVICE_OPTIONAL_PFN

VK_DEVICE_PFN

#define VK_DEVICE_PFN   LOAD_DEVICE_PFN

VK_INSTANCE_EXT_PFN

#define VK_INSTANCE_EXT_PFN   LOAD_INSTANCE_OPTIONAL_PFN

VK_INSTANCE_PFN [1/2]

#define VK_INSTANCE_PFN   LOAD_INSTANCE_PFN

VK_INSTANCE_PFN [2/2]

#define VK_INSTANCE_PFN   COPY_PARENT_PFN

Function Documentation

debug_cpu_handle()

const char * debug_cpu_handle

(

D3D12_CPU_DESCRIPTOR_HANDLE

handle

)

Definition at line 645 of file utils.c.

{
    return vkd3d_dbg_sprintf("{%#"PRIxPTR"}", (uintptr_t)handle.ptr);
}

Referenced by d3d12_command_list_ClearDepthStencilView(), d3d12_command_list_ClearRenderTargetView(), d3d12_command_list_ClearUnorderedAccessViewFloat(), d3d12_command_list_ClearUnorderedAccessViewUint(), d3d12_device_CopyDescriptorsSimple(), d3d12_device_CreateConstantBufferView(), d3d12_device_CreateDepthStencilView(), d3d12_device_CreateRenderTargetView(), d3d12_device_CreateSampler(), d3d12_device_CreateSamplerFeedbackUnorderedAccessView(), d3d12_device_CreateShaderResourceView(), and d3d12_device_CreateUnorderedAccessView().

debug_d3d12_box()

const char * debug_d3d12_box

(

const D3D12_BOX *

box

)

Definition at line 650 of file utils.c.

{
    if (!box)
        return "(null)";
 
    return vkd3d_dbg_sprintf("(%u, %u, %u)-(%u, %u, %u)",
            box->left, box->top, box->front,
            box->right, box->bottom, box->back);
}

Referenced by d3d12_command_list_CopyTextureRegion(), d3d12_resource_ReadFromSubresource(), and d3d12_resource_WriteToSubresource().

debug_d3d12_shader_component()

static const char * debug_d3d12_shader_component ( D3D12_SHADER_COMPONENT_MAPPING  component )

static

Definition at line 660 of file utils.c.

{
    switch (component)
    {
        case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0:
            return "r";
        case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1:
            return "g";
        case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2:
            return "b";
        case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3:
            return "a";
        case D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0:
            return "0";
        case D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1:
            return "1";
    }
 
    FIXME("Invalid component mapping %#x.\n", component);
    return "invalid";
}

Referenced by debug_d3d12_shader_component_mapping().

debug_d3d12_shader_component_mapping()

const char * debug_d3d12_shader_component_mapping

(

unsigned int

mapping

)

Definition at line 682 of file utils.c.

{
    return vkd3d_dbg_sprintf("{%s, %s, %s, %s}",
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(0, mapping)),
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(1, mapping)),
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(2, mapping)),
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(3, mapping)));
}

Referenced by d3d12_desc_create_srv().

debug_gpu_handle()

const char * debug_gpu_handle

(

D3D12_GPU_DESCRIPTOR_HANDLE

handle

)

Definition at line 691 of file utils.c.

{
    return vkd3d_dbg_sprintf("{%#"PRIx64"}", handle.ptr);
}

Referenced by d3d12_command_list_ClearUnorderedAccessViewFloat(), d3d12_command_list_ClearUnorderedAccessViewUint(), d3d12_command_list_SetComputeRootDescriptorTable(), and d3d12_command_list_SetGraphicsRootDescriptorTable().

debug_vk_extent_3d()

const char * debug_vk_extent_3d

(

VkExtent3D

extent

)

Definition at line 696 of file utils.c.

{
    return vkd3d_dbg_sprintf("(%u, %u, %u)",
            (unsigned int)extent.width,
            (unsigned int)extent.height,
            (unsigned int)extent.depth);
}

Referenced by vkd3d_trace_physical_device().

debug_vk_memory_heap_flags()

const char * debug_vk_memory_heap_flags

(

VkMemoryHeapFlags

flags

)

Definition at line 728 of file utils.c.

{
    char buffer[80];
 
    buffer[0] = '\0';
#define FLAG_TO_STR(f) if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
    FLAG_TO_STR(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
    FLAG_TO_STR(VK_MEMORY_HEAP_MULTI_INSTANCE_BIT)
#undef FLAG_TO_STR
    if (flags)
        FIXME("Unrecognized flag(s) %#x.\n", flags);
 
    if (!buffer[0])
        return "0";
    return vkd3d_dbg_sprintf("%s", &buffer[3]);
}

Referenced by vkd3d_trace_physical_device().

debug_vk_memory_property_flags()

const char * debug_vk_memory_property_flags

(

VkMemoryPropertyFlags

flags

)

Definition at line 745 of file utils.c.

{
    char buffer[320];
 
    buffer[0] = '\0';
#define FLAG_TO_STR(f) if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
    FLAG_TO_STR(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_PROTECTED_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD)
#undef FLAG_TO_STR
    if (flags)
        FIXME("Unrecognized flag(s) %#x.\n", flags);
 
    if (!buffer[0])
        return "0";
    return vkd3d_dbg_sprintf("%s", &buffer[3]);
}

Referenced by vkd3d_trace_physical_device().

debug_vk_queue_flags()

const char * debug_vk_queue_flags

(

VkQueueFlags

flags

)

Definition at line 704 of file utils.c.

{
    char buffer[191];
 
    buffer[0] = '\0';
#define FLAG_TO_STR(f) if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
    FLAG_TO_STR(VK_QUEUE_GRAPHICS_BIT)
    FLAG_TO_STR(VK_QUEUE_COMPUTE_BIT)
    FLAG_TO_STR(VK_QUEUE_TRANSFER_BIT)
    FLAG_TO_STR(VK_QUEUE_SPARSE_BINDING_BIT)
    FLAG_TO_STR(VK_QUEUE_PROTECTED_BIT)
#undef FLAG_TO_STR
#define FLAG_TO_STR(f, n) if (flags & f) { strcat(buffer, " | "#n); flags &= ~f; }
    FLAG_TO_STR(0x20, VK_QUEUE_VIDEO_DECODE_BIT_KHR)
    FLAG_TO_STR(0x40, VK_QUEUE_VIDEO_ENCODE_BIT_KHR)
#undef FLAG_TO_STR
    if (flags)
        FIXME("Unrecognized flag(s) %#x.\n", flags);
 
    if (!buffer[0])
        return "0";
    return vkd3d_dbg_sprintf("%s", &buffer[3]);
}

Referenced by vkd3d_trace_physical_device().

dxgi_format_is_depth_stencil()

static bool dxgi_format_is_depth_stencil ( DXGI_FORMAT  dxgi_format )

static

Definition at line 247 of file utils.c.

{
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_formats); ++i)
    {
        const struct vkd3d_format *current = &vkd3d_formats[i];
 
        if (current->dxgi_format == dxgi_format)
            return current->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
    }
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_depth_stencil_formats); ++i)
    {
        if (vkd3d_depth_stencil_formats[i].dxgi_format == dxgi_format)
            return true;
    }
 
    return false;
}

Referenced by vkd3d_init_format_compatibility_lists().

hresult_from_errno()

HRESULT hresult_from_errno

(

int

rc

)

Definition at line 768 of file utils.c.

{
    switch (rc)
    {
        case 0:
            return S_OK;
        case ENOMEM:
            return E_OUTOFMEMORY;
        case EINVAL:
            return E_INVALIDARG;
        default:
            FIXME("Unhandled errno %d.\n", rc);
            return E_FAIL;
    }
}

Referenced by vkd3d_create_thread(), and vkd3d_join_thread().

hresult_from_vk_result()

HRESULT hresult_from_vk_result

(

VkResult

vr

)

Definition at line 784 of file utils.c.

{
    switch (vr)
    {
        case VK_SUCCESS:
            return S_OK;
        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
            WARN("Out of device memory.\n");
            /* fall-through */
        case VK_ERROR_OUT_OF_HOST_MEMORY:
            return E_OUTOFMEMORY;
        default:
            FIXME("Unhandled VkResult %d.\n", vr);
            /* fall-through */
        case VK_ERROR_DEVICE_LOST:
        case VK_ERROR_EXTENSION_NOT_PRESENT:
            return E_FAIL;
    }
}

Referenced by vkd3d_set_vk_object_name().

is_power_of_two()

static bool is_power_of_two ( unsigned int  x )

static

Definition at line 585 of file utils.c.

{
    return x && !(x & (x -1));
}

Referenced by is_valid_resource_state().

is_valid_feature_level()

bool is_valid_feature_level

(

D3D_FEATURE_LEVEL

feature_level

)

Definition at line 548 of file utils.c.

{
    static const D3D_FEATURE_LEVEL valid_feature_levels[] =
    {
        D3D_FEATURE_LEVEL_12_2,
        D3D_FEATURE_LEVEL_12_1,
        D3D_FEATURE_LEVEL_12_0,
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
        D3D_FEATURE_LEVEL_9_3,
        D3D_FEATURE_LEVEL_9_2,
        D3D_FEATURE_LEVEL_9_1,
        D3D_FEATURE_LEVEL_1_0_CORE,
    };
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(valid_feature_levels); ++i)
    {
        if (valid_feature_levels[i] == feature_level)
            return true;
    }
 
    return false;
}

Referenced by vkd3d_create_device().

is_valid_resource_state()

bool is_valid_resource_state

(

D3D12_RESOURCE_STATES

state

)

Definition at line 590 of file utils.c.

{
    const D3D12_RESOURCE_STATES valid_states =
            D3D12_RESOURCE_STATE_COMMON |
            D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER |
            D3D12_RESOURCE_STATE_INDEX_BUFFER |
            D3D12_RESOURCE_STATE_RENDER_TARGET |
            D3D12_RESOURCE_STATE_UNORDERED_ACCESS |
            D3D12_RESOURCE_STATE_DEPTH_WRITE |
            D3D12_RESOURCE_STATE_DEPTH_READ |
            D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE |
            D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE |
            D3D12_RESOURCE_STATE_STREAM_OUT |
            D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT |
            D3D12_RESOURCE_STATE_COPY_DEST |
            D3D12_RESOURCE_STATE_COPY_SOURCE |
            D3D12_RESOURCE_STATE_RESOLVE_DEST |
            D3D12_RESOURCE_STATE_RESOLVE_SOURCE |
            D3D12_RESOURCE_STATE_GENERIC_READ |
            D3D12_RESOURCE_STATE_PRESENT |
            D3D12_RESOURCE_STATE_PREDICATION;
 
    if (state & ~valid_states)
    {
        WARN("Invalid resource states %#x.\n", state & ~valid_states);
        return false;
    }
 
    /* Exactly one bit must be set for write states. */
    if (is_write_resource_state(state) && !is_power_of_two(state))
    {
        WARN("Write state cannot be mixed with other states: %#x.\n", state);
        return false;
    }
 
    return true;
}

Referenced by d3d12_command_list_ResourceBarrier(), d3d12_find_ds_multiplanar_transition(), and d3d12_resource_init().

is_write_resource_state()

bool is_write_resource_state

(

D3D12_RESOURCE_STATES

state

)

Definition at line 575 of file utils.c.

{
    return state & (D3D12_RESOURCE_STATE_RENDER_TARGET
            | D3D12_RESOURCE_STATE_UNORDERED_ACCESS
            | D3D12_RESOURCE_STATE_DEPTH_WRITE
            | D3D12_RESOURCE_STATE_STREAM_OUT
            | D3D12_RESOURCE_STATE_COPY_DEST
            | D3D12_RESOURCE_STATE_RESOLVE_DEST);
}

Referenced by is_valid_resource_state(), and vk_barrier_parameters_from_d3d12_resource_state().

return_interface()

HRESULT return_interface	(	void *	iface,
		REFIID	iface_iid,
		REFIID	requested_iid,
		void **	object
	)

Definition at line 628 of file utils.c.

{
    IUnknown *unknown = iface;
    HRESULT hr;
 
    if (IsEqualGUID(iface_iid, requested_iid))
    {
        *object = unknown;
        return S_OK;
    }
 
    hr = IUnknown_QueryInterface(unknown, requested_iid, object);
    IUnknown_Release(unknown);
    return hr;
}

Referenced by d3d12_device_CreateCommandAllocator(), d3d12_device_CreateCommandList(), d3d12_device_CreateCommandQueue(), d3d12_device_CreateCommandSignature(), d3d12_device_CreateCommittedResource(), d3d12_device_CreateCommittedResource1(), d3d12_device_CreateCommittedResource2(), d3d12_device_CreateComputePipelineState(), d3d12_device_CreateDescriptorHeap(), d3d12_device_CreateFence(), d3d12_device_CreateGraphicsPipelineState(), d3d12_device_CreateHeap(), d3d12_device_CreateHeap1(), d3d12_device_CreatePipelineState(), d3d12_device_CreatePlacedResource(), d3d12_device_CreatePlacedResource1(), d3d12_device_CreateQueryHeap(), d3d12_device_CreateReservedResource(), d3d12_device_CreateRootSignature(), vkd3d_create_device(), vkd3d_create_root_signature_deserializer(), and vkd3d_create_versioned_root_signature_deserializer().

vkd3d_cleanup_depth_stencil_formats()

static void vkd3d_cleanup_depth_stencil_formats ( struct d3d12_device *  device )

static

Definition at line 393 of file utils.c.

{
    if (vkd3d_depth_stencil_formats != device->depth_stencil_formats)
        vkd3d_free((void *)device->depth_stencil_formats);
 
    device->depth_stencil_formats = NULL;
}

Referenced by vkd3d_cleanup_format_info(), and vkd3d_init_format_info().

vkd3d_cleanup_format_compatibility_lists()

static void vkd3d_cleanup_format_compatibility_lists ( struct d3d12_device *  device )

static

Definition at line 346 of file utils.c.

{
    vkd3d_free((void *)device->format_compatibility_lists);
 
    device->format_compatibility_lists = NULL;
    device->format_compatibility_list_count = 0;
}

Referenced by vkd3d_cleanup_format_info().

vkd3d_cleanup_format_info()

void vkd3d_cleanup_format_info

(

struct d3d12_device *

device

)

Definition at line 414 of file utils.c.

{
    vkd3d_cleanup_depth_stencil_formats(device);
    vkd3d_cleanup_format_compatibility_lists(device);
}

Referenced by d3d12_device_init(), and d3d12_device_Release().

vkd3d_find_uint_format()

const struct vkd3d_format * vkd3d_find_uint_format	(	const struct d3d12_device *	device,
		DXGI_FORMAT	dxgi_format
	)

Definition at line 465 of file utils.c.

{
    DXGI_FORMAT typeless_format = DXGI_FORMAT_UNKNOWN;
    const struct vkd3d_format *vkd3d_format;
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_format_compatibility_info); ++i)
    {
        if (vkd3d_format_compatibility_info[i].format == dxgi_format)
        {
            typeless_format = vkd3d_format_compatibility_info[i].typeless_format;
            break;
        }
    }
 
    if (!typeless_format)
        return NULL;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_format_compatibility_info); ++i)
    {
        if (vkd3d_format_compatibility_info[i].typeless_format != typeless_format)
            continue;
 
        vkd3d_format = vkd3d_get_format(device, vkd3d_format_compatibility_info[i].format, false);
        if (vkd3d_format->type == VKD3D_FORMAT_TYPE_UINT)
            return vkd3d_format;
    }
 
    return NULL;
}

Referenced by create_uint_view().

vkd3d_format_copy_data()

void vkd3d_format_copy_data	(	const struct vkd3d_format *	format,
		const uint8_t *	src,
		unsigned int	src_row_pitch,
		unsigned int	src_slice_pitch,
		uint8_t *	dst,
		unsigned int	dst_row_pitch,
		unsigned int	dst_slice_pitch,
		unsigned int	w,
		unsigned int	h,
		unsigned int	d
	)

Definition at line 496 of file utils.c.

{
    unsigned int row_block_count, row_count, row_size, slice, row;
    unsigned int slice_count = d;
    const uint8_t *src_row;
    uint8_t *dst_row;
 
    row_block_count = (w + format->block_width - 1) / format->block_width;
    row_count = (h + format->block_height - 1) / format->block_height;
    row_size = row_block_count * format->byte_count * format->block_byte_count;
 
    for (slice = 0; slice < slice_count; ++slice)
    {
        for (row = 0; row < row_count; ++row)
        {
            src_row = &src[slice * src_slice_pitch + row * src_row_pitch];
            dst_row = &dst[slice * dst_slice_pitch + row * dst_row_pitch];
            memcpy(dst_row, src_row, row_size);
        }
    }
}

Referenced by d3d12_resource_ReadFromSubresource(), and d3d12_resource_WriteToSubresource().

vkd3d_get_depth_stencil_format()

static const struct vkd3d_format * vkd3d_get_depth_stencil_format ( const struct d3d12_device *  device, DXGI_FORMAT  dxgi_format  )

static

Definition at line 424 of file utils.c.

{
    const struct vkd3d_format *formats;
    unsigned int i;
 
    VKD3D_ASSERT(device);
    formats = device->depth_stencil_formats;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_depth_stencil_formats); ++i)
    {
        if (formats[i].dxgi_format == dxgi_format)
            return &formats[i];
    }
 
    return NULL;
}

Referenced by vkd3d_get_format().

vkd3d_get_dxgi_format()

DXGI_FORMAT vkd3d_get_dxgi_format

(

VkFormat

format

)

Definition at line 530 of file utils.c.

{
    DXGI_FORMAT dxgi_format;
    VkFormat vk_format;
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_formats); ++i)
    {
        vk_format = vkd3d_formats[i].vk_format;
        dxgi_format = vkd3d_formats[i].dxgi_format;
        if (vk_format == format && vkd3d_formats[i].type != VKD3D_FORMAT_TYPE_TYPELESS)
            return dxgi_format;
    }
 
    FIXME("Unhandled Vulkan format %#x.\n", format);
    return DXGI_FORMAT_UNKNOWN;
}

vkd3d_get_format()

const struct vkd3d_format * vkd3d_get_format	(	const struct d3d12_device *	device,
		DXGI_FORMAT	dxgi_format,
		bool	depth_stencil
	)

Definition at line 442 of file utils.c.

{
    const struct vkd3d_format *format;
    unsigned int i;
 
    if (depth_stencil && (format = vkd3d_get_depth_stencil_format(device, dxgi_format)))
        return format;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_formats); ++i)
    {
        if (vkd3d_formats[i].dxgi_format == dxgi_format)
            return &vkd3d_formats[i];
    }
 
    /* Do not check VkPhysicalDevice4444FormatsFeaturesEXT because apps
     * should query format support, which returns more detailed info. */
    if (dxgi_format == format_b4g4r4a4.dxgi_format && device->vk_info.EXT_4444_formats)
        return &format_b4g4r4a4;
 
    return NULL;
}

Referenced by compute_input_layout_offsets(), d3d12_device_check_multisample_quality_levels(), d3d12_device_CheckFeatureSupport(), d3d12_device_supports_typed_uav_load_additional_formats(), d3d12_pipeline_state_init_graphics(), vkd3d_create_buffer_uav(), vkd3d_create_buffer_view_for_resource(), vkd3d_create_null_srv(), vkd3d_create_null_uav(), vkd3d_create_raw_buffer_view(), vkd3d_find_uint_format(), vkd3d_fixup_clear_uav_uint_colour(), vkd3d_format_from_d3d12_resource_desc(), and vkd3d_get_vk_format().

vkd3d_get_private_data()

HRESULT vkd3d_get_private_data	(	struct vkd3d_private_store *	store,
		const GUID *	tag,
		unsigned int *	out_size,
		void *	out
	)

Definition at line 994 of file utils.c.

{
    const struct vkd3d_private_data *data;
    HRESULT hr = S_OK;
    unsigned int size;
 
    if (!out_size)
        return E_INVALIDARG;
 
    vkd3d_mutex_lock(&store->mutex);
 
    if (!(data = vkd3d_private_store_get_private_data(store, tag)))
    {
        *out_size = 0;
        hr = DXGI_ERROR_NOT_FOUND;
        goto done;
    }
 
    size = *out_size;
    *out_size = data->size;
    if (!out)
        goto done;
 
    if (size < data->size)
    {
        hr = DXGI_ERROR_MORE_DATA;
        goto done;
    }
 
    if (data->is_object)
        IUnknown_AddRef(data->u.object);
    memcpy(out, data->u.data, data->size);
 
done:
    vkd3d_mutex_unlock(&store->mutex);
    return hr;
}

Referenced by d3d12_cache_session_GetPrivateData(), d3d12_command_allocator_GetPrivateData(), d3d12_command_list_GetPrivateData(), d3d12_command_queue_GetPrivateData(), d3d12_command_signature_GetPrivateData(), d3d12_descriptor_heap_GetPrivateData(), d3d12_device_GetPrivateData(), d3d12_fence_GetPrivateData(), d3d12_heap_GetPrivateData(), d3d12_pipeline_state_GetPrivateData(), d3d12_query_heap_GetPrivateData(), d3d12_resource_GetPrivateData(), and d3d12_root_signature_GetPrivateData().

vkd3d_get_program_name()

bool vkd3d_get_program_name

(

char

program_name[PATH_MAX]

)

Definition at line 931 of file utils.c.

{
    *program_name = '\0';
    return false;
}

Referenced by vkd3d_instance_init().

vkd3d_get_vk_format()

VkFormat vkd3d_get_vk_format

(

DXGI_FORMAT

format

)

Definition at line 520 of file utils.c.

{
    const struct vkd3d_format *vkd3d_format;
 
    if (!(vkd3d_format = vkd3d_get_format(NULL, format, false)))
        return VK_FORMAT_UNDEFINED;
 
    return vkd3d_format->vk_format;
}

Referenced by d3d12_swapchain_create_d3d12_resources(), select_vk_format(), and vkd3d_init_format_compatibility_lists().

vkd3d_init_depth_stencil_formats()

static HRESULT vkd3d_init_depth_stencil_formats ( struct d3d12_device *  device )

static

Definition at line 354 of file utils.c.

{
    const unsigned int count = ARRAY_SIZE(vkd3d_depth_stencil_formats);
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    VkFormatProperties properties;
    struct vkd3d_format *formats;
    unsigned int i;
 
    VK_CALL(vkGetPhysicalDeviceFormatProperties(device->vk_physical_device,
            VK_FORMAT_D24_UNORM_S8_UINT, &properties));
 
    if (properties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
    {
        device->depth_stencil_formats = vkd3d_depth_stencil_formats;
    }
    else
    {
        /* AMD doesn't support VK_FORMAT_D24_UNORM_S8_UINT. */
        WARN("Mapping VK_FORMAT_D24_UNORM_S8_UINT to VK_FORMAT_D32_SFLOAT_S8_UINT.\n");
 
        if (!(formats = vkd3d_calloc(count, sizeof(*formats))))
            return E_OUTOFMEMORY;
 
        memcpy(formats, vkd3d_depth_stencil_formats, sizeof(vkd3d_depth_stencil_formats));
        for (i = 0; i < count; ++i)
        {
            if (formats[i].vk_format == VK_FORMAT_D24_UNORM_S8_UINT)
            {
                formats[i].vk_format = VK_FORMAT_D32_SFLOAT_S8_UINT;
                formats[i].is_emulated = true;
            }
        }
 
        device->depth_stencil_formats = formats;
    }
 
    return S_OK;
}

Referenced by vkd3d_init_format_info().

vkd3d_init_format_compatibility_lists()

static HRESULT vkd3d_init_format_compatibility_lists ( struct d3d12_device *  device )

static

Definition at line 269 of file utils.c.

{
    struct vkd3d_format_compatibility_list *lists, *current_list;
    const struct vkd3d_format_compatibility_info *current;
    DXGI_FORMAT dxgi_format;
    VkFormat vk_format;
    unsigned int count;
    unsigned int i, j;
 
    device->format_compatibility_list_count = 0;
    device->format_compatibility_lists = NULL;
 
    if (!device->vk_info.KHR_image_format_list)
        return S_OK;
 
    count = 1;
    dxgi_format = vkd3d_format_compatibility_info[0].typeless_format;
    for (i = 0; i < ARRAY_SIZE(vkd3d_format_compatibility_info); ++i)
    {
        DXGI_FORMAT typeless_format = vkd3d_format_compatibility_info[i].typeless_format;
 
        if (dxgi_format != typeless_format)
        {
            ++count;
            dxgi_format = typeless_format;
        }
    }
 
    if (!(lists = vkd3d_calloc(count, sizeof(*lists))))
        return E_OUTOFMEMORY;
 
    count = 0;
    current_list = lists;
    current_list->typeless_format = vkd3d_format_compatibility_info[0].typeless_format;
    for (i = 0; i < ARRAY_SIZE(vkd3d_format_compatibility_info); ++i)
    {
        current = &vkd3d_format_compatibility_info[i];
 
        if (current_list->typeless_format != current->typeless_format)
        {
            /* Avoid empty format lists. */
            if (current_list->format_count)
            {
                ++current_list;
                ++count;
            }
 
            current_list->typeless_format = current->typeless_format;
        }
 
        /* In Vulkan, each depth-stencil format is only compatible with itself. */
        if (dxgi_format_is_depth_stencil(current->format))
            continue;
 
        if (!(vk_format = vkd3d_get_vk_format(current->format)))
            continue;
 
        for (j = 0; j < current_list->format_count; ++j)
        {
            if (current_list->vk_formats[j] == vk_format)
                break;
        }
 
        if (j >= current_list->format_count)
        {
            VKD3D_ASSERT(current_list->format_count < VKD3D_MAX_COMPATIBLE_FORMAT_COUNT);
            current_list->vk_formats[current_list->format_count++] = vk_format;
        }
    }
    if (current_list->format_count)
        ++count;
 
    device->format_compatibility_list_count = count;
    device->format_compatibility_lists = lists;
    return S_OK;
}

Referenced by vkd3d_init_format_info().

vkd3d_init_format_info()

HRESULT vkd3d_init_format_info

(

struct d3d12_device *

device

)

Definition at line 401 of file utils.c.

{
    HRESULT hr;
 
    if (FAILED(hr = vkd3d_init_depth_stencil_formats(device)))
        return hr;
 
    if (FAILED(hr = vkd3d_init_format_compatibility_lists(device)))
        vkd3d_cleanup_depth_stencil_formats(device);
 
    return hr;
}

Referenced by d3d12_device_init().

vkd3d_load_vk_device_procs()

HRESULT vkd3d_load_vk_device_procs	(	struct vkd3d_vk_device_procs *	procs,
		const struct vkd3d_vk_instance_procs *	parent_procs,
		VkDevice	device
	)

Definition at line 857 of file utils.c.

{
    memset(procs, 0, sizeof(*procs));
 
#define VK_INSTANCE_PFN   COPY_PARENT_PFN
#define VK_DEVICE_PFN     LOAD_DEVICE_PFN
#define VK_DEVICE_EXT_PFN LOAD_DEVICE_OPTIONAL_PFN
#include "vulkan_procs.h"
 
    TRACE("Loaded procs for VkDevice %p.\n", device);
    return S_OK;
}

Referenced by vkd3d_create_vk_device().

vkd3d_load_vk_global_procs()

HRESULT vkd3d_load_vk_global_procs	(	struct vkd3d_vk_global_procs *	procs,
		PFN_vkGetInstanceProcAddr	vkGetInstanceProcAddr
	)

Definition at line 811 of file utils.c.

{
    memset(procs, 0, sizeof(*procs));
 
    procs->vkGetInstanceProcAddr = vkGetInstanceProcAddr;
 
    LOAD_GLOBAL_PFN(vkCreateInstance)
    LOAD_GLOBAL_PFN(vkEnumerateInstanceExtensionProperties)
 
    TRACE("Loaded global Vulkan procs.\n");
    return S_OK;
}

Referenced by vkd3d_init_vk_global_procs().

vkd3d_load_vk_instance_procs()

HRESULT vkd3d_load_vk_instance_procs	(	struct vkd3d_vk_instance_procs *	procs,
		const struct vkd3d_vk_global_procs *	global_procs,
		VkInstance	instance
	)

Definition at line 834 of file utils.c.

{
    memset(procs, 0, sizeof(*procs));
 
#define VK_INSTANCE_PFN     LOAD_INSTANCE_PFN
#define VK_INSTANCE_EXT_PFN LOAD_INSTANCE_OPTIONAL_PFN
#include "vulkan_procs.h"
 
    TRACE("Loaded procs for VkInstance %p.\n", instance);
    return S_OK;
}

Referenced by vkd3d_instance_init().

vkd3d_private_store_get_private_data()

static struct vkd3d_private_data * vkd3d_private_store_get_private_data ( const struct vkd3d_private_store *  store, const GUID *  tag  )

static

Definition at line 939 of file utils.c.

{
    struct vkd3d_private_data *data;
 
    LIST_FOR_EACH_ENTRY(data, &store->content, struct vkd3d_private_data, entry)
    {
        if (IsEqualGUID(&data->tag, tag))
            return data;
    }
 
    return NULL;
}

Referenced by vkd3d_get_private_data(), and vkd3d_private_store_set_private_data().

vkd3d_private_store_set_private_data()

static HRESULT vkd3d_private_store_set_private_data ( struct vkd3d_private_store *  store, const GUID *  tag, const void *  data, unsigned int  data_size, bool  is_object  )

static

Definition at line 953 of file utils.c.

{
    struct vkd3d_private_data *d, *old_data;
    const void *ptr = data;
 
    if (!data)
    {
        if ((d = vkd3d_private_store_get_private_data(store, tag)))
        {
            vkd3d_private_data_destroy(d);
            return S_OK;
        }
 
        return S_FALSE;
    }
 
    if (is_object)
    {
        if (data_size != sizeof(IUnknown *))
            return E_INVALIDARG;
        ptr = &data;
    }
 
    if (!(d = vkd3d_malloc(offsetof(struct vkd3d_private_data, u.data[data_size]))))
        return E_OUTOFMEMORY;
 
    d->tag = *tag;
    d->size = data_size;
    d->is_object = is_object;
    memcpy(d->u.data, ptr, data_size);
    if (is_object)
        IUnknown_AddRef(d->u.object);
 
    if ((old_data = vkd3d_private_store_get_private_data(store, tag)))
        vkd3d_private_data_destroy(old_data);
    list_add_tail(&store->content, &d->entry);
 
    return S_OK;
}

Referenced by vkd3d_set_private_data(), and vkd3d_set_private_data_interface().

vkd3d_set_private_data()

HRESULT vkd3d_set_private_data	(	struct vkd3d_private_store *	store,
		const GUID *	tag,
		unsigned int	data_size,
		const void *	data
	)

Definition at line 1033 of file utils.c.

{
    HRESULT hr;
 
    vkd3d_mutex_lock(&store->mutex);
 
    hr = vkd3d_private_store_set_private_data(store, tag, data, data_size, false);
 
    vkd3d_mutex_unlock(&store->mutex);
    return hr;
}

Referenced by d3d12_cache_session_SetPrivateData(), d3d12_command_allocator_SetPrivateData(), d3d12_command_list_SetPrivateData(), d3d12_command_queue_SetPrivateData(), d3d12_command_signature_SetPrivateData(), d3d12_descriptor_heap_SetPrivateData(), d3d12_device_SetPrivateData(), d3d12_fence_SetPrivateData(), d3d12_heap_SetPrivateData(), d3d12_pipeline_state_SetPrivateData(), d3d12_query_heap_SetPrivateData(), d3d12_resource_SetPrivateData(), and d3d12_root_signature_SetPrivateData().

vkd3d_set_private_data_interface()

HRESULT vkd3d_set_private_data_interface	(	struct vkd3d_private_store *	store,
		const GUID *	tag,
		const IUnknown *	object
	)

Definition at line 1046 of file utils.c.

{
    const void *data = object ? object : (void *)&object;
    HRESULT hr;
 
    vkd3d_mutex_lock(&store->mutex);
 
    hr = vkd3d_private_store_set_private_data(store, tag, data, sizeof(object), !!object);
 
    vkd3d_mutex_unlock(&store->mutex);
    return hr;
}

Referenced by d3d12_cache_session_SetPrivateDataInterface(), d3d12_command_allocator_SetPrivateDataInterface(), d3d12_command_list_SetPrivateDataInterface(), d3d12_command_queue_SetPrivateDataInterface(), d3d12_command_signature_SetPrivateDataInterface(), d3d12_descriptor_heap_SetPrivateDataInterface(), d3d12_device_SetPrivateDataInterface(), d3d12_fence_SetPrivateDataInterface(), d3d12_heap_SetPrivateDataInterface(), d3d12_pipeline_state_SetPrivateDataInterface(), d3d12_query_heap_SetPrivateDataInterface(), d3d12_resource_SetPrivateDataInterface(), and d3d12_root_signature_SetPrivateDataInterface().

vkd3d_set_vk_object_name()

HRESULT vkd3d_set_vk_object_name	(	struct d3d12_device *	device,
		uint64_t	vk_object,
		VkDebugReportObjectTypeEXT	vk_object_type,
		const WCHAR *	name
	)

Definition at line 1077 of file utils.c.

{
    char *name_utf8;
    VkResult vr;
 
    if (!name)
        return E_INVALIDARG;
 
    if (!device->vk_info.EXT_debug_marker)
        return S_OK;
 
    if (!(name_utf8 = vkd3d_strdup_w_utf8(name, device->wchar_size)))
        return E_OUTOFMEMORY;
 
    vr = vkd3d_set_vk_object_name_utf8(device, vk_object, vk_object_type, name_utf8);
 
    vkd3d_free(name_utf8);
 
    return hresult_from_vk_result(vr);
}

Referenced by d3d12_command_allocator_SetName(), d3d12_command_queue_SetName(), d3d12_device_SetName(), d3d12_heap_SetName(), d3d12_pipeline_state_SetName(), d3d12_query_heap_SetName(), and d3d12_resource_SetName().

vkd3d_set_vk_object_name_utf8()

VkResult vkd3d_set_vk_object_name_utf8	(	struct d3d12_device *	device,
		uint64_t	vk_object,
		VkDebugReportObjectTypeEXT	vk_object_type,
		const char *	name
	)

Definition at line 1060 of file utils.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    VkDebugMarkerObjectNameInfoEXT info;
 
    if (!device->vk_info.EXT_debug_marker)
        return VK_SUCCESS;
 
    info.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
    info.pNext = NULL;
    info.objectType = vk_object_type;
    info.object = vk_object;
    info.pObjectName = name;
    return VK_CALL(vkDebugMarkerSetObjectNameEXT(device->vk_device, &info));
}

Referenced by vkd3d_init_null_resources(), and vkd3d_set_vk_object_name().

Variable Documentation

format_b4g4r4a4

const struct vkd3d_format format_b4g4r4a4

static

Initial value:

=
    {DXGI_FORMAT_B4G4R4A4_UNORM,        VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, 2,  1, 1,  1, COLOR, 1}

Definition at line 121 of file utils.c.

Referenced by vkd3d_get_format().

vkd3d_depth_stencil_formats

const struct vkd3d_format vkd3d_depth_stencil_formats[]

static

Initial value:

=
{
    {DXGI_FORMAT_R32G8X24_TYPELESS,        VK_FORMAT_D32_SFLOAT_S8_UINT, 8,  1, 1, 1, DEPTH_STENCIL, 2, TYPELESS},
    {DXGI_FORMAT_D32_FLOAT_S8X24_UINT,     VK_FORMAT_D32_SFLOAT_S8_UINT, 8,  1, 1, 1, DEPTH_STENCIL, 2},
    {DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, VK_FORMAT_D32_SFLOAT_S8_UINT, 8,  1, 1, 1, DEPTH,         2},
    {DXGI_FORMAT_X32_TYPELESS_G8X24_UINT,  VK_FORMAT_D32_SFLOAT_S8_UINT, 8,  1, 1, 1, STENCIL,       2},
    {DXGI_FORMAT_R32_TYPELESS,             VK_FORMAT_D32_SFLOAT,         4,  1, 1, 1, DEPTH,         1, TYPELESS},
    {DXGI_FORMAT_R32_FLOAT,                VK_FORMAT_D32_SFLOAT,         4,  1, 1, 1, DEPTH,         1},
    {DXGI_FORMAT_R24G8_TYPELESS,           VK_FORMAT_D24_UNORM_S8_UINT,  4,  1, 1, 1, DEPTH_STENCIL, 2, TYPELESS},
    {DXGI_FORMAT_D24_UNORM_S8_UINT,        VK_FORMAT_D24_UNORM_S8_UINT,  4,  1, 1, 1, DEPTH_STENCIL, 2},
    {DXGI_FORMAT_R24_UNORM_X8_TYPELESS,    VK_FORMAT_D24_UNORM_S8_UINT,  4,  1, 1, 1, DEPTH,         2},
    {DXGI_FORMAT_X24_TYPELESS_G8_UINT,     VK_FORMAT_D24_UNORM_S8_UINT,  4,  1, 1, 1, STENCIL,       2},
    {DXGI_FORMAT_R16_TYPELESS,             VK_FORMAT_D16_UNORM,          2,  1, 1, 1, DEPTH,         1, TYPELESS},
    {DXGI_FORMAT_R16_UNORM,                VK_FORMAT_D16_UNORM,          2,  1, 1, 1, DEPTH,         1},
}

Definition at line 125 of file utils.c.

Referenced by dxgi_format_is_depth_stencil(), vkd3d_cleanup_depth_stencil_formats(), vkd3d_get_depth_stencil_format(), and vkd3d_init_depth_stencil_formats().

vkd3d_format_compatibility_info

const struct vkd3d_format_compatibility_info vkd3d_format_compatibility_info[]

static

vkd3d_formats

const struct vkd3d_format vkd3d_formats[]

static

Definition at line 30 of file utils.c.

Referenced by dxgi_format_is_depth_stencil(), vkd3d_get_dxgi_format(), and vkd3d_get_format().