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: Avoid Windows data types in public API.

Browse Source 
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:52 +01:00
committed by Alexandre Julliard
parent fddf86e6ea
commit 844c83a837
9 changed files with 252 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
include/vkd3d_shader.h
View File

@ -19,7 +19,8 @@
#ifndef __VKD3D_SHADER_H
#define __VKD3D_SHADER_H
#include "vkd3d.h"
#include <stdbool.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
@ -27,6 +28,17 @@ extern "C" {
#define VKD3D_FORCE_32_BIT_ENUM(name) name##_FORCE_32BIT = 0x7fffffff
enum vkd3d_result
{
VKD3D_OK = 0,
VKD3D_ERROR = -1, /* unspecified failure */
VKD3D_ERROR_OUT_OF_MEMORY = -2,
VKD3D_ERROR_INVALID_ARGUMENT = -3,
VKD3D_ERROR_NOT_IMPLEMENTED = -4,
VKD3D_FORCE_32_BIT_ENUM(VKD3D_RESULT),
};
enum vkd3d_shader_compiler_option
{
VKD3D_SHADER_STRIP_DEBUG = 0x00000001,
@ -113,7 +125,7 @@ struct vkd3d_shader_interface
unsigned int uav_counter_count;
};
HRESULT vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
int vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
struct vkd3d_shader_code *spirv, uint32_t compiler_options,
const struct vkd3d_shader_interface *shader_interface);
void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
@ -295,7 +307,7 @@ struct vkd3d_root_signature_desc
enum vkd3d_root_signature_flags flags;
};
HRESULT vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
struct vkd3d_root_signature_desc *root_signature);
void vkd3d_shader_free_root_signature(struct vkd3d_root_signature_desc *root_signature);
@ -306,7 +318,7 @@ enum vkd3d_root_signature_version
VKD3D_FORCE_32_BIT_ENUM(VKD3D_ROOT_SIGNATURE_VERSION),
};
HRESULT vkd3d_shader_serialize_root_signature(const struct vkd3d_root_signature_desc *root_signature,
int vkd3d_shader_serialize_root_signature(const struct vkd3d_root_signature_desc *root_signature,
enum vkd3d_root_signature_version version, struct vkd3d_shader_code *dxbc);
#define VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS 8
@ -317,7 +329,7 @@ struct vkd3d_shader_scan_info
unsigned int uav_counter_mask : VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS;
};
HRESULT vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc,
int vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc,
struct vkd3d_shader_scan_info *scan_info);
enum vkd3d_component_type
@ -362,7 +374,7 @@ struct vkd3d_shader_signature_element
enum vkd3d_sysval_semantic sysval_semantic;
enum vkd3d_component_type component_type;
unsigned int register_index;
DWORD mask;
unsigned int mask;
};
struct vkd3d_shader_signature
@ -371,7 +383,7 @@ struct vkd3d_shader_signature
unsigned int element_count;
};
HRESULT vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
struct vkd3d_shader_signature *signature);
struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element(
const struct vkd3d_shader_signature *signature, const char *semantic_name,

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

File diff suppressed because it is too large Load Diff

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

@ -5951,7 +5951,7 @@ static void vkd3d_dxbc_compiler_emit_output_setup_function(struct vkd3d_dxbc_com
vkd3d_spirv_build_op_function_end(builder);
}
bool vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
int vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
struct vkd3d_shader_code *spirv)
{
struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
@ -5965,7 +5965,7 @@ bool vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
vkd3d_dxbc_compiler_emit_output_setup_function(compiler);
if (!vkd3d_spirv_compile_module(builder, spirv))
return false;
return VKD3D_ERROR;
if (TRACE_ON())
{
@ -5973,7 +5973,7 @@ bool vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
vkd3d_spirv_validate(spirv);
}
return true;
return VKD3D_OK;
}
void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler)

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

