wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-04-13 05:43:18 -07:00
Code Issues Packages Projects Releases Wiki Activity

libs/vkd3d-shader: Remove dependency on D3D12 headers.

Browse Source 
We would like to allow building libvkd3d-shader as a standalone library
without our Direct3D translation layers.

In the long term, it should be possible to build and use libvkd3d-shader
without Win32 data types, Vulkan headers and libs.

Signed-off-by: Józef Kucia <jkucia@codeweavers.com>
Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Józef Kucia
2018-02-15 15:43:51 +01:00
committed by Alexandre Julliard
parent 4c35737940
commit fddf86e6ea
5 changed files with 325 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
include/vkd3d_shader.h
View File

@ -118,9 +118,186 @@ HRESULT vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
const struct vkd3d_shader_interface *shader_interface); const struct vkd3d_shader_interface *shader_interface);
void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code); void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
enum vkd3d_filter
{
VKD3D_FILTER_MIN_MAG_MIP_POINT = 0x0,
VKD3D_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1,
VKD3D_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4,
VKD3D_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5,
VKD3D_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10,
VKD3D_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11,
VKD3D_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14,
VKD3D_FILTER_MIN_MAG_MIP_LINEAR = 0x15,
VKD3D_FILTER_ANISOTROPIC = 0x55,
VKD3D_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80,
VKD3D_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81,
VKD3D_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84,
VKD3D_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85,
VKD3D_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90,
VKD3D_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91,
VKD3D_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94,
VKD3D_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95,
VKD3D_FILTER_COMPARISON_ANISOTROPIC = 0xd5,
VKD3D_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100,
VKD3D_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101,
VKD3D_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104,
VKD3D_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105,
VKD3D_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110,
VKD3D_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111,
VKD3D_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114,
VKD3D_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115,
VKD3D_FILTER_MINIMUM_ANISOTROPIC = 0x155,
VKD3D_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180,
VKD3D_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181,
VKD3D_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184,
VKD3D_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185,
VKD3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190,
VKD3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191,
VKD3D_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194,
VKD3D_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195,
VKD3D_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_FILTER),
};
enum vkd3d_texture_address_mode
{
VKD3D_TEXTURE_ADDRESS_MODE_WRAP = 1,
VKD3D_TEXTURE_ADDRESS_MODE_MIRROR = 2,
VKD3D_TEXTURE_ADDRESS_MODE_CLAMP = 3,
VKD3D_TEXTURE_ADDRESS_MODE_BORDER = 4,
VKD3D_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 5,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_TEXTURE_ADDRESS_MODE),
};
enum vkd3d_comparison_func
{
VKD3D_COMPARISON_FUNC_NEVER = 1,
VKD3D_COMPARISON_FUNC_LESS = 2,
VKD3D_COMPARISON_FUNC_EQUAL = 3,
VKD3D_COMPARISON_FUNC_LESS_EQUAL = 4,
VKD3D_COMPARISON_FUNC_GREATER = 5,
VKD3D_COMPARISON_FUNC_NOT_EQUAL = 6,
VKD3D_COMPARISON_FUNC_GREATER_EQUAL = 7,
VKD3D_COMPARISON_FUNC_ALWAYS = 8,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_COMPARISON_FUNC),
};
enum vkd3d_static_border_color
{
VKD3D_STATIC_BORDER_COLOR_TRANSPARENT_BLACK = 0,
VKD3D_STATIC_BORDER_COLOR_OPAQUE_BLACK = 1,
VKD3D_STATIC_BORDER_COLOR_OPAQUE_WHITE = 2,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_STATIC_BORDER_COLOR),
};
struct vkd3d_static_sampler_desc
{
enum vkd3d_filter filter;
enum vkd3d_texture_address_mode address_u;
enum vkd3d_texture_address_mode address_v;
enum vkd3d_texture_address_mode address_w;
float mip_lod_bias;
unsigned int max_anisotropy;
enum vkd3d_comparison_func comparison_func;
enum vkd3d_static_border_color border_color;
float min_lod;
float max_lod;
unsigned int shader_register;
unsigned int register_space;
enum vkd3d_shader_visibility shader_visibility;
};
enum vkd3d_descriptor_range_type
{
VKD3D_DESCRIPTOR_RANGE_TYPE_SRV = 0,
VKD3D_DESCRIPTOR_RANGE_TYPE_UAV = 1,
VKD3D_DESCRIPTOR_RANGE_TYPE_CBV = 2,
VKD3D_DESCRIPTOR_RANGE_TYPE_SAMPLER = 3,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_DESCRIPTOR_RANGE_TYPE),
};
struct vkd3d_descriptor_range
{
enum vkd3d_descriptor_range_type range_type;
unsigned int descriptor_count;
unsigned int base_shader_register;
unsigned int register_space;
unsigned int descriptor_table_offset;
};
struct vkd3d_root_descriptor_table
{
unsigned int descriptor_range_count;
const struct vkd3d_descriptor_range *descriptor_ranges;
};
struct vkd3d_root_constants
{
unsigned int shader_register;
unsigned int register_space;
unsigned int value_count;
};
struct vkd3d_root_descriptor
{
unsigned int shader_register;
unsigned int register_space;
};
enum vkd3d_root_parameter_type
{
VKD3D_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = 0,
VKD3D_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS = 1,
VKD3D_ROOT_PARAMETER_TYPE_CBV = 2,
VKD3D_ROOT_PARAMETER_TYPE_SRV = 3,
VKD3D_ROOT_PARAMETER_TYPE_UAV = 4,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_PARAMETER_TYPE),
};
struct vkd3d_root_parameter
{
enum vkd3d_root_parameter_type parameter_type;
union
{
struct vkd3d_root_descriptor_table descriptor_table;
struct vkd3d_root_constants constants;
struct vkd3d_root_descriptor descriptor;
} u;
enum vkd3d_shader_visibility shader_visibility;
};
enum vkd3d_root_signature_flags
{
VKD3D_ROOT_SIGNATURE_FLAG_NONE = 0x0,
VKD3D_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 0x1,
VKD3D_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = 0x2,
VKD3D_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = 0x4,
VKD3D_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = 0x8,
VKD3D_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10,
VKD3D_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20,
VKD3D_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_SIGNATURE_FLAGS),
};
struct vkd3d_root_signature_desc
{
unsigned int parameter_count;
const struct vkd3d_root_parameter *parameters;
unsigned int static_sampler_count;
const struct vkd3d_static_sampler_desc *static_samplers;
enum vkd3d_root_signature_flags flags;
};
HRESULT vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc, HRESULT vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
D3D12_ROOT_SIGNATURE_DESC *root_signature); struct vkd3d_root_signature_desc *root_signature);
void vkd3d_shader_free_root_signature(D3D12_ROOT_SIGNATURE_DESC *root_signature); void vkd3d_shader_free_root_signature(struct vkd3d_root_signature_desc *root_signature);
enum vkd3d_root_signature_version enum vkd3d_root_signature_version
{ {
@ -129,7 +306,7 @@ enum vkd3d_root_signature_version
VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_SIGNATURE_VERSION), VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_SIGNATURE_VERSION),
}; };
HRESULT vkd3d_shader_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *root_signature, HRESULT vkd3d_shader_serialize_root_signature(const struct vkd3d_root_signature_desc *root_signature,
enum vkd3d_root_signature_version version, struct vkd3d_shader_code *dxbc); enum vkd3d_root_signature_version version, struct vkd3d_shader_code *dxbc);
#define VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS 8 #define VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS 8

