wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-01-28 13:05:02 -08:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d-shader: Add support for parsing Shader Model 5.1 bytecode.

Browse Source 
Translation to SPIR-V isn't implemented yet.

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 2019-04-29 11:38:15 +02:00 committed by Alexandre Julliard
parent 242e52ac59
commit c77f02ca01
4 changed files with 186 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -78,6 +78,9 @@
#define VKD3D_SM4_REGISTER_MODIFIER (0x1u << 31)
#define VKD3D_SM4_ADDRESSING_SHIFT2 28
#define VKD3D_SM4_ADDRESSING_MASK2 (0x3u << VKD3D_SM4_ADDRESSING_SHIFT2)
#define VKD3D_SM4_ADDRESSING_SHIFT1 25
#define VKD3D_SM4_ADDRESSING_MASK1 (0x3u << VKD3D_SM4_ADDRESSING_SHIFT1)
@ -512,11 +515,35 @@ static const enum vkd3d_data_type data_type_table[] =
/* VKD3D_SM4_DATA_FLOAT */ VKD3D_DATA_FLOAT,
};
static bool shader_is_sm_5_1(const struct vkd3d_sm4_data *priv)
{
const struct vkd3d_shader_version *version = &priv->shader_version;
return version->major >= 5 && version->minor >= 1;
}
static bool shader_sm4_read_src_param(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
enum vkd3d_data_type data_type, struct vkd3d_shader_src_param *src_param);
static bool shader_sm4_read_dst_param(struct vkd3d_sm4_data *priv, const DWORD **ptr, const DWORD *end,
enum vkd3d_data_type data_type, struct vkd3d_shader_dst_param *dst_param);
static bool shader_sm4_read_register_space(struct vkd3d_sm4_data *priv,
const DWORD **ptr, const DWORD *end, unsigned int *register_space)
{
*register_space = 0;
if (!shader_is_sm_5_1(priv))
return true;
if (*ptr >= end)
{
WARN("Invalid ptr %p >= end %p.\n", *ptr, end);
return false;
}
*register_space = *(*ptr)++;
return true;
}
static void shader_sm4_read_conditional_op(struct vkd3d_shader_instruction *ins,
DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
struct vkd3d_sm4_data *priv)
@ -560,6 +587,7 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins,
struct vkd3d_sm4_data *priv)
{
enum vkd3d_sm4_resource_type resource_type;
const DWORD *end = &tokens[token_count];
enum vkd3d_sm4_data_type data_type;
enum vkd3d_data_type reg_data_type;
DWORD components;
@ -575,7 +603,7 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins,
ins->declaration.semantic.resource_type = resource_type_table[resource_type];
}
reg_data_type = opcode == VKD3D_SM4_OP_DCL_RESOURCE ? VKD3D_DATA_RESOURCE : VKD3D_DATA_UAV;
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], reg_data_type, &ins->declaration.semantic.reg);
shader_sm4_read_dst_param(priv, &tokens, end, reg_data_type, &ins->declaration.semantic.reg);
components = *tokens++;
if ((components & 0xfff0) != (components & 0xf) * 0x1110)
@ -594,25 +622,47 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins,
if (reg_data_type == VKD3D_DATA_UAV)
ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT;
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.semantic.register_space);
}
static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction *ins,
DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
struct vkd3d_sm4_data *priv)
{
shader_sm4_read_src_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_FLOAT, &ins->declaration.src);
const DWORD *end = &tokens[token_count];
shader_sm4_read_src_param(priv, &tokens, end, VKD3D_DATA_FLOAT, &ins->declaration.cb.src);
if (opcode_token & VKD3D_SM4_INDEX_TYPE_MASK)
ins->flags |= VKD3DSI_INDEXED_DYNAMIC;
ins->declaration.cb.size = ins->declaration.cb.src.reg.idx[1].offset;
ins->declaration.cb.register_space = 0;
if (shader_is_sm_5_1(priv))
{
if (tokens >= end)
{
FIXME("Invalid ptr %p >= end %p.\n", tokens, end);
return;
}
ins->declaration.cb.size = *tokens++;
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.cb.register_space);
}
}
static void shader_sm4_read_dcl_sampler(struct vkd3d_shader_instruction *ins,
DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
struct vkd3d_sm4_data *priv)
{
const DWORD *end = &tokens[token_count];
ins->flags = (opcode_token & VKD3D_SM4_SAMPLER_MODE_MASK) >> VKD3D_SM4_SAMPLER_MODE_SHIFT;
if (ins->flags & ~VKD3D_SM4_SAMPLER_COMPARISON)
FIXME("Unhandled sampler mode %#x.\n", ins->flags);
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_SAMPLER, &ins->declaration.dst);
shader_sm4_read_src_param(priv, &tokens, end, VKD3D_DATA_SAMPLER, &ins->declaration.sampler.src);
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.sampler.register_space);
}
static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins,
@ -808,20 +858,25 @@ static void shader_sm5_read_dcl_uav_raw(struct vkd3d_shader_instruction *ins,
DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
struct vkd3d_sm4_data *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_UAV, &ins->declaration.dst);
const DWORD *end = &tokens[token_count];
shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &ins->declaration.raw_resource.dst);
ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT;
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.raw_resource.register_space);
}
static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction *ins,
DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
struct vkd3d_sm4_data *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_UAV,
&ins->declaration.structured_resource.reg);
const DWORD *end = &tokens[token_count];
shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &ins->declaration.structured_resource.reg);
ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT;
ins->declaration.structured_resource.byte_stride = *tokens;
if (ins->declaration.structured_resource.byte_stride % 4)
FIXME("Byte stride %u is not multiple of 4.\n", ins->declaration.structured_resource.byte_stride);
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.structured_resource.register_space);
}
static void shader_sm5_read_dcl_tgsm_raw(struct vkd3d_shader_instruction *ins,
@ -850,18 +905,23 @@ static void shader_sm5_read_dcl_resource_structured(struct vkd3d_shader_instruct
DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
struct vkd3d_sm4_data *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_RESOURCE,
&ins->declaration.structured_resource.reg);
const DWORD *end = &tokens[token_count];
shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &ins->declaration.structured_resource.reg);
ins->declaration.structured_resource.byte_stride = *tokens;
if (ins->declaration.structured_resource.byte_stride % 4)
FIXME("Byte stride %u is not multiple of 4.\n", ins->declaration.structured_resource.byte_stride);
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.structured_resource.register_space);
}
static void shader_sm5_read_dcl_resource_raw(struct vkd3d_shader_instruction *ins,
DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
struct vkd3d_sm4_data *priv)
{
shader_sm4_read_dst_param(priv, &tokens, &tokens[token_count], VKD3D_DATA_RESOURCE, &ins->declaration.dst);
const DWORD *end = &tokens[token_count];
shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &ins->declaration.dst);
shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.raw_resource.register_space);
}
static void shader_sm5_read_sync(struct vkd3d_shader_instruction *ins,
@ -1470,8 +1530,26 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr
}
}
if (order > 2)
FIXME("Unhandled order %u.\n", order);
if (order < 3)
{
param->idx[2].offset = ~0u;
param->idx[2].rel_addr = NULL;
}
else
{
DWORD addressing = (token & VKD3D_SM4_ADDRESSING_MASK2) >> VKD3D_SM4_ADDRESSING_SHIFT2;
if (!(shader_sm4_read_reg_idx(priv, ptr, end, addressing, &param->idx[2])))
{
ERR("Failed to read register index.\n");
return false;
}
}
if (order > 3)
{
WARN("Unhandled order %u.\n", order);
return false;
}
if (register_type == VKD3D_SM4_RT_IMMCONST)
{

54
libs/vkd3d-shader/spirv.c
View File

@ -4671,39 +4671,42 @@ static void vkd3d_dxbc_compiler_emit_dcl_constant_buffer(struct vkd3d_dxbc_compi
const struct vkd3d_shader_instruction *instruction)
{
uint32_t vec4_id, array_type_id, length_id, struct_id, pointer_type_id, var_id;
const struct vkd3d_shader_register *reg = &instruction->declaration.src.reg;
const struct vkd3d_shader_constant_buffer *cb = &instruction->declaration.cb;
struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
const SpvStorageClass storage_class = SpvStorageClassUniform;
const struct vkd3d_shader_register *reg = &cb->src.reg;
struct vkd3d_push_constant_buffer_binding *push_cb;
struct vkd3d_symbol reg_symbol;
unsigned int cb_size;
assert(!(instruction->flags & ~VKD3DSI_INDEXED_DYNAMIC));
cb_size = reg->idx[1].offset;
if (cb->register_space)
FIXME("Unhandled register space %u.\n", cb->register_space);
if ((push_cb = vkd3d_dxbc_compiler_find_push_constant_buffer(compiler, reg)))
{
/* Push constant buffers are handled in
* vkd3d_dxbc_compiler_emit_push_constant_buffers().
*/
unsigned int cb_size_in_bytes = cb_size * VKD3D_VEC4_SIZE * sizeof(uint32_t);
unsigned int cb_size_in_bytes = cb->size * VKD3D_VEC4_SIZE * sizeof(uint32_t);
push_cb->reg = *reg;
if (cb_size_in_bytes > push_cb->pc.size)
{
WARN("Constant buffer size %u exceeds push constant size %u.\n",
cb_size_in_bytes, push_cb->pc.size);
}
return;
}
vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_TYPE_FLOAT, VKD3D_VEC4_SIZE);
length_id = vkd3d_dxbc_compiler_get_constant_uint(compiler, cb_size);
length_id = vkd3d_dxbc_compiler_get_constant_uint(compiler, cb->size);
array_type_id = vkd3d_spirv_build_op_type_array(builder, vec4_id, length_id);
vkd3d_spirv_build_op_decorate1(builder, array_type_id, SpvDecorationArrayStride, 16);
struct_id = vkd3d_spirv_build_op_type_struct(builder, &array_type_id, 1);
vkd3d_spirv_build_op_decorate(builder, struct_id, SpvDecorationBlock, NULL, 0);
vkd3d_spirv_build_op_member_decorate1(builder, struct_id, 0, SpvDecorationOffset, 0);
vkd3d_spirv_build_op_name(builder, struct_id, "cb%u_struct", cb_size);
vkd3d_spirv_build_op_name(builder, struct_id, "cb%u_struct", cb->size);
pointer_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, struct_id);
var_id = vkd3d_spirv_build_op_variable(builder, &builder->global_stream,
@ -4756,12 +4759,15 @@ static void vkd3d_dxbc_compiler_emit_dcl_immediate_constant_buffer(struct vkd3d_
static void vkd3d_dxbc_compiler_emit_dcl_sampler(struct vkd3d_dxbc_compiler *compiler,
const struct vkd3d_shader_instruction *instruction)
{
const struct vkd3d_shader_register *reg = &instruction->declaration.dst.reg;
const struct vkd3d_shader_register *reg = &instruction->declaration.sampler.src.reg;
const SpvStorageClass storage_class = SpvStorageClassUniformConstant;
struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
uint32_t type_id, ptr_type_id, var_id;
struct vkd3d_symbol reg_symbol;
if (instruction->declaration.sampler.register_space)
FIXME("Unhandled register space %u.\n", instruction->declaration.sampler.register_space);
if (vkd3d_dxbc_compiler_has_combined_sampler(compiler, NULL, reg))
return;
@ -4980,6 +4986,10 @@ static void vkd3d_dxbc_compiler_emit_dcl_resource(struct vkd3d_dxbc_compiler *co
const struct vkd3d_shader_instruction *instruction)
{
const struct vkd3d_shader_semantic *semantic = &instruction->declaration.semantic;
if (semantic->register_space)
FIXME("Unhandled register space %u.\n", semantic->register_space);
vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &semantic->reg.reg,
semantic->resource_type, semantic->resource_data_type, 0, false);
}
@ -4987,25 +4997,38 @@ static void vkd3d_dxbc_compiler_emit_dcl_resource(struct vkd3d_dxbc_compiler *co
static void vkd3d_dxbc_compiler_emit_dcl_resource_raw(struct vkd3d_dxbc_compiler *compiler,
const struct vkd3d_shader_instruction *instruction)
{
vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &instruction->declaration.dst.reg,
const struct vkd3d_shader_raw_resource *resource = &instruction->declaration.raw_resource;
if (resource->register_space)
FIXME("Unhandled register space %u.\n", resource->register_space);
vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &resource->dst.reg,
VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, 0, true);
}
static void vkd3d_dxbc_compiler_emit_dcl_uav_raw(struct vkd3d_dxbc_compiler *compiler,
const struct vkd3d_shader_instruction *instruction)
{
const struct vkd3d_shader_raw_resource *resource = &instruction->declaration.raw_resource;
if (resource->register_space)
FIXME("Unhandled register space %u.\n", resource->register_space);
if (instruction->flags)
FIXME("Unhandled UAV flags %#x.\n", instruction->flags);
vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &instruction->declaration.dst.reg,
vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &resource->dst.reg,
VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, 0, true);
}
static void vkd3d_dxbc_compiler_emit_dcl_resource_structured(struct vkd3d_dxbc_compiler *compiler,
const struct vkd3d_shader_instruction *instruction)
{
const struct vkd3d_shader_register *reg = &instruction->declaration.structured_resource.reg.reg;
unsigned int stride = instruction->declaration.structured_resource.byte_stride;
const struct vkd3d_shader_structured_resource *resource = &instruction->declaration.structured_resource;
const struct vkd3d_shader_register *reg = &resource->reg.reg;
unsigned int stride = resource->byte_stride;
if (resource->register_space)
FIXME("Unhandled register space %u.\n", resource->register_space);
vkd3d_dxbc_compiler_emit_resource_declaration(compiler, reg,
VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, stride / 4, false);
@ -5014,9 +5037,12 @@ static void vkd3d_dxbc_compiler_emit_dcl_resource_structured(struct vkd3d_dxbc_c
static void vkd3d_dxbc_compiler_emit_dcl_uav_structured(struct vkd3d_dxbc_compiler *compiler,
const struct vkd3d_shader_instruction *instruction)
{
const struct vkd3d_shader_register *reg = &instruction->declaration.structured_resource.reg.reg;
unsigned int stride = instruction->declaration.structured_resource.byte_stride;
const struct vkd3d_shader_structured_resource *resource = &instruction->declaration.structured_resource;
const struct vkd3d_shader_register *reg = &resource->reg.reg;
unsigned int stride = resource->byte_stride;
if (resource->register_space)
FIXME("Unhandled register space %u.\n", resource->register_space);
if (instruction->flags)
FIXME("Unhandled UAV flags %#x.\n", instruction->flags);
@ -5029,6 +5055,8 @@ static void vkd3d_dxbc_compiler_emit_dcl_uav_typed(struct vkd3d_dxbc_compiler *c
{
const struct vkd3d_shader_semantic *semantic = &instruction->declaration.semantic;
if (semantic->register_space)
FIXME("Unhandled register space %u.\n", semantic->register_space);
if (instruction->flags)
FIXME("Unhandled UAV flags %#x.\n", instruction->flags);

35
libs/vkd3d-shader/trace.c
View File

@ -1042,6 +1042,17 @@ static void shader_dump_register(struct vkd3d_string_buffer *buffer,
}
shader_addline(buffer, "%u]", reg->idx[1].offset);
}
if (reg->idx[2].offset != ~0u)
{
shader_addline(buffer, "[");
if (reg->idx[2].rel_addr)
{
shader_dump_src_param(buffer, reg->idx[2].rel_addr, shader_version);
shader_addline(buffer, " + ");
}
shader_addline(buffer, "%u]", reg->idx[2].offset);
}
}
if (reg->type == VKD3DSPR_FUNCTIONPOINTER)
@ -1333,6 +1344,13 @@ static void shader_dump_instruction_flags(struct vkd3d_string_buffer *buffer,
}
}
static void shader_dump_register_space(struct vkd3d_string_buffer *buffer,
unsigned int register_space, const struct vkd3d_shader_version *shader_version)
{
if (shader_version->major >= 5 && shader_version->minor >= 1)
shader_addline(buffer, ", space=%u", register_space);
}
static void shader_dump_instruction(struct vkd3d_string_buffer *buffer,
const struct vkd3d_shader_instruction *ins, const struct vkd3d_shader_version *shader_version)
{
@ -1346,13 +1364,17 @@ static void shader_dump_instruction(struct vkd3d_string_buffer *buffer,
shader_dump_ins_modifiers(buffer, &ins->declaration.semantic.reg);
shader_addline(buffer, " ");
shader_dump_dst_param(buffer, &ins->declaration.semantic.reg, shader_version);
shader_dump_register_space(buffer, ins->declaration.semantic.register_space, shader_version);
break;
case VKD3DSIH_DCL_CONSTANT_BUFFER:
shader_addline(buffer, "%s ", shader_opcode_names[ins->handler_idx]);
shader_dump_src_param(buffer, &ins->declaration.src, shader_version);
shader_dump_src_param(buffer, &ins->declaration.cb.src, shader_version);
if (shader_version->major >= 5 && shader_version->minor >= 1)
shader_addline(buffer, "[%u]", ins->declaration.cb.size);
shader_addline(buffer, ", %s",
ins->flags & VKD3DSI_INDEXED_DYNAMIC ? "dynamicIndexed" : "immediateIndexed");
shader_dump_register_space(buffer, ins->declaration.cb.register_space, shader_version);
break;
case VKD3DSIH_DCL_FUNCTION_BODY:
@ -1447,20 +1469,23 @@ static void shader_dump_instruction(struct vkd3d_string_buffer *buffer,
case VKD3DSIH_DCL_RESOURCE_RAW:
shader_addline(buffer, "%s ", shader_opcode_names[ins->handler_idx]);
shader_dump_dst_param(buffer, &ins->declaration.dst, shader_version);
shader_dump_dst_param(buffer, &ins->declaration.raw_resource.dst, shader_version);
shader_dump_register_space(buffer, ins->declaration.raw_resource.register_space, shader_version);
break;
case VKD3DSIH_DCL_RESOURCE_STRUCTURED:
shader_addline(buffer, "%s ", shader_opcode_names[ins->handler_idx]);
shader_dump_dst_param(buffer, &ins->declaration.structured_resource.reg, shader_version);
shader_addline(buffer, ", %u", ins->declaration.structured_resource.byte_stride);
shader_dump_register_space(buffer, ins->declaration.structured_resource.register_space, shader_version);
break;
case VKD3DSIH_DCL_SAMPLER:
shader_addline(buffer, "%s ", shader_opcode_names[ins->handler_idx]);
shader_dump_dst_param(buffer, &ins->declaration.dst, shader_version);
shader_dump_src_param(buffer, &ins->declaration.sampler.src, shader_version);
if (ins->flags == VKD3DSI_SAMPLER_COMPARISON_MODE)
shader_addline(buffer, ", comparisonMode");
shader_dump_register_space(buffer, ins->declaration.sampler.register_space, shader_version);
break;
case VKD3DSIH_DCL_TEMPS:
@ -1512,7 +1537,8 @@ static void shader_dump_instruction(struct vkd3d_string_buffer *buffer,
shader_addline(buffer, "%s", shader_opcode_names[ins->handler_idx]);
shader_dump_uav_flags(buffer, ins->flags);
shader_addline(buffer, " ");
shader_dump_dst_param(buffer, &ins->declaration.dst, shader_version);
shader_dump_dst_param(buffer, &ins->declaration.raw_resource.dst, shader_version);
shader_dump_register_space(buffer, ins->declaration.raw_resource.register_space, shader_version);
break;
case VKD3DSIH_DCL_UAV_STRUCTURED:
@ -1521,6 +1547,7 @@ static void shader_dump_instruction(struct vkd3d_string_buffer *buffer,
shader_addline(buffer, " ");
shader_dump_dst_param(buffer, &ins->declaration.structured_resource.reg, shader_version);
shader_addline(buffer, ", %u", ins->declaration.structured_resource.byte_stride);
shader_dump_register_space(buffer, ins->declaration.structured_resource.register_space, shader_version);
break;
case VKD3DSIH_DEF:

27
libs/vkd3d-shader/vkd3d_shader_private.h
View File

@ -558,7 +558,7 @@ struct vkd3d_shader_register
{
enum vkd3d_shader_register_type type;
enum vkd3d_data_type data_type;
struct vkd3d_shader_register_index idx[2];
struct vkd3d_shader_register_index idx[3];
enum vkd3d_immconst_type immconst_type;
union
{
@ -614,6 +614,7 @@ struct vkd3d_shader_semantic
enum vkd3d_shader_resource_type resource_type;
enum vkd3d_data_type resource_data_type;
struct vkd3d_shader_dst_param reg;
unsigned int register_space;
};
enum vkd3d_shader_input_sysval_semantic
@ -658,10 +659,30 @@ struct vkd3d_shader_register_semantic
enum vkd3d_shader_input_sysval_semantic sysval_semantic;
};
struct vkd3d_shader_sampler
{
struct vkd3d_shader_src_param src;
unsigned int register_space;
};
struct vkd3d_shader_constant_buffer
{
struct vkd3d_shader_src_param src;
unsigned int size;
unsigned int register_space;
};
struct vkd3d_shader_structured_resource
{
struct vkd3d_shader_dst_param reg;
unsigned int byte_stride;
unsigned int register_space;
};
struct vkd3d_shader_raw_resource
{
struct vkd3d_shader_dst_param dst;
unsigned int register_space;
};
struct vkd3d_shader_tgsm
@ -741,10 +762,12 @@ struct vkd3d_shader_instruction
struct vkd3d_shader_register_semantic register_semantic;
struct vkd3d_shader_primitive_type primitive_type;
struct vkd3d_shader_dst_param dst;
struct vkd3d_shader_src_param src;
struct vkd3d_shader_constant_buffer cb;
struct vkd3d_shader_sampler sampler;
unsigned int count;
unsigned int index;
const struct vkd3d_shader_immediate_constant_buffer *icb;
struct vkd3d_shader_raw_resource raw_resource;
struct vkd3d_shader_structured_resource structured_resource;
struct vkd3d_shader_tgsm_raw tgsm_raw;
struct vkd3d_shader_tgsm_structured tgsm_structured;