@ -26,16 +26,16 @@ struct vkd3d_shader_parser
const DWORD *ptr;
};
static HRESULT vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
static int vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
const struct vkd3d_shader_code *dxbc)
{
struct vkd3d_shader_desc *shader_desc = &parser->shader_desc;
HRESULT hr;
int ret;
if (FAILED(hr = shader_extract_from_dxbc(dxbc->code, dxbc->size, shader_desc)))
if ((ret = shader_extract_from_dxbc(dxbc->code, dxbc->size, shader_desc)) < 0)
{
WARN("Failed to extract shader, hr %#x.\n", hr);
return hr;
WARN("Failed to extract shader, vkd3d result %d.\n", ret);
return ret;
}
if (!(parser->data = shader_sm4_init(shader_desc->byte_code,
@ -43,11 +43,11 @@ static HRESULT vkd3d_shader_parser_init(struct vkd3d_shader_parser *parser,
{
WARN("Failed to initialize shader parser.\n");
free_shader_desc(shader_desc);
return E_INVALIDARG;
return VKD3D_ERROR_INVALID_ARGUMENT;
}
shader_sm4_read_header(parser->data, &parser->ptr, &parser->shader_version);
return S_OK;
return VKD3D_OK;
}
static void vkd3d_shader_parser_destroy(struct vkd3d_shader_parser *parser)
@ -56,7 +56,7 @@ static void vkd3d_shader_parser_destroy(struct vkd3d_shader_parser *parser)
free_shader_desc(&parser->shader_desc);
}
HRESULT vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
int vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
struct vkd3d_shader_code *spirv, uint32_t compiler_options,
const struct vkd3d_shader_interface *shader_interface)
{
@ -64,24 +64,23 @@ HRESULT vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
struct vkd3d_dxbc_compiler *spirv_compiler;
struct vkd3d_shader_scan_info scan_info;
struct vkd3d_shader_parser parser;
HRESULT hr;
bool ret;
TRACE("dxbc {%p, %zu}, spirv %p, compiler_options %#x, shader_interface %p.\n",
dxbc->code, dxbc->size, spirv, compiler_options, shader_interface);
if (FAILED(hr = vkd3d_shader_scan_dxbc(dxbc, &scan_info)))
return hr;
if ((ret = vkd3d_shader_scan_dxbc(dxbc, &scan_info)) < 0)
return ret;
if (FAILED(hr = vkd3d_shader_parser_init(&parser, dxbc)))
return hr;
if ((ret = vkd3d_shader_parser_init(&parser, dxbc)) < 0)
return ret;
if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser.shader_version,
&parser.shader_desc, compiler_options, shader_interface, &scan_info)))
{
ERR("Failed to create DXBC compiler.\n");
vkd3d_shader_parser_destroy(&parser);
return hr;
return VKD3D_ERROR;
}
while (!shader_sm4_is_end(parser.data, &parser.ptr))
@ -93,7 +92,7 @@ HRESULT vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
WARN("Encountered unrecognized or invalid instruction.\n");
vkd3d_dxbc_compiler_destroy(spirv_compiler);
vkd3d_shader_parser_destroy(&parser);
return E_FAIL;
return VKD3D_ERROR_INVALID_ARGUMENT;
}
vkd3d_dxbc_compiler_handle_instruction(spirv_compiler, &instruction);
@ -102,8 +101,7 @@ HRESULT vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
ret = vkd3d_dxbc_compiler_generate_spirv(spirv_compiler, spirv);
vkd3d_dxbc_compiler_destroy(spirv_compiler);
vkd3d_shader_parser_destroy(&parser);
return ret ? S_OK : E_FAIL;
return ret;
}
static bool vkd3d_shader_instruction_is_uav_read(const struct vkd3d_shader_instruction *instruction)
@ -160,17 +158,17 @@ static void vkd3d_shader_scan_handle_instruction(struct vkd3d_shader_scan_info *
vkd3d_shader_scan_record_uav_counter(scan_info, &instruction->src[0].reg);
}
HRESULT vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc,
int vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc,
struct vkd3d_shader_scan_info *scan_info)
{
struct vkd3d_shader_instruction instruction;
struct vkd3d_shader_parser parser;
HRESULT hr;
int ret;
TRACE("dxbc {%p, %zu}, scan_info %p.\n", dxbc->code, dxbc->size, scan_info);
if (FAILED(hr = vkd3d_shader_parser_init(&parser, dxbc)))
return hr;
if ((ret = vkd3d_shader_parser_init(&parser, dxbc)) < 0)
return ret;
memset(scan_info, 0, sizeof(*scan_info));
@ -182,14 +180,14 @@ HRESULT vkd3d_shader_scan_dxbc(const struct vkd3d_shader_code *dxbc,
{
WARN("Encountered unrecognized or invalid instruction.\n");
vkd3d_shader_parser_destroy(&parser);
return E_FAIL;
return VKD3D_ERROR_INVALID_ARGUMENT;
}
vkd3d_shader_scan_handle_instruction(scan_info, &instruction);
}
vkd3d_shader_parser_destroy(&parser);
return S_OK;
return VKD3D_OK;
}
void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code)
@ -217,7 +215,7 @@ void vkd3d_shader_free_root_signature(struct vkd3d_root_signature_desc *root_sig
memset(root_signature, 0, sizeof(*root_signature));
}
HRESULT vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc,
struct vkd3d_shader_signature *signature)
{
TRACE("dxbc {%p, %zu}, signature %p.\n", dxbc->code, dxbc->size, signature);

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

@ -768,11 +768,11 @@ void shader_sm4_read_instruction(void *data, const DWORD **ptr,
struct vkd3d_shader_instruction *ins) DECLSPEC_HIDDEN;
BOOL shader_sm4_is_end(void *data, const DWORD **ptr) DECLSPEC_HIDDEN;
HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length,
int shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length,
struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN;
void free_shader_desc(struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN;
HRESULT shader_parse_input_signature(const void *dxbc, SIZE_T dxbc_length,
int shader_parse_input_signature(const void *dxbc, SIZE_T dxbc_length,
struct vkd3d_shader_signature *signature) DECLSPEC_HIDDEN;
struct vkd3d_dxbc_compiler;
@ -783,7 +783,7 @@ struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader
const struct vkd3d_shader_scan_info *scan_info) DECLSPEC_HIDDEN;
void vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler,
const struct vkd3d_shader_instruction *instruction) DECLSPEC_HIDDEN;
bool vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
int vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler,
struct vkd3d_shader_code *spirv) DECLSPEC_HIDDEN;
void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler) DECLSPEC_HIDDEN;

