libs/vkd3d-shader: Avoid Windows data types in public API.

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>

include/vkd3d_shader.h

@@ -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,

libs/vkd3d-shader/spirv.c

@@ -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)

libs/vkd3d-shader/vkd3d_shader_main.c

@@ -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);
+        WARN("Failed to extract shader, vkd3d result %d.\n", ret);
-        return hr;
+        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)))
+    if ((ret = vkd3d_shader_scan_dxbc(dxbc, &scan_info)) < 0)
-        return hr;
+        return ret;
 
-    if (FAILED(hr = vkd3d_shader_parser_init(&parser, dxbc)))
+    if ((ret = vkd3d_shader_parser_init(&parser, dxbc)) < 0)
-        return hr;
+        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;
-    return ret ? S_OK : E_FAIL;
 }
 
 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)))
+    if ((ret = vkd3d_shader_parser_init(&parser, dxbc)) < 0)
-        return hr;
+        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);

libs/vkd3d-shader/vkd3d_shader_private.h

@@ -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;
 

libs/vkd3d/state.c

@@ -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);
+        WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
-        return hr;
+        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);
+        WARN("Failed to compile shader, vkd3d result %d.\n", ret);
-        return hr;
+        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);
+        WARN("Failed to scan shader bytecode, vkd3d result %d.\n", ret);
-        return hr;
+        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);
+            WARN("Failed to scan shader bytecode, stage %#x, vkd3d result %d.\n",
-            hr = E_FAIL;
+                    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;
     }

libs/vkd3d/utils.c

@@ -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))) \
     { \

libs/vkd3d/vkd3d_main.c

@@ -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);
+        WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
-        return hr;
+        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);
+        WARN("Failed to serialize root signature, vkd3d result %d.\n", ret);
-        return hr;
+        return hresult_from_vkd3d_result(ret);
     }
 
     if (FAILED(hr = d3d_blob_create((void *)dxbc.code, dxbc.size, &blob_object)))

libs/vkd3d/vkd3d_private.h

@@ -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;