diff options
Diffstat (limited to 'third_party/rust/spirv-cross-internal/src/wrapper.cpp')
| -rw-r--r-- | third_party/rust/spirv-cross-internal/src/wrapper.cpp | 543 |
1 files changed, 543 insertions, 0 deletions
diff --git a/third_party/rust/spirv-cross-internal/src/wrapper.cpp b/third_party/rust/spirv-cross-internal/src/wrapper.cpp new file mode 100644 index 0000000000..d9c7ad8915 --- /dev/null +++ b/third_party/rust/spirv-cross-internal/src/wrapper.cpp @@ -0,0 +1,543 @@ +#pragma GCC diagnostic ignored "-Wunknown-pragmas" +#pragma warning(disable : 4996 4101) + +#include "vendor/SPIRV-Cross/spirv_cross_util.hpp" +#include "vendor/SPIRV-Cross/spirv_hlsl.hpp" +#include "vendor/SPIRV-Cross/spirv_msl.hpp" +#include "vendor/SPIRV-Cross/spirv_glsl.hpp" +#include "wrapper.hpp" + +static const char *latest_exception_message; + +#ifdef SPIRV_CROSS_WRAPPER_NO_EXCEPTIONS +#define INTERNAL_RESULT(block_to_attempt) \ + do \ + { \ + { \ + block_to_attempt \ + } \ + return ScInternalResult::Success; \ + } while (0); +#else +#define INTERNAL_RESULT(block_to_attempt) \ + do \ + { \ + try \ + { \ + { \ + block_to_attempt \ + } \ + return ScInternalResult::Success; \ + } \ + catch (const spirv_cross::CompilerError &ex) \ + { \ + latest_exception_message = strdup(ex.what()); \ + return ScInternalResult::CompilationError; \ + } \ + catch (const std::exception &ex) \ + { \ + return ScInternalResult::Unhandled; \ + } \ + catch (...) \ + { \ + return ScInternalResult::Unhandled; \ + } \ + return ScInternalResult::Unhandled; \ + } while (0); +#endif + +extern "C" +{ + ScInternalResult sc_internal_get_latest_exception_message(const char **message) + { + INTERNAL_RESULT(*message = latest_exception_message;) + } + +#ifdef SPIRV_CROSS_WRAPPER_HLSL + ScInternalResult sc_internal_compiler_hlsl_new(ScInternalCompilerHlsl **compiler, const uint32_t *ir, const size_t size) + { + INTERNAL_RESULT(*compiler = new spirv_cross::CompilerHLSL(ir, size);) + } + + ScInternalResult sc_internal_compiler_hlsl_set_options(const ScInternalCompilerHlsl *compiler, const ScHlslCompilerOptions *options) + { + INTERNAL_RESULT( + do { + auto compiler_glsl = (spirv_cross::CompilerGLSL *)compiler; + auto glsl_options = compiler_glsl->get_common_options(); + glsl_options.vertex.fixup_clipspace = options->vertex_transform_clip_space; + glsl_options.vertex.flip_vert_y = options->vertex_invert_y; + glsl_options.force_zero_initialized_variables = options->force_zero_initialized_variables; + compiler_glsl->set_common_options(glsl_options); + + auto compiler_hlsl = (spirv_cross::CompilerHLSL *)compiler; + auto hlsl_options = compiler_hlsl->get_hlsl_options(); + hlsl_options.shader_model = options->shader_model; + hlsl_options.point_size_compat = options->point_size_compat; + hlsl_options.point_coord_compat = options->point_coord_compat; + hlsl_options.force_storage_buffer_as_uav = options->force_storage_buffer_as_uav; + hlsl_options.nonwritable_uav_texture_as_srv = options->nonwritable_uav_texture_as_srv; + + compiler_hlsl->set_hlsl_options(hlsl_options); + } while (0);) + } + + ScInternalResult sc_internal_compiler_hlsl_set_root_constant_layout(const ScInternalCompilerHlsl *compiler, const ScHlslRootConstant *constants, size_t count) + { + INTERNAL_RESULT( + do { + std::vector<spirv_cross::RootConstants> root_constants; + for (size_t i = 0; i < count; i++) + { + root_constants.push_back( + spirv_cross::RootConstants{ + constants[i].start, + constants[i].end, + constants[i].binding, + constants[i].space}); + } + + auto compiler_hlsl = (spirv_cross::CompilerHLSL *)compiler; + compiler_hlsl->set_root_constant_layouts(root_constants); + } while (0);) + } +#endif + +#ifdef SPIRV_CROSS_WRAPPER_MSL + ScInternalResult sc_internal_compiler_msl_new(ScInternalCompilerMsl **compiler, const uint32_t *ir, const size_t size) + { + INTERNAL_RESULT(*compiler = new spirv_cross::CompilerMSL(ir, size);) + } + + ScInternalResult sc_internal_compiler_msl_compile(const ScInternalCompilerBase *compiler, const char **shader, + const spirv_cross::MSLShaderInput *p_vat_overrides, const size_t vat_override_count, + const spirv_cross::MSLResourceBinding *p_res_overrides, const size_t res_override_count, + const ScMslConstSamplerMapping *p_const_samplers, const size_t const_sampler_count) + { + INTERNAL_RESULT( + do { + auto compiler_msl = ((spirv_cross::CompilerMSL *)compiler); + + for (size_t i = 0; i < vat_override_count; i++) + { + compiler_msl->add_msl_shader_input(p_vat_overrides[i]); + } + + for (size_t i = 0; i < res_override_count; i++) + { + compiler_msl->add_msl_resource_binding(p_res_overrides[i]); + } + + for (size_t i = 0; i < const_sampler_count; i++) + { + const auto& mapping = p_const_samplers[i]; + compiler_msl->remap_constexpr_sampler_by_binding(mapping.desc_set, mapping.binding, mapping.sampler); + } + + *shader = strdup(compiler_msl->compile().c_str()); + } while (0);) + } + + ScInternalResult sc_internal_compiler_msl_set_options(const ScInternalCompilerMsl *compiler, const ScMslCompilerOptions *options) + { + INTERNAL_RESULT( + do { + auto compiler_msl = (spirv_cross::CompilerMSL *)compiler; + + auto glsl_options = compiler_msl->get_common_options(); + glsl_options.vertex.fixup_clipspace = options->vertex_transform_clip_space; + glsl_options.vertex.flip_vert_y = options->vertex_invert_y; + glsl_options.force_zero_initialized_variables = options->force_zero_initialized_variables; + compiler_msl->set_common_options(glsl_options); + + auto msl_options = compiler_msl->get_msl_options(); + msl_options.platform = static_cast<spirv_cross::CompilerMSL::Options::Platform>(options->platform); + msl_options.msl_version = options->version; + msl_options.swizzle_buffer_index = options->swizzle_buffer_index; + msl_options.indirect_params_buffer_index = options->indirect_params_buffer_index; + msl_options.shader_output_buffer_index = options->shader_output_buffer_index; + msl_options.shader_patch_output_buffer_index = options->shader_patch_output_buffer_index; + msl_options.shader_tess_factor_buffer_index = options->shader_tess_factor_buffer_index; + msl_options.buffer_size_buffer_index = options->buffer_size_buffer_index; + msl_options.enable_point_size_builtin = options->enable_point_size_builtin; + msl_options.disable_rasterization = options->disable_rasterization; + msl_options.capture_output_to_buffer = options->capture_output_to_buffer; + msl_options.swizzle_texture_samples = options->swizzle_texture_samples; + msl_options.tess_domain_origin_lower_left = options->tess_domain_origin_lower_left; + msl_options.argument_buffers = options->argument_buffers; + msl_options.pad_fragment_output_components = options->pad_fragment_output_components; + msl_options.force_native_arrays = options->force_native_arrays; + compiler_msl->set_msl_options(msl_options); + } while (0);) + } + + ScInternalResult sc_internal_compiler_msl_get_is_rasterization_disabled(const ScInternalCompilerMsl *compiler, bool *is_rasterization_disabled) + { + INTERNAL_RESULT(*is_rasterization_disabled = ((spirv_cross::CompilerMSL *)compiler)->get_is_rasterization_disabled();) + } +#endif + +#ifdef SPIRV_CROSS_WRAPPER_GLSL + ScInternalResult sc_internal_compiler_glsl_new(ScInternalCompilerGlsl **compiler, const uint32_t *ir, const size_t size) + { + INTERNAL_RESULT(*compiler = new spirv_cross::CompilerGLSL(ir, size);) + } + + ScInternalResult sc_internal_compiler_glsl_set_options(const ScInternalCompilerGlsl *compiler, const ScGlslCompilerOptions *options) + { + INTERNAL_RESULT( + do { + auto compiler_glsl = (spirv_cross::CompilerGLSL *)compiler; + auto glsl_options = compiler_glsl->get_common_options(); + glsl_options.version = options->version; + glsl_options.es = options->es; + glsl_options.force_temporary = options->force_temporary; + glsl_options.vulkan_semantics = options->vulkan_semantics; + glsl_options.separate_shader_objects = options->separate_shader_objects; + glsl_options.flatten_multidimensional_arrays = options->flatten_multidimensional_arrays; + glsl_options.enable_420pack_extension = options->enable_420_pack_extension; + glsl_options.emit_push_constant_as_uniform_buffer = options->emit_push_constant_as_uniform_buffer; + glsl_options.emit_uniform_buffer_as_plain_uniforms = options->emit_uniform_buffer_as_plain_uniforms; + glsl_options.emit_line_directives = options->emit_line_directives; + glsl_options.enable_storage_image_qualifier_deduction = options->enable_storage_image_qualifier_deduction; + glsl_options.force_zero_initialized_variables = options->force_zero_initialized_variables; + glsl_options.vertex.fixup_clipspace = options->vertex_transform_clip_space; + glsl_options.vertex.flip_vert_y = options->vertex_invert_y; + glsl_options.vertex.support_nonzero_base_instance = options->vertex_support_nonzero_base_instance; + glsl_options.fragment.default_float_precision = static_cast<spirv_cross::CompilerGLSL::Options::Precision>(options->fragment_default_float_precision); + glsl_options.fragment.default_int_precision = static_cast<spirv_cross::CompilerGLSL::Options::Precision>(options->fragment_default_int_precision); + compiler_glsl->set_common_options(glsl_options); + } while (0);) + } + + ScInternalResult sc_internal_compiler_glsl_build_combined_image_samplers(const ScInternalCompilerBase *compiler) + { + INTERNAL_RESULT( + do { + ((spirv_cross::CompilerGLSL *)compiler)->build_combined_image_samplers(); + } while (0);) + } + + ScInternalResult sc_internal_compiler_glsl_get_combined_image_samplers(const ScInternalCompilerBase *compiler, const ScCombinedImageSampler **samplers, size_t *size) + { + INTERNAL_RESULT( + do { + const spirv_cross::SmallVector<spirv_cross::CombinedImageSampler>& ret = ((spirv_cross::CompilerGLSL *)compiler)->get_combined_image_samplers(); + *samplers = (const ScCombinedImageSampler *)ret.data(); + *size = ret.size(); + } while (0);) + } + + ScInternalResult sc_internal_compiler_glsl_add_header_line(const ScInternalCompilerBase *compiler, const char *str) + { + INTERNAL_RESULT( + do { + ((spirv_cross::CompilerGLSL *)compiler)->add_header_line(std::string(str)); + } while (0);) + } + + ScInternalResult sc_internal_compiler_glsl_flatten_buffer_block(const ScInternalCompilerBase *compiler, const uint32_t id) + { + INTERNAL_RESULT( + do { + ((spirv_cross::CompilerGLSL *)compiler)->flatten_buffer_block(id); + } while (0);) + } +#endif + + ScInternalResult sc_internal_compiler_get_decoration(const ScInternalCompilerBase *compiler, uint32_t *result, const uint32_t id, const spv::Decoration decoration) + { + INTERNAL_RESULT(*result = ((spirv_cross::Compiler *)compiler)->get_decoration(id, decoration);) + } + + ScInternalResult sc_internal_compiler_unset_decoration(const ScInternalCompilerBase *compiler, const uint32_t id, const spv::Decoration decoration) + { + INTERNAL_RESULT(((spirv_cross::Compiler *)compiler)->unset_decoration(id, decoration);) + } + + ScInternalResult sc_internal_compiler_set_decoration(const ScInternalCompilerBase *compiler, const uint32_t id, const spv::Decoration decoration, const uint32_t argument) + { + INTERNAL_RESULT(((spirv_cross::Compiler *)compiler)->set_decoration(id, decoration, argument);) + } + + ScInternalResult sc_internal_compiler_get_name(const ScInternalCompilerBase *compiler, const uint32_t id, const char **name) + { + INTERNAL_RESULT( + do { + auto const _name = ((spirv_cross::Compiler *)compiler)->get_name(id); + *name = strdup(_name.c_str()); + } while (0);) + } + + ScInternalResult sc_internal_compiler_set_name(const ScInternalCompilerBase *compiler, const uint32_t id, const char *name) + { + INTERNAL_RESULT(((spirv_cross::Compiler *)compiler)->set_name(id, std::string(name));) + } + + ScInternalResult sc_internal_compiler_get_entry_points(const ScInternalCompilerBase *compiler, ScEntryPoint **entry_points, size_t *size) + { + INTERNAL_RESULT( + do { + auto const &comp = *((spirv_cross::Compiler *)compiler); + auto const &sc_entry_point_names_and_stages = comp.get_entry_points_and_stages(); + auto const sc_size = sc_entry_point_names_and_stages.size(); + + *entry_points = (ScEntryPoint *)malloc(sc_size * sizeof(ScEntryPoint)); + *size = sc_size; + for (uint32_t i = 0; i < sc_size; i++) + { + auto const &sc_entry_point = sc_entry_point_names_and_stages[i]; + auto const &sc_spir_entry_point = comp.get_entry_point(sc_entry_point.name, sc_entry_point.execution_model); + auto &entry_point = (*entry_points)[i]; + entry_point.name = strdup(sc_entry_point.name.c_str()); + entry_point.execution_model = sc_spir_entry_point.model; + entry_point.work_group_size_x = sc_spir_entry_point.workgroup_size.x; + entry_point.work_group_size_y = sc_spir_entry_point.workgroup_size.y; + entry_point.work_group_size_z = sc_spir_entry_point.workgroup_size.z; + } + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_active_buffer_ranges(const ScInternalCompilerBase *compiler, uint32_t id, ScBufferRange **active_buffer_ranges, size_t *size) + { + INTERNAL_RESULT( + do { + auto const &comp = *((spirv_cross::Compiler *)compiler); + auto const &sc_active_buffer_ranges = comp.get_active_buffer_ranges(id); + auto const sc_size = sc_active_buffer_ranges.size(); + + *active_buffer_ranges = (ScBufferRange *)malloc(sc_size * sizeof(ScBufferRange)); + *size = sc_size; + for (uint32_t i = 0; i < sc_size; i++) + { + auto const &sc_active_buffer_range = sc_active_buffer_ranges[i]; + auto &active_buffer_range = (*active_buffer_ranges)[i]; + active_buffer_range.index = sc_active_buffer_range.index; + active_buffer_range.offset = sc_active_buffer_range.offset; + active_buffer_range.range = sc_active_buffer_range.range; + } + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_cleansed_entry_point_name(const ScInternalCompilerBase *compiler, const char *original_entry_point_name, const spv::ExecutionModel execution_model, const char **compiled_entry_point_name) + { + INTERNAL_RESULT( + do { + *compiled_entry_point_name = strdup( + (*((spirv_cross::Compiler *)compiler)) + .get_cleansed_entry_point_name(std::string(original_entry_point_name), execution_model) + .c_str()); + } while (0);) + } + + void fill_resource_array(ScResourceArray *resources, const spirv_cross::SmallVector<spirv_cross::Resource> &sc_resources) + { + auto const sc_size = sc_resources.size(); + + if (sc_size == 0) + { + resources->num = 0; + resources->data = 0x0; + return; + } + + resources->num = sc_size; + resources->data = (ScResource *)malloc(sc_size * sizeof(ScResource)); + for (uint32_t i = 0; i < sc_size; i++) + { + auto const &resource = sc_resources[i]; + resources->data[i].id = resource.id; + resources->data[i].type_id = resource.type_id; + resources->data[i].base_type_id = resource.base_type_id; + resources->data[i].name = strdup(resource.name.c_str()); + } + } + + ScInternalResult sc_internal_compiler_get_shader_resources(const ScInternalCompilerBase *compiler, ScShaderResources *shader_resources) + { + INTERNAL_RESULT( + do { + auto const sc_resources = ((const spirv_cross::Compiler *)compiler)->get_shader_resources(); + + fill_resource_array(&shader_resources->uniform_buffers, sc_resources.uniform_buffers); + fill_resource_array(&shader_resources->storage_buffers, sc_resources.storage_buffers); + fill_resource_array(&shader_resources->stage_inputs, sc_resources.stage_inputs); + fill_resource_array(&shader_resources->stage_outputs, sc_resources.stage_outputs); + fill_resource_array(&shader_resources->subpass_inputs, sc_resources.subpass_inputs); + fill_resource_array(&shader_resources->storage_images, sc_resources.storage_images); + fill_resource_array(&shader_resources->sampled_images, sc_resources.sampled_images); + fill_resource_array(&shader_resources->atomic_counters, sc_resources.atomic_counters); + fill_resource_array(&shader_resources->push_constant_buffers, sc_resources.push_constant_buffers); + fill_resource_array(&shader_resources->separate_images, sc_resources.separate_images); + fill_resource_array(&shader_resources->separate_samplers, sc_resources.separate_samplers); + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_specialization_constants(const ScInternalCompilerBase *compiler, ScSpecializationConstant **constants, size_t *size) + { + INTERNAL_RESULT( + do { + auto const sc_constants = ((const spirv_cross::Compiler *)compiler)->get_specialization_constants(); + auto const sc_size = sc_constants.size(); + + auto p_constants = (ScSpecializationConstant *)malloc(sc_size * sizeof(ScSpecializationConstant)); + *constants = p_constants; + *size = sc_size; + for (uint32_t i = 0; i < sc_size; i++) + { + auto const &sc_constant = sc_constants[i]; + p_constants[i].id = sc_constant.id; + p_constants[i].constant_id = sc_constant.constant_id; + } + } while (0);) + } + + ScInternalResult sc_internal_compiler_set_scalar_constant(const ScInternalCompilerBase *compiler, const uint32_t id, const uint32_t constant_high_bits, const uint32_t constant_low_bits) + { + INTERNAL_RESULT( + do { + auto &sc_constant = ((spirv_cross::Compiler *)compiler)->get_constant(id); + sc_constant.m.c[0].r[0].u64 = (((uint64_t)constant_high_bits) << 32) | constant_low_bits; + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_type(const ScInternalCompilerBase *compiler, const uint32_t id, const ScType **spirv_type) + { + INTERNAL_RESULT( + do { + auto const &type = ((spirv_cross::Compiler *)compiler)->get_type(id); + auto const member_types_size = type.member_types.size(); + auto const array_size = type.array.size(); + + auto ty = (ScType *)malloc(sizeof(ScType)); + ty->type = type.basetype; + ty->vecsize = type.vecsize; + ty->columns = type.columns; + ty->member_types_size = member_types_size; + ty->array_size = array_size; + + if (member_types_size > 0) + { + auto const &member_types = (uint32_t *)malloc(member_types_size * sizeof(uint32_t)); + + for (size_t i = 0; i < member_types_size; i++) + { + member_types[i] = type.member_types[i]; + } + + ty->member_types = member_types; + } + + if (array_size > 0) + { + auto const &array = (uint32_t *)malloc(array_size * sizeof(uint32_t)); + + for (size_t i = 0; i < array_size; i++) + { + array[i] = type.array[i]; + } + + ty->array = array; + } + + *spirv_type = ty; + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_member_name(const ScInternalCompilerBase *compiler, const uint32_t id, const uint32_t index, const char **name) + { + INTERNAL_RESULT( + do { + auto const member_name = ((spirv_cross::Compiler *)compiler)->get_member_name(id, index); + *name = strdup(member_name.c_str()); + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_member_decoration(const ScInternalCompilerBase *compiler, const uint32_t id, const uint32_t index, const spv::Decoration decoration, uint32_t *result) + { + INTERNAL_RESULT(*result = ((spirv_cross::Compiler *)compiler)->get_member_decoration(id, index, decoration);) + } + + ScInternalResult sc_internal_compiler_set_member_decoration(const ScInternalCompilerBase *compiler, const uint32_t id, const uint32_t index, const spv::Decoration decoration, const uint32_t argument) + { + INTERNAL_RESULT(((spirv_cross::Compiler *)compiler)->set_member_decoration(id, index, decoration, argument);) + } + + ScInternalResult sc_internal_compiler_get_declared_struct_size(const ScInternalCompilerBase *compiler, const uint32_t id, uint32_t *result) + { + INTERNAL_RESULT(do { + auto const &comp = ((spirv_cross::Compiler *)compiler); + *result = comp->get_declared_struct_size(comp->get_type(id)); + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_declared_struct_member_size(const ScInternalCompilerBase *compiler, const uint32_t id, const uint32_t index, uint32_t *result) + { + INTERNAL_RESULT(do { + auto const &comp = ((spirv_cross::Compiler *)compiler); + *result = comp->get_declared_struct_member_size(comp->get_type(id), index); + } while (0);) + } + + ScInternalResult sc_internal_compiler_rename_interface_variable(const ScInternalCompilerBase *compiler, const ScResource *resources, const size_t resources_size, uint32_t location, const char *name) + { + INTERNAL_RESULT(do { + spirv_cross::SmallVector<spirv_cross::Resource> sc_resources; + for (size_t i = 0; i < resources_size; i++) + { + auto const &resource = resources[i]; + spirv_cross::Resource sc_resource; + std::string sc_name(resource.name); + sc_resource.id = resource.id; + sc_resource.type_id = resource.type_id; + sc_resource.base_type_id = resource.base_type_id; + sc_resource.name = sc_name; + sc_resources.push_back(sc_resource); + } + + auto &comp = *(spirv_cross::Compiler *)compiler; + std::string new_name(name); + spirv_cross_util::rename_interface_variable(comp, sc_resources, location, new_name); + } while (0);) + } + + ScInternalResult sc_internal_compiler_get_work_group_size_specialization_constants(const ScInternalCompilerBase *compiler, ScSpecializationConstant **constants) + { + INTERNAL_RESULT(do { + spirv_cross::SpecializationConstant wg_x; + spirv_cross::SpecializationConstant wg_y; + spirv_cross::SpecializationConstant wg_z; + ((const spirv_cross::Compiler *)compiler)->get_work_group_size_specialization_constants(wg_x, wg_y, wg_z); + + auto p_constants = (ScSpecializationConstant *)malloc(3 * sizeof(ScSpecializationConstant)); + p_constants[0].id = wg_x.id; + p_constants[0].constant_id = wg_x.constant_id; + p_constants[1].id = wg_y.id; + p_constants[1].constant_id = wg_y.constant_id; + p_constants[2].id = wg_z.id; + p_constants[2].constant_id = wg_z.constant_id; + + *constants = p_constants; + } while (0);) + } + + ScInternalResult sc_internal_compiler_set_entry_point(const ScInternalCompilerBase *compiler, const char *name, const spv::ExecutionModel execution_model) + { + INTERNAL_RESULT(((spirv_cross::Compiler *)compiler)->set_entry_point(name, execution_model);) + } + + ScInternalResult sc_internal_compiler_compile(const ScInternalCompilerBase *compiler, const char **shader) + { + INTERNAL_RESULT(*shader = strdup(((spirv_cross::Compiler *)compiler)->compile().c_str());) + } + + ScInternalResult sc_internal_compiler_delete(ScInternalCompilerBase *compiler) + { + INTERNAL_RESULT(delete (spirv_cross::Compiler *)compiler;) + } + + ScInternalResult sc_internal_free_pointer(void *pointer) + { + INTERNAL_RESULT(free(pointer);) + } +} |