238
libs/vkd3d-shader/dxbc.c
View File

@ -2064,7 +2064,7 @@ HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length,
} }
static HRESULT shader_parse_descriptor_ranges(const char *data, DWORD data_size, static HRESULT shader_parse_descriptor_ranges(const char *data, DWORD data_size,
DWORD offset, DWORD count, D3D12_DESCRIPTOR_RANGE *ranges) DWORD offset, DWORD count, struct vkd3d_descriptor_range *ranges)
{ {
const char *ptr; const char *ptr;
unsigned int i; unsigned int i;
@ -2078,26 +2078,26 @@ static HRESULT shader_parse_descriptor_ranges(const char *data, DWORD data_size,
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &ranges[i].RangeType); read_dword(&ptr, &ranges[i].range_type);
read_dword(&ptr, &ranges[i].NumDescriptors); read_dword(&ptr, &ranges[i].descriptor_count);
read_dword(&ptr, &ranges[i].BaseShaderRegister); read_dword(&ptr, &ranges[i].base_shader_register);
read_dword(&ptr, &ranges[i].RegisterSpace); read_dword(&ptr, &ranges[i].register_space);
read_dword(&ptr, &ranges[i].OffsetInDescriptorsFromTableStart); read_dword(&ptr, &ranges[i].descriptor_table_offset);
TRACE("Type %#x, descriptor count %u, base shader register %u, " TRACE("Type %#x, descriptor count %u, base shader register %u, "
"register space %u, offset %u.\n", "register space %u, offset %u.\n",
ranges[i].RangeType, ranges[i].NumDescriptors, ranges[i].range_type, ranges[i].descriptor_count,
ranges[i].BaseShaderRegister, ranges[i].RegisterSpace, ranges[i].base_shader_register, ranges[i].register_space,
ranges[i].OffsetInDescriptorsFromTableStart); ranges[i].descriptor_table_offset);
} }
return S_OK; return S_OK;
} }
static HRESULT shader_parse_descriptor_table(const char *data, DWORD data_size, static HRESULT shader_parse_descriptor_table(const char *data, DWORD data_size,
DWORD offset, D3D12_ROOT_DESCRIPTOR_TABLE *table) DWORD offset, struct vkd3d_root_descriptor_table *table)
{ {
D3D12_DESCRIPTOR_RANGE *ranges; struct vkd3d_descriptor_range *ranges;
const char *ptr; const char *ptr;
DWORD count; DWORD count;
@ -2113,16 +2113,16 @@ static HRESULT shader_parse_descriptor_table(const char *data, DWORD data_size,
TRACE("Descriptor range count %u.\n", count); TRACE("Descriptor range count %u.\n", count);
table->NumDescriptorRanges = count; table->descriptor_range_count = count;
if (!(ranges = vkd3d_calloc(count, sizeof(*ranges)))) if (!(ranges = vkd3d_calloc(count, sizeof(*ranges))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
table->pDescriptorRanges = ranges; table->descriptor_ranges = ranges;
return shader_parse_descriptor_ranges(data, data_size, offset, count, ranges); return shader_parse_descriptor_ranges(data, data_size, offset, count, ranges);
} }
static HRESULT shader_parse_root_constants(const char *data, DWORD data_size, static HRESULT shader_parse_root_constants(const char *data, DWORD data_size,
DWORD offset, D3D12_ROOT_CONSTANTS *constants) DWORD offset, struct vkd3d_root_constants *constants)
{ {
const char *ptr; const char *ptr;
@ -2133,18 +2133,18 @@ static HRESULT shader_parse_root_constants(const char *data, DWORD data_size,
} }
ptr = &data[offset]; ptr = &data[offset];
read_dword(&ptr, &constants->ShaderRegister); read_dword(&ptr, &constants->shader_register);
read_dword(&ptr, &constants->RegisterSpace); read_dword(&ptr, &constants->register_space);
read_dword(&ptr, &constants->Num32BitValues); read_dword(&ptr, &constants->value_count);
TRACE("Shader register %u, register space %u, 32-bit value count %u.\n", TRACE("Shader register %u, register space %u, 32-bit value count %u.\n",
constants->ShaderRegister, constants->RegisterSpace, constants->Num32BitValues); constants->shader_register, constants->register_space, constants->value_count);
return S_OK; return S_OK;
} }
static HRESULT shader_parse_root_descriptor(const char *data, DWORD data_size, static HRESULT shader_parse_root_descriptor(const char *data, DWORD data_size,
DWORD offset, D3D12_ROOT_DESCRIPTOR *descriptor) DWORD offset, struct vkd3d_root_descriptor *descriptor)
{ {
const char *ptr; const char *ptr;
@ -2155,17 +2155,17 @@ static HRESULT shader_parse_root_descriptor(const char *data, DWORD data_size,
} }
ptr = &data[offset]; ptr = &data[offset];
read_dword(&ptr, &descriptor->ShaderRegister); read_dword(&ptr, &descriptor->shader_register);
read_dword(&ptr, &descriptor->RegisterSpace); read_dword(&ptr, &descriptor->register_space);
TRACE("Shader register %u, register space %u.\n", TRACE("Shader register %u, register space %u.\n",
descriptor->ShaderRegister, descriptor->RegisterSpace); descriptor->shader_register, descriptor->register_space);
return S_OK; return S_OK;
} }
static HRESULT shader_parse_root_parameters(const char *data, DWORD data_size, static HRESULT shader_parse_root_parameters(const char *data, DWORD data_size,
DWORD offset, DWORD count, D3D12_ROOT_PARAMETER *parameters) DWORD offset, DWORD count, struct vkd3d_root_parameter *parameters)
{ {
const char *ptr; const char *ptr;
unsigned int i; unsigned int i;
@ -2180,28 +2180,28 @@ static HRESULT shader_parse_root_parameters(const char *data, DWORD data_size,
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &parameters[i].ParameterType); read_dword(&ptr, &parameters[i].parameter_type);
read_dword(&ptr, &parameters[i].ShaderVisibility); read_dword(&ptr, &parameters[i].shader_visibility);
read_dword(&ptr, &offset); read_dword(&ptr, &offset);
TRACE("Type %#x, shader visibility %#x.\n", TRACE("Type %#x, shader visibility %#x.\n",
parameters[i].ParameterType, parameters[i].ShaderVisibility); parameters[i].parameter_type, parameters[i].shader_visibility);
switch (parameters[i].ParameterType) switch (parameters[i].parameter_type)
{ {
case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE: case VKD3D_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
hr = shader_parse_descriptor_table(data, data_size, offset, &parameters[i].u.DescriptorTable); hr = shader_parse_descriptor_table(data, data_size, offset, &parameters[i].u.descriptor_table);
break; break;
case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS: case VKD3D_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
hr = shader_parse_root_constants(data, data_size, offset, &parameters[i].u.Constants); hr = shader_parse_root_constants(data, data_size, offset, &parameters[i].u.constants);
break; break;
case D3D12_ROOT_PARAMETER_TYPE_CBV: case VKD3D_ROOT_PARAMETER_TYPE_CBV:
case D3D12_ROOT_PARAMETER_TYPE_SRV: case VKD3D_ROOT_PARAMETER_TYPE_SRV:
case D3D12_ROOT_PARAMETER_TYPE_UAV: case VKD3D_ROOT_PARAMETER_TYPE_UAV:
hr = shader_parse_root_descriptor(data, data_size, offset, &parameters[i].u.Descriptor); hr = shader_parse_root_descriptor(data, data_size, offset, &parameters[i].u.descriptor);
break; break;
default: default:
FIXME("Unrecognized type %#x.\n", parameters[i].ParameterType); FIXME("Unrecognized type %#x.\n", parameters[i].parameter_type);
return E_INVALIDARG; return E_INVALIDARG;
} }
@ -2213,7 +2213,7 @@ static HRESULT shader_parse_root_parameters(const char *data, DWORD data_size,
} }
static HRESULT shader_parse_static_samplers(const char *data, DWORD data_size, static HRESULT shader_parse_static_samplers(const char *data, DWORD data_size,
DWORD offset, DWORD count, D3D12_STATIC_SAMPLER_DESC *sampler_descs) DWORD offset, DWORD count, struct vkd3d_static_sampler_desc *sampler_descs)
{ {
const char *ptr; const char *ptr;
unsigned int i; unsigned int i;
@ -2227,26 +2227,26 @@ static HRESULT shader_parse_static_samplers(const char *data, DWORD data_size,
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
{ {
read_dword(&ptr, &sampler_descs[i].Filter); read_dword(&ptr, &sampler_descs[i].filter);
read_dword(&ptr, &sampler_descs[i].AddressU); read_dword(&ptr, &sampler_descs[i].address_u);
read_dword(&ptr, &sampler_descs[i].AddressV); read_dword(&ptr, &sampler_descs[i].address_v);
read_dword(&ptr, &sampler_descs[i].AddressW); read_dword(&ptr, &sampler_descs[i].address_w);
read_float(&ptr, &sampler_descs[i].MipLODBias); read_float(&ptr, &sampler_descs[i].mip_lod_bias);
read_dword(&ptr, &sampler_descs[i].MaxAnisotropy); read_dword(&ptr, &sampler_descs[i].max_anisotropy);
read_dword(&ptr, &sampler_descs[i].ComparisonFunc); read_dword(&ptr, &sampler_descs[i].comparison_func);
read_dword(&ptr, &sampler_descs[i].BorderColor); read_dword(&ptr, &sampler_descs[i].border_color);
read_float(&ptr, &sampler_descs[i].MinLOD); read_float(&ptr, &sampler_descs[i].min_lod);
read_float(&ptr, &sampler_descs[i].MaxLOD); read_float(&ptr, &sampler_descs[i].max_lod);
read_dword(&ptr, &sampler_descs[i].ShaderRegister); read_dword(&ptr, &sampler_descs[i].shader_register);
read_dword(&ptr, &sampler_descs[i].RegisterSpace); read_dword(&ptr, &sampler_descs[i].register_space);
read_dword(&ptr, &sampler_descs[i].ShaderVisibility); read_dword(&ptr, &sampler_descs[i].shader_visibility);
} }
return S_OK; return S_OK;
} }
static HRESULT shader_parse_root_signature(const char *data, DWORD data_size, static HRESULT shader_parse_root_signature(const char *data, DWORD data_size,
D3D12_ROOT_SIGNATURE_DESC *desc) struct vkd3d_root_signature_desc *desc)
{ {
const char *ptr = data; const char *ptr = data;
DWORD count, offset; DWORD count, offset;
@ -2264,13 +2264,13 @@ static HRESULT shader_parse_root_signature(const char *data, DWORD data_size,
read_dword(&ptr, &offset); read_dword(&ptr, &offset);
TRACE("Parameter count %u, offset %u.\n", count, offset); TRACE("Parameter count %u, offset %u.\n", count, offset);
desc->NumParameters = count; desc->parameter_count = count;
if (desc->NumParameters) if (desc->parameter_count)
{ {
D3D12_ROOT_PARAMETER *parameters; struct vkd3d_root_parameter *parameters;
if (!(parameters = vkd3d_calloc(desc->NumParameters, sizeof(*parameters)))) if (!(parameters = vkd3d_calloc(desc->parameter_count, sizeof(*parameters))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
desc->pParameters = parameters; desc->parameters = parameters;
if (FAILED(hr = shader_parse_root_parameters(data, data_size, offset, count, parameters))) if (FAILED(hr = shader_parse_root_parameters(data, data_size, offset, count, parameters)))
return hr; return hr;
} }
@ -2279,26 +2279,26 @@ static HRESULT shader_parse_root_signature(const char *data, DWORD data_size,
read_dword(&ptr, &offset); read_dword(&ptr, &offset);
TRACE("Static sampler count %u, offset %u.\n", count, offset); TRACE("Static sampler count %u, offset %u.\n", count, offset);
desc->NumStaticSamplers = count; desc->static_sampler_count = count;
if (desc->NumStaticSamplers) if (desc->static_sampler_count)
{ {
D3D12_STATIC_SAMPLER_DESC *samplers; struct vkd3d_static_sampler_desc *samplers;
if (!(samplers = vkd3d_calloc(desc->NumStaticSamplers, sizeof(*samplers)))) if (!(samplers = vkd3d_calloc(desc->static_sampler_count, sizeof(*samplers))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
desc->pStaticSamplers = samplers; desc->static_samplers = samplers;
if (FAILED(hr = shader_parse_static_samplers(data, data_size, offset, count, samplers))) if (FAILED(hr = shader_parse_static_samplers(data, data_size, offset, count, samplers)))
return hr; return hr;
} }
read_dword(&ptr, &desc->Flags); read_dword(&ptr, &desc->flags);
TRACE("Flags %#x.\n", desc->Flags); TRACE("Flags %#x.\n", desc->flags);
return S_OK; return S_OK;
} }
static HRESULT rts0_handler(const char *data, DWORD data_size, DWORD tag, void *context) static HRESULT rts0_handler(const char *data, DWORD data_size, DWORD tag, void *context)
{ {
D3D12_ROOT_SIGNATURE_DESC *desc = context; struct vkd3d_root_signature_desc *desc = context;
if (tag != TAG_RTS0) if (tag != TAG_RTS0)
return S_OK; return S_OK;
@ -2307,7 +2307,7 @@ static HRESULT rts0_handler(const char *data, DWORD data_size, DWORD tag, void *
} }
HRESULT vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc, HRESULT vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
D3D12_ROOT_SIGNATURE_DESC *root_signature) struct vkd3d_root_signature_desc *root_signature)
{ {
HRESULT hr; HRESULT hr;
@ -2400,22 +2400,22 @@ static HRESULT shader_write_root_signature_header(struct root_signature_writer_c
} }
static HRESULT shader_write_descriptor_ranges(struct root_signature_writer_context *context, static HRESULT shader_write_descriptor_ranges(struct root_signature_writer_context *context,
const D3D12_ROOT_DESCRIPTOR_TABLE *table) const struct vkd3d_root_descriptor_table *table)
{ {
const D3D12_DESCRIPTOR_RANGE *ranges = table->pDescriptorRanges; const struct vkd3d_descriptor_range *ranges = table->descriptor_ranges;
unsigned int i; unsigned int i;
for (i = 0; i < table->NumDescriptorRanges; ++i) for (i = 0; i < table->descriptor_range_count; ++i)
{ {
if (!write_dword(context, ranges[i].RangeType)) if (!write_dword(context, ranges[i].range_type))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, ranges[i].NumDescriptors)) if (!write_dword(context, ranges[i].descriptor_count))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, ranges[i].BaseShaderRegister)) if (!write_dword(context, ranges[i].base_shader_register))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, ranges[i].RegisterSpace)) if (!write_dword(context, ranges[i].register_space))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, ranges[i].OffsetInDescriptorsFromTableStart)) if (!write_dword(context, ranges[i].descriptor_table_offset))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
@ -2423,9 +2423,9 @@ static HRESULT shader_write_descriptor_ranges(struct root_signature_writer_conte
} }
static HRESULT shader_write_descriptor_table(struct root_signature_writer_context *context, static HRESULT shader_write_descriptor_table(struct root_signature_writer_context *context,
const D3D12_ROOT_DESCRIPTOR_TABLE *table) const struct vkd3d_root_descriptor_table *table)
{ {
if (!write_dword(context, table->NumDescriptorRanges)) if (!write_dword(context, table->descriptor_range_count))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, get_chunk_offset(context) + sizeof(DWORD))) /* offset */ if (!write_dword(context, get_chunk_offset(context) + sizeof(DWORD))) /* offset */
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -2434,67 +2434,67 @@ static HRESULT shader_write_descriptor_table(struct root_signature_writer_contex
} }
static HRESULT shader_write_root_constants(struct root_signature_writer_context *context, static HRESULT shader_write_root_constants(struct root_signature_writer_context *context,
const D3D12_ROOT_CONSTANTS *constants) const struct vkd3d_root_constants *constants)
{ {
if (!write_dword(context, constants->ShaderRegister)) if (!write_dword(context, constants->shader_register))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, constants->RegisterSpace)) if (!write_dword(context, constants->register_space))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, constants->Num32BitValues)) if (!write_dword(context, constants->value_count))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
return S_OK; return S_OK;
} }
static HRESULT shader_write_root_descriptor(struct root_signature_writer_context *context, static HRESULT shader_write_root_descriptor(struct root_signature_writer_context *context,
const D3D12_ROOT_DESCRIPTOR *descriptor) const struct vkd3d_root_descriptor *descriptor)
{ {
if (!write_dword(context, descriptor->ShaderRegister)) if (!write_dword(context, descriptor->shader_register))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, descriptor->RegisterSpace)) if (!write_dword(context, descriptor->register_space))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
return S_OK; return S_OK;
} }
static HRESULT shader_write_root_parameters(struct root_signature_writer_context *context, static HRESULT shader_write_root_parameters(struct root_signature_writer_context *context,
const D3D12_ROOT_SIGNATURE_DESC *desc) const struct vkd3d_root_signature_desc *desc)
{ {
const D3D12_ROOT_PARAMETER *parameters = desc->pParameters; const struct vkd3d_root_parameter *parameters = desc->parameters;
size_t parameters_position; size_t parameters_position;
unsigned int i; unsigned int i;
HRESULT hr; HRESULT hr;
parameters_position = context->position; parameters_position = context->position;
for (i = 0; i < desc->NumParameters; ++i) for (i = 0; i < desc->parameter_count; ++i)
{ {
if (!write_dword(context, parameters[i].ParameterType)) if (!write_dword(context, parameters[i].parameter_type))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, parameters[i].ShaderVisibility)) if (!write_dword(context, parameters[i].shader_visibility))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, 0xffffffff)) /* offset */ if (!write_dword(context, 0xffffffff)) /* offset */
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
for (i = 0; i < desc->NumParameters; ++i) for (i = 0; i < desc->parameter_count; ++i)
{ {
context->data[parameters_position + 3 * i + 2] = get_chunk_offset(context); /* offset */ context->data[parameters_position + 3 * i + 2] = get_chunk_offset(context); /* offset */
switch (parameters[i].ParameterType) switch (parameters[i].parameter_type)
{ {
case D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE: case VKD3D_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE:
hr = shader_write_descriptor_table(context, &parameters[i].u.DescriptorTable); hr = shader_write_descriptor_table(context, &parameters[i].u.descriptor_table);
break; break;
case D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS: case VKD3D_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS:
hr = shader_write_root_constants(context, &parameters[i].u.Constants); hr = shader_write_root_constants(context, &parameters[i].u.constants);
break; break;
case D3D12_ROOT_PARAMETER_TYPE_CBV: case VKD3D_ROOT_PARAMETER_TYPE_CBV:
case D3D12_ROOT_PARAMETER_TYPE_SRV: case VKD3D_ROOT_PARAMETER_TYPE_SRV:
case D3D12_ROOT_PARAMETER_TYPE_UAV: case VKD3D_ROOT_PARAMETER_TYPE_UAV:
hr = shader_write_root_descriptor(context, &parameters[i].u.Descriptor); hr = shader_write_root_descriptor(context, &parameters[i].u.descriptor);
break; break;
default: default:
FIXME("Unrecognized type %#x.\n", parameters[i].ParameterType); FIXME("Unrecognized type %#x.\n", parameters[i].parameter_type);
return E_INVALIDARG; return E_INVALIDARG;
} }
@ -2506,38 +2506,38 @@ static HRESULT shader_write_root_parameters(struct root_signature_writer_context
} }
static HRESULT shader_write_static_samplers(struct root_signature_writer_context *context, static HRESULT shader_write_static_samplers(struct root_signature_writer_context *context,
const D3D12_ROOT_SIGNATURE_DESC *desc) const struct vkd3d_root_signature_desc *desc)
{ {
const D3D12_STATIC_SAMPLER_DESC *samplers = desc->pStaticSamplers; const struct vkd3d_static_sampler_desc *samplers = desc->static_samplers;
unsigned int i; unsigned int i;
for (i = 0; i < desc->NumStaticSamplers; ++i) for (i = 0; i < desc->static_sampler_count; ++i)
{ {
if (!write_dword(context, samplers[i].Filter)) if (!write_dword(context, samplers[i].filter))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].AddressU)) if (!write_dword(context, samplers[i].address_u))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].AddressV)) if (!write_dword(context, samplers[i].address_v))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].AddressW)) if (!write_dword(context, samplers[i].address_w))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_float(context, samplers[i].MipLODBias)) if (!write_float(context, samplers[i].mip_lod_bias))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].MaxAnisotropy)) if (!write_dword(context, samplers[i].max_anisotropy))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].ComparisonFunc)) if (!write_dword(context, samplers[i].comparison_func))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].BorderColor)) if (!write_dword(context, samplers[i].border_color))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_float(context, samplers[i].MinLOD)) if (!write_float(context, samplers[i].min_lod))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_float(context, samplers[i].MaxLOD)) if (!write_float(context, samplers[i].max_lod))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].ShaderRegister)) if (!write_dword(context, samplers[i].shader_register))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].RegisterSpace)) if (!write_dword(context, samplers[i].register_space))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, samplers[i].ShaderVisibility)) if (!write_dword(context, samplers[i].shader_visibility))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
@ -2545,7 +2545,7 @@ static HRESULT shader_write_static_samplers(struct root_signature_writer_context
} }
static HRESULT shader_write_root_signature(struct root_signature_writer_context *context, static HRESULT shader_write_root_signature(struct root_signature_writer_context *context,
const D3D12_ROOT_SIGNATURE_DESC *desc) const struct vkd3d_root_signature_desc *desc)
{ {
size_t samplers_offset_position; size_t samplers_offset_position;
HRESULT hr; HRESULT hr;
@ -2553,18 +2553,18 @@ static HRESULT shader_write_root_signature(struct root_signature_writer_context
if (!write_dword(context, 0x00000001)) if (!write_dword(context, 0x00000001))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, desc->NumParameters)) if (!write_dword(context, desc->parameter_count))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, get_chunk_offset(context) + 4 * sizeof(DWORD))) /* offset */ if (!write_dword(context, get_chunk_offset(context) + 4 * sizeof(DWORD))) /* offset */
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, desc->NumStaticSamplers)) if (!write_dword(context, desc->static_sampler_count))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
samplers_offset_position = context->position; samplers_offset_position = context->position;
if (!write_dword(context, 0xffffffff)) /* offset */ if (!write_dword(context, 0xffffffff)) /* offset */
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!write_dword(context, desc->Flags)) if (!write_dword(context, desc->flags))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (FAILED(hr = shader_write_root_parameters(context, desc))) if (FAILED(hr = shader_write_root_parameters(context, desc)))
@ -2574,7 +2574,7 @@ static HRESULT shader_write_root_signature(struct root_signature_writer_context
return shader_write_static_samplers(context, desc); return shader_write_static_samplers(context, desc);
} }
HRESULT vkd3d_shader_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *root_signature, HRESULT vkd3d_shader_serialize_root_signature(const struct vkd3d_root_signature_desc *root_signature,
enum vkd3d_root_signature_version version, struct vkd3d_shader_code *dxbc) enum vkd3d_root_signature_version version, struct vkd3d_shader_code *dxbc)
{ {
struct root_signature_writer_context context; struct root_signature_writer_context context;

14
libs/vkd3d-shader/vkd3d_shader_main.c
View File

@ -200,19 +200,19 @@ void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code)
vkd3d_free((void *)shader_code->code); vkd3d_free((void *)shader_code->code);
} }
void vkd3d_shader_free_root_signature(D3D12_ROOT_SIGNATURE_DESC *root_signature) void vkd3d_shader_free_root_signature(struct vkd3d_root_signature_desc *root_signature)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < root_signature->NumParameters; ++i) for (i = 0; i < root_signature->parameter_count; ++i)
{ {
const D3D12_ROOT_PARAMETER *parameter = &root_signature->pParameters[i]; const struct vkd3d_root_parameter *parameter = &root_signature->parameters[i];
if (parameter->ParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE) if (parameter->parameter_type == VKD3D_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
vkd3d_free((void *)parameter->u.DescriptorTable.pDescriptorRanges); vkd3d_free((void *)parameter->u.descriptor_table.descriptor_ranges);
} }
vkd3d_free((void *)root_signature->pParameters); vkd3d_free((void *)root_signature->parameters);
vkd3d_free((void *)root_signature->pStaticSamplers); vkd3d_free((void *)root_signature->static_samplers);
memset(root_signature, 0, sizeof(*root_signature)); memset(root_signature, 0, sizeof(*root_signature));
} }