35
libs/vkd3d/state.c
View File

@ -1013,11 +1013,12 @@ HRESULT d3d12_root_signature_create(struct d3d12_device *device,
} root_signature_desc;
struct d3d12_root_signature *object;
HRESULT hr;
int ret;
if (FAILED(hr = vkd3d_shader_parse_root_signature(&dxbc, &root_signature_desc.vkd3d)))
if ((ret = vkd3d_shader_parse_root_signature(&dxbc, &root_signature_desc.vkd3d)) < 0)
{
WARN("Failed to parse root signature, hr %#x.\n", hr);
return hr;
WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
return hresult_from_vkd3d_result(ret);
}
if (!(object = vkd3d_malloc(sizeof(*object))))
@ -1269,7 +1270,7 @@ static HRESULT create_shader_stage(struct d3d12_device *device,
struct VkShaderModuleCreateInfo shader_desc;
struct vkd3d_shader_code spirv = {};
VkResult vr;
HRESULT hr;
int ret;
stage_desc->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stage_desc->pNext = NULL;
@ -1283,10 +1284,10 @@ static HRESULT create_shader_stage(struct d3d12_device *device,
shader_desc.flags = 0;
dump_shader_stage(stage, code->pShaderBytecode, code->BytecodeLength);
if (FAILED(hr = vkd3d_shader_compile_dxbc(&dxbc, &spirv, 0, shader_interface)))
if ((ret = vkd3d_shader_compile_dxbc(&dxbc, &spirv, 0, shader_interface)) < 0)
{
WARN("Failed to compile shader, hr %#x.\n", hr);
return hr;
WARN("Failed to compile shader, vkd3d result %d.\n", ret);
return hresult_from_vkd3d_result(ret);
}
shader_desc.codeSize = spirv.size;
shader_desc.pCode = spirv.code;
@ -1389,6 +1390,7 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st
struct vkd3d_shader_code dxbc;
VkResult vr;
HRESULT hr;
int ret;
state->ID3D12PipelineState_iface.lpVtbl = &d3d12_pipeline_state_vtbl;
state->refcount = 1;
@ -1406,10 +1408,10 @@ static HRESULT d3d12_pipeline_state_init_compute(struct d3d12_pipeline_state *st
dxbc.code = desc->CS.pShaderBytecode;
dxbc.size = desc->CS.BytecodeLength;
if (FAILED(hr = vkd3d_shader_scan_dxbc(&dxbc, &shader_info)))
if ((ret = vkd3d_shader_scan_dxbc(&dxbc, &shader_info)) < 0)
{
WARN("Failed to scan shader bytecode, hr %#x.\n", hr);
return hr;
WARN("Failed to scan shader bytecode, vkd3d result %d.\n", ret);
return hresult_from_vkd3d_result(ret);
}
if (FAILED(hr = d3d12_pipeline_state_init_compute_uav_counters(state,
@ -1802,6 +1804,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s
uint32_t mask;
VkResult vr;
HRESULT hr;
int ret;
static const struct
{
@ -1849,10 +1852,11 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s
if (!b->pShaderBytecode)
continue;
if (FAILED(hr = vkd3d_shader_scan_dxbc(&dxbc, &shader_info)))
if ((ret = vkd3d_shader_scan_dxbc(&dxbc, &shader_info)) < 0)
{
WARN("Failed to scan shader bytecode, stage %#x, hr %#x.\n", shader_stages[i].stage, hr);
hr = E_FAIL;
WARN("Failed to scan shader bytecode, stage %#x, vkd3d result %d.\n",
shader_stages[i].stage, ret);
hr = hresult_from_vkd3d_result(ret);
goto fail;
}
if (shader_info.uav_counter_mask)
@ -1863,8 +1867,11 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s
goto fail;
if (shader_stages[i].stage == VK_SHADER_STAGE_VERTEX_BIT
&& FAILED(hr = vkd3d_shader_parse_input_signature(&dxbc, &input_signature)))
&& (ret = vkd3d_shader_parse_input_signature(&dxbc, &input_signature)) < 0)
{
hr = hresult_from_vkd3d_result(ret);
goto fail;
}
++graphics->stage_count;
}

20
libs/vkd3d/utils.c
View File

@ -351,6 +351,26 @@ HRESULT hresult_from_vk_result(VkResult vr)
}
}
HRESULT hresult_from_vkd3d_result(int vkd3d_result)
{
switch (vkd3d_result)
{
case VKD3D_OK:
return S_OK;
case VKD3D_ERROR:
return E_FAIL;
case VKD3D_ERROR_OUT_OF_MEMORY:
return E_OUTOFMEMORY;
case VKD3D_ERROR_INVALID_ARGUMENT:
return E_INVALIDARG;
case VKD3D_ERROR_NOT_IMPLEMENTED:
return E_NOTIMPL;
default:
FIXME("Unhandled vkd3d result %d.\n", vkd3d_result);
return E_FAIL;
}
}
#define LOAD_GLOBAL_PFN(name) \
if (!(procs->name = (void *)vkGetInstanceProcAddr(NULL, #name))) \
{ \

17
libs/vkd3d/vkd3d_main.c
View File

@ -162,15 +162,15 @@ static const struct ID3D12RootSignatureDeserializerVtbl d3d12_root_signature_des
static HRESULT d3d12_root_signature_deserializer_init(struct d3d12_root_signature_deserializer *deserializer,
const struct vkd3d_shader_code *dxbc)
{
HRESULT hr;
int ret;
deserializer->ID3D12RootSignatureDeserializer_iface.lpVtbl = &d3d12_root_signature_deserializer_vtbl;
deserializer->refcount = 1;
if (FAILED(hr = vkd3d_shader_parse_root_signature(dxbc, &deserializer->desc.vkd3d)))
if ((ret = vkd3d_shader_parse_root_signature(dxbc, &deserializer->desc.vkd3d)) < 0)
{
WARN("Failed to parse root signature, hr %#x.\n", hr);
return hr;
WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
return hresult_from_vkd3d_result(ret);
}
return S_OK;
@ -319,6 +319,7 @@ HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *root_sig
struct vkd3d_shader_code dxbc;
struct d3d_blob *blob_object;
HRESULT hr;
int ret;
TRACE("root_signature_desc %p, version %#x, blob %p, error_blob %p.\n",
root_signature_desc, version, blob, error_blob);
@ -335,12 +336,12 @@ HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *root_sig
*error_blob = NULL;
}
if (FAILED(hr = vkd3d_shader_serialize_root_signature(
if ((ret = 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)) < 0)
{
WARN("Failed to serialize root signature, hr %#x.\n", hr);
return hr;
WARN("Failed to serialize root signature, vkd3d result %d.\n", ret);
return hresult_from_vkd3d_result(ret);
}
if (FAILED(hr = d3d_blob_create((void *)dxbc.code, dxbc.size, &blob_object)))

1
libs/vkd3d/vkd3d_private.h
View File

@ -767,6 +767,7 @@ const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags) DECLSPEC
const char *debug_vk_queue_flags(VkQueueFlags flags) DECLSPEC_HIDDEN;
HRESULT hresult_from_vk_result(VkResult vr) DECLSPEC_HIDDEN;
HRESULT hresult_from_vkd3d_result(int vkd3d_result) DECLSPEC_HIDDEN;
HRESULT vkd3d_load_vk_global_procs(struct vkd3d_vk_global_procs *procs,
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) DECLSPEC_HIDDEN;