14
libs/vkd3d/state.c
View File

@ -1006,11 +1006,15 @@ HRESULT d3d12_root_signature_create(struct d3d12_device *device,
const void *bytecode, size_t bytecode_length, struct d3d12_root_signature **root_signature) const void *bytecode, size_t bytecode_length, struct d3d12_root_signature **root_signature)
{ {
const struct vkd3d_shader_code dxbc = {bytecode, bytecode_length}; const struct vkd3d_shader_code dxbc = {bytecode, bytecode_length};
D3D12_ROOT_SIGNATURE_DESC root_signature_desc; union
{
D3D12_ROOT_SIGNATURE_DESC d3d12;
struct vkd3d_root_signature_desc vkd3d;
} root_signature_desc;
struct d3d12_root_signature *object; struct d3d12_root_signature *object;
HRESULT hr; HRESULT hr;
if (FAILED(hr = vkd3d_shader_parse_root_signature(&dxbc, &root_signature_desc))) if (FAILED(hr = vkd3d_shader_parse_root_signature(&dxbc, &root_signature_desc.vkd3d)))
{ {
WARN("Failed to parse root signature, hr %#x.\n", hr); WARN("Failed to parse root signature, hr %#x.\n", hr);
return hr; return hr;
@ -1018,12 +1022,12 @@ HRESULT d3d12_root_signature_create(struct d3d12_device *device,
if (!(object = vkd3d_malloc(sizeof(*object)))) if (!(object = vkd3d_malloc(sizeof(*object))))
{ {
vkd3d_shader_free_root_signature(&root_signature_desc); vkd3d_shader_free_root_signature(&root_signature_desc.vkd3d);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
hr = d3d12_root_signature_init(object, device, &root_signature_desc); hr = d3d12_root_signature_init(object, device, &root_signature_desc.d3d12);
vkd3d_shader_free_root_signature(&root_signature_desc); vkd3d_shader_free_root_signature(&root_signature_desc.vkd3d);
if (FAILED(hr)) if (FAILED(hr))
{ {
vkd3d_free(object); vkd3d_free(object);

15
libs/vkd3d/vkd3d_main.c
View File

@ -79,7 +79,11 @@ struct d3d12_root_signature_deserializer
ID3D12RootSignatureDeserializer ID3D12RootSignatureDeserializer_iface; ID3D12RootSignatureDeserializer ID3D12RootSignatureDeserializer_iface;
LONG refcount; LONG refcount;
D3D12_ROOT_SIGNATURE_DESC desc; union
{
D3D12_ROOT_SIGNATURE_DESC d3d12;
struct vkd3d_root_signature_desc vkd3d;
} desc;
}; };
static struct d3d12_root_signature_deserializer *impl_from_ID3D12RootSignatureDeserializer( static struct d3d12_root_signature_deserializer *impl_from_ID3D12RootSignatureDeserializer(
@ -128,7 +132,7 @@ static ULONG STDMETHODCALLTYPE d3d12_root_signature_deserializer_Release(ID3D12R
if (!refcount) if (!refcount)
{ {
vkd3d_shader_free_root_signature(&deserializer->desc); vkd3d_shader_free_root_signature(&deserializer->desc.vkd3d);
vkd3d_free(deserializer); vkd3d_free(deserializer);
} }
@ -142,7 +146,7 @@ static const D3D12_ROOT_SIGNATURE_DESC * STDMETHODCALLTYPE d3d12_root_signature_
TRACE("iface %p.\n", iface); TRACE("iface %p.\n", iface);
return &deserializer->desc; return &deserializer->desc.d3d12;
} }
static const struct ID3D12RootSignatureDeserializerVtbl d3d12_root_signature_deserializer_vtbl = static const struct ID3D12RootSignatureDeserializerVtbl d3d12_root_signature_deserializer_vtbl =
@ -163,7 +167,7 @@ static HRESULT d3d12_root_signature_deserializer_init(struct d3d12_root_signatur
deserializer->ID3D12RootSignatureDeserializer_iface.lpVtbl = &d3d12_root_signature_deserializer_vtbl; deserializer->ID3D12RootSignatureDeserializer_iface.lpVtbl = &d3d12_root_signature_deserializer_vtbl;
deserializer->refcount = 1; deserializer->refcount = 1;
if (FAILED(hr = vkd3d_shader_parse_root_signature(dxbc, &deserializer->desc))) if (FAILED(hr = vkd3d_shader_parse_root_signature(dxbc, &deserializer->desc.vkd3d)))
{ {
WARN("Failed to parse root signature, hr %#x.\n", hr); WARN("Failed to parse root signature, hr %#x.\n", hr);
return hr; return hr;
@ -331,7 +335,8 @@ HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *root_sig
*error_blob = NULL; *error_blob = NULL;
} }
if (FAILED(hr = vkd3d_shader_serialize_root_signature(root_signature_desc, if (FAILED(hr = vkd3d_shader_serialize_root_signature(
(const struct vkd3d_root_signature_desc *)root_signature_desc,
(enum vkd3d_root_signature_version)version, &dxbc))) (enum vkd3d_root_signature_version)version, &dxbc)))
{ {
WARN("Failed to serialize root signature, hr %#x.\n", hr); WARN("Failed to serialize root signature, hr %#x.\n", hr);