// Copyright 2015 The Shaderc Authors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef SHADERC_SHADERC_H_ #define SHADERC_SHADERC_H_ #ifdef __cplusplus extern "C" { #endif #include #include #include #include "shaderc/env.h" #include "shaderc/status.h" #include "shaderc/visibility.h" // Source language kind. typedef enum { shaderc_source_language_glsl, shaderc_source_language_hlsl, } shaderc_source_language; typedef enum { // Forced shader kinds. These shader kinds force the compiler to compile the // source code as the specified kind of shader. shaderc_vertex_shader, shaderc_fragment_shader, shaderc_compute_shader, shaderc_geometry_shader, shaderc_tess_control_shader, shaderc_tess_evaluation_shader, shaderc_glsl_vertex_shader = shaderc_vertex_shader, shaderc_glsl_fragment_shader = shaderc_fragment_shader, shaderc_glsl_compute_shader = shaderc_compute_shader, shaderc_glsl_geometry_shader = shaderc_geometry_shader, shaderc_glsl_tess_control_shader = shaderc_tess_control_shader, shaderc_glsl_tess_evaluation_shader = shaderc_tess_evaluation_shader, // Deduce the shader kind from #pragma annotation in the source code. Compiler // will emit error if #pragma annotation is not found. shaderc_glsl_infer_from_source, // Default shader kinds. Compiler will fall back to compile the source code as // the specified kind of shader when #pragma annotation is not found in the // source code. shaderc_glsl_default_vertex_shader, shaderc_glsl_default_fragment_shader, shaderc_glsl_default_compute_shader, shaderc_glsl_default_geometry_shader, shaderc_glsl_default_tess_control_shader, shaderc_glsl_default_tess_evaluation_shader, shaderc_spirv_assembly, shaderc_raygen_shader, shaderc_anyhit_shader, shaderc_closesthit_shader, shaderc_miss_shader, shaderc_intersection_shader, shaderc_callable_shader, shaderc_glsl_raygen_shader = shaderc_raygen_shader, shaderc_glsl_anyhit_shader = shaderc_anyhit_shader, shaderc_glsl_closesthit_shader = shaderc_closesthit_shader, shaderc_glsl_miss_shader = shaderc_miss_shader, shaderc_glsl_intersection_shader = shaderc_intersection_shader, shaderc_glsl_callable_shader = shaderc_callable_shader, shaderc_glsl_default_raygen_shader, shaderc_glsl_default_anyhit_shader, shaderc_glsl_default_closesthit_shader, shaderc_glsl_default_miss_shader, shaderc_glsl_default_intersection_shader, shaderc_glsl_default_callable_shader, shaderc_task_shader, shaderc_mesh_shader, shaderc_glsl_task_shader = shaderc_task_shader, shaderc_glsl_mesh_shader = shaderc_mesh_shader, shaderc_glsl_default_task_shader, shaderc_glsl_default_mesh_shader, } shaderc_shader_kind; typedef enum { shaderc_profile_none, // Used if and only if GLSL version did not specify // profiles. shaderc_profile_core, shaderc_profile_compatibility, // Disabled. This generates an error shaderc_profile_es, } shaderc_profile; // Optimization level. typedef enum { shaderc_optimization_level_zero, // no optimization shaderc_optimization_level_size, // optimize towards reducing code size shaderc_optimization_level_performance, // optimize towards performance } shaderc_optimization_level; // Resource limits. typedef enum { shaderc_limit_max_lights, shaderc_limit_max_clip_planes, shaderc_limit_max_texture_units, shaderc_limit_max_texture_coords, shaderc_limit_max_vertex_attribs, shaderc_limit_max_vertex_uniform_components, shaderc_limit_max_varying_floats, shaderc_limit_max_vertex_texture_image_units, shaderc_limit_max_combined_texture_image_units, shaderc_limit_max_texture_image_units, shaderc_limit_max_fragment_uniform_components, shaderc_limit_max_draw_buffers, shaderc_limit_max_vertex_uniform_vectors, shaderc_limit_max_varying_vectors, shaderc_limit_max_fragment_uniform_vectors, shaderc_limit_max_vertex_output_vectors, shaderc_limit_max_fragment_input_vectors, shaderc_limit_min_program_texel_offset, shaderc_limit_max_program_texel_offset, shaderc_limit_max_clip_distances, shaderc_limit_max_compute_work_group_count_x, shaderc_limit_max_compute_work_group_count_y, shaderc_limit_max_compute_work_group_count_z, shaderc_limit_max_compute_work_group_size_x, shaderc_limit_max_compute_work_group_size_y, shaderc_limit_max_compute_work_group_size_z, shaderc_limit_max_compute_uniform_components, shaderc_limit_max_compute_texture_image_units, shaderc_limit_max_compute_image_uniforms, shaderc_limit_max_compute_atomic_counters, shaderc_limit_max_compute_atomic_counter_buffers, shaderc_limit_max_varying_components, shaderc_limit_max_vertex_output_components, shaderc_limit_max_geometry_input_components, shaderc_limit_max_geometry_output_components, shaderc_limit_max_fragment_input_components, shaderc_limit_max_image_units, shaderc_limit_max_combined_image_units_and_fragment_outputs, shaderc_limit_max_combined_shader_output_resources, shaderc_limit_max_image_samples, shaderc_limit_max_vertex_image_uniforms, shaderc_limit_max_tess_control_image_uniforms, shaderc_limit_max_tess_evaluation_image_uniforms, shaderc_limit_max_geometry_image_uniforms, shaderc_limit_max_fragment_image_uniforms, shaderc_limit_max_combined_image_uniforms, shaderc_limit_max_geometry_texture_image_units, shaderc_limit_max_geometry_output_vertices, shaderc_limit_max_geometry_total_output_components, shaderc_limit_max_geometry_uniform_components, shaderc_limit_max_geometry_varying_components, shaderc_limit_max_tess_control_input_components, shaderc_limit_max_tess_control_output_components, shaderc_limit_max_tess_control_texture_image_units, shaderc_limit_max_tess_control_uniform_components, shaderc_limit_max_tess_control_total_output_components, shaderc_limit_max_tess_evaluation_input_components, shaderc_limit_max_tess_evaluation_output_components, shaderc_limit_max_tess_evaluation_texture_image_units, shaderc_limit_max_tess_evaluation_uniform_components, shaderc_limit_max_tess_patch_components, shaderc_limit_max_patch_vertices, shaderc_limit_max_tess_gen_level, shaderc_limit_max_viewports, shaderc_limit_max_vertex_atomic_counters, shaderc_limit_max_tess_control_atomic_counters, shaderc_limit_max_tess_evaluation_atomic_counters, shaderc_limit_max_geometry_atomic_counters, shaderc_limit_max_fragment_atomic_counters, shaderc_limit_max_combined_atomic_counters, shaderc_limit_max_atomic_counter_bindings, shaderc_limit_max_vertex_atomic_counter_buffers, shaderc_limit_max_tess_control_atomic_counter_buffers, shaderc_limit_max_tess_evaluation_atomic_counter_buffers, shaderc_limit_max_geometry_atomic_counter_buffers, shaderc_limit_max_fragment_atomic_counter_buffers, shaderc_limit_max_combined_atomic_counter_buffers, shaderc_limit_max_atomic_counter_buffer_size, shaderc_limit_max_transform_feedback_buffers, shaderc_limit_max_transform_feedback_interleaved_components, shaderc_limit_max_cull_distances, shaderc_limit_max_combined_clip_and_cull_distances, shaderc_limit_max_samples, shaderc_limit_max_mesh_output_vertices_nv, shaderc_limit_max_mesh_output_primitives_nv, shaderc_limit_max_mesh_work_group_size_x_nv, shaderc_limit_max_mesh_work_group_size_y_nv, shaderc_limit_max_mesh_work_group_size_z_nv, shaderc_limit_max_task_work_group_size_x_nv, shaderc_limit_max_task_work_group_size_y_nv, shaderc_limit_max_task_work_group_size_z_nv, shaderc_limit_max_mesh_view_count_nv, shaderc_limit_max_mesh_output_vertices_ext, shaderc_limit_max_mesh_output_primitives_ext, shaderc_limit_max_mesh_work_group_size_x_ext, shaderc_limit_max_mesh_work_group_size_y_ext, shaderc_limit_max_mesh_work_group_size_z_ext, shaderc_limit_max_task_work_group_size_x_ext, shaderc_limit_max_task_work_group_size_y_ext, shaderc_limit_max_task_work_group_size_z_ext, shaderc_limit_max_mesh_view_count_ext, shaderc_limit_max_dual_source_draw_buffers_ext, } shaderc_limit; // Uniform resource kinds. // In Vulkan, uniform resources are bound to the pipeline via descriptors // with numbered bindings and sets. typedef enum { // Image and image buffer. shaderc_uniform_kind_image, // Pure sampler. shaderc_uniform_kind_sampler, // Sampled texture in GLSL, and Shader Resource View in HLSL. shaderc_uniform_kind_texture, // Uniform Buffer Object (UBO) in GLSL. Cbuffer in HLSL. shaderc_uniform_kind_buffer, // Shader Storage Buffer Object (SSBO) in GLSL. shaderc_uniform_kind_storage_buffer, // Unordered Access View, in HLSL. (Writable storage image or storage // buffer.) shaderc_uniform_kind_unordered_access_view, } shaderc_uniform_kind; // Usage examples: // // Aggressively release compiler resources, but spend time in initialization // for each new use. // shaderc_compiler_t compiler = shaderc_compiler_initialize(); // shaderc_compilation_result_t result = shaderc_compile_into_spv( // compiler, "#version 450\nvoid main() {}", 27, // shaderc_glsl_vertex_shader, "main.vert", "main", nullptr); // // Do stuff with compilation results. // shaderc_result_release(result); // shaderc_compiler_release(compiler); // // Keep the compiler object around for a long time, but pay for extra space // occupied. // shaderc_compiler_t compiler = shaderc_compiler_initialize(); // // On the same, other or multiple simultaneous threads. // shaderc_compilation_result_t result = shaderc_compile_into_spv( // compiler, "#version 450\nvoid main() {}", 27, // shaderc_glsl_vertex_shader, "main.vert", "main", nullptr); // // Do stuff with compilation results. // shaderc_result_release(result); // // Once no more compilations are to happen. // shaderc_compiler_release(compiler); // An opaque handle to an object that manages all compiler state. typedef struct shaderc_compiler* shaderc_compiler_t; // Returns a shaderc_compiler_t that can be used to compile modules. // A return of NULL indicates that there was an error initializing the compiler. // Any function operating on shaderc_compiler_t must offer the basic // thread-safety guarantee. // [http://herbsutter.com/2014/01/13/gotw-95-solution-thread-safety-and-synchronization/] // That is: concurrent invocation of these functions on DIFFERENT objects needs // no synchronization; concurrent invocation of these functions on the SAME // object requires synchronization IF AND ONLY IF some of them take a non-const // argument. SHADERC_EXPORT shaderc_compiler_t shaderc_compiler_initialize(void); // Releases the resources held by the shaderc_compiler_t. // After this call it is invalid to make any future calls to functions // involving this shaderc_compiler_t. SHADERC_EXPORT void shaderc_compiler_release(shaderc_compiler_t); // An opaque handle to an object that manages options to a single compilation // result. typedef struct shaderc_compile_options* shaderc_compile_options_t; // Returns a default-initialized shaderc_compile_options_t that can be used // to modify the functionality of a compiled module. // A return of NULL indicates that there was an error initializing the options. // Any function operating on shaderc_compile_options_t must offer the // basic thread-safety guarantee. SHADERC_EXPORT shaderc_compile_options_t shaderc_compile_options_initialize(void); // Returns a copy of the given shaderc_compile_options_t. // If NULL is passed as the parameter the call is the same as // shaderc_compile_options_init. SHADERC_EXPORT shaderc_compile_options_t shaderc_compile_options_clone( const shaderc_compile_options_t options); // Releases the compilation options. It is invalid to use the given // shaderc_compile_options_t object in any future calls. It is safe to pass // NULL to this function, and doing such will have no effect. SHADERC_EXPORT void shaderc_compile_options_release( shaderc_compile_options_t options); // Adds a predefined macro to the compilation options. This has the same // effect as passing -Dname=value to the command-line compiler. If value // is NULL, it has the same effect as passing -Dname to the command-line // compiler. If a macro definition with the same name has previously been // added, the value is replaced with the new value. The macro name and // value are passed in with char pointers, which point to their data, and // the lengths of their data. The strings that the name and value pointers // point to must remain valid for the duration of the call, but can be // modified or deleted after this function has returned. In case of adding // a valueless macro, the value argument should be a null pointer or the // value_length should be 0u. SHADERC_EXPORT void shaderc_compile_options_add_macro_definition( shaderc_compile_options_t options, const char* name, size_t name_length, const char* value, size_t value_length); // Sets the source language. The default is GLSL. SHADERC_EXPORT void shaderc_compile_options_set_source_language( shaderc_compile_options_t options, shaderc_source_language lang); // Sets the compiler mode to generate debug information in the output. SHADERC_EXPORT void shaderc_compile_options_set_generate_debug_info( shaderc_compile_options_t options); // Sets the compiler optimization level to the given level. Only the last one // takes effect if multiple calls of this function exist. SHADERC_EXPORT void shaderc_compile_options_set_optimization_level( shaderc_compile_options_t options, shaderc_optimization_level level); // Forces the GLSL language version and profile to a given pair. The version // number is the same as would appear in the #version annotation in the source. // Version and profile specified here overrides the #version annotation in the // source. Use profile: 'shaderc_profile_none' for GLSL versions that do not // define profiles, e.g. versions below 150. SHADERC_EXPORT void shaderc_compile_options_set_forced_version_profile( shaderc_compile_options_t options, int version, shaderc_profile profile); // Source text inclusion via #include is supported with a pair of callbacks // to an "includer" on the client side. The first callback processes an // inclusion request, and returns an include result. The includer owns // the contents of the result, and those contents must remain valid until the // second callback is invoked to release the result. Both callbacks take a // user_data argument to specify the client context. // To return an error, set the source_name to an empty string and put your // error message in content. // An include result. typedef struct shaderc_include_result { // The name of the source file. The name should be fully resolved // in the sense that it should be a unique name in the context of the // includer. For example, if the includer maps source names to files in // a filesystem, then this name should be the absolute path of the file. // For a failed inclusion, this string is empty. const char* source_name; size_t source_name_length; // The text contents of the source file in the normal case. // For a failed inclusion, this contains the error message. const char* content; size_t content_length; // User data to be passed along with this request. void* user_data; } shaderc_include_result; // The kinds of include requests. enum shaderc_include_type { shaderc_include_type_relative, // E.g. #include "source" shaderc_include_type_standard // E.g. #include }; // An includer callback type for mapping an #include request to an include // result. The user_data parameter specifies the client context. The // requested_source parameter specifies the name of the source being requested. // The type parameter specifies the kind of inclusion request being made. // The requesting_source parameter specifies the name of the source containing // the #include request. The includer owns the result object and its contents, // and both must remain valid until the release callback is called on the result // object. typedef shaderc_include_result* (*shaderc_include_resolve_fn)( void* user_data, const char* requested_source, int type, const char* requesting_source, size_t include_depth); // An includer callback type for destroying an include result. typedef void (*shaderc_include_result_release_fn)( void* user_data, shaderc_include_result* include_result); // Sets includer callback functions. SHADERC_EXPORT void shaderc_compile_options_set_include_callbacks( shaderc_compile_options_t options, shaderc_include_resolve_fn resolver, shaderc_include_result_release_fn result_releaser, void* user_data); // Sets the compiler mode to suppress warnings, overriding warnings-as-errors // mode. When both suppress-warnings and warnings-as-errors modes are // turned on, warning messages will be inhibited, and will not be emitted // as error messages. SHADERC_EXPORT void shaderc_compile_options_set_suppress_warnings( shaderc_compile_options_t options); // Sets the target shader environment, affecting which warnings or errors will // be issued. The version will be for distinguishing between different versions // of the target environment. The version value should be either 0 or // a value listed in shaderc_env_version. The 0 value maps to Vulkan 1.0 if // |target| is Vulkan, and it maps to OpenGL 4.5 if |target| is OpenGL. SHADERC_EXPORT void shaderc_compile_options_set_target_env( shaderc_compile_options_t options, shaderc_target_env target, uint32_t version); // Sets the target SPIR-V version. The generated module will use this version // of SPIR-V. Each target environment determines what versions of SPIR-V // it can consume. Defaults to the highest version of SPIR-V 1.0 which is // required to be supported by the target environment. E.g. Default to SPIR-V // 1.0 for Vulkan 1.0 and SPIR-V 1.3 for Vulkan 1.1. SHADERC_EXPORT void shaderc_compile_options_set_target_spirv( shaderc_compile_options_t options, shaderc_spirv_version version); // Sets the compiler mode to treat all warnings as errors. Note the // suppress-warnings mode overrides this option, i.e. if both // warning-as-errors and suppress-warnings modes are set, warnings will not // be emitted as error messages. SHADERC_EXPORT void shaderc_compile_options_set_warnings_as_errors( shaderc_compile_options_t options); // Sets a resource limit. SHADERC_EXPORT void shaderc_compile_options_set_limit( shaderc_compile_options_t options, shaderc_limit limit, int value); // Sets whether the compiler should automatically assign bindings to uniforms // that aren't already explicitly bound in the shader source. SHADERC_EXPORT void shaderc_compile_options_set_auto_bind_uniforms( shaderc_compile_options_t options, bool auto_bind); // Sets whether the compiler should automatically remove sampler variables // and convert image variables to combined image-sampler variables. SHADERC_EXPORT void shaderc_compile_options_set_auto_combined_image_sampler( shaderc_compile_options_t options, bool upgrade); // Sets whether the compiler should use HLSL IO mapping rules for bindings. // Defaults to false. SHADERC_EXPORT void shaderc_compile_options_set_hlsl_io_mapping( shaderc_compile_options_t options, bool hlsl_iomap); // Sets whether the compiler should determine block member offsets using HLSL // packing rules instead of standard GLSL rules. Defaults to false. Only // affects GLSL compilation. HLSL rules are always used when compiling HLSL. SHADERC_EXPORT void shaderc_compile_options_set_hlsl_offsets( shaderc_compile_options_t options, bool hlsl_offsets); // Sets the base binding number used for for a uniform resource type when // automatically assigning bindings. For GLSL compilation, sets the lowest // automatically assigned number. For HLSL compilation, the regsiter number // assigned to the resource is added to this specified base. SHADERC_EXPORT void shaderc_compile_options_set_binding_base( shaderc_compile_options_t options, shaderc_uniform_kind kind, uint32_t base); // Like shaderc_compile_options_set_binding_base, but only takes effect when // compiling a given shader stage. The stage is assumed to be one of vertex, // fragment, tessellation evaluation, tesselation control, geometry, or compute. SHADERC_EXPORT void shaderc_compile_options_set_binding_base_for_stage( shaderc_compile_options_t options, shaderc_shader_kind shader_kind, shaderc_uniform_kind kind, uint32_t base); // Sets whether the compiler should preserve all bindings, even when those // bindings are not used. SHADERC_EXPORT void shaderc_compile_options_set_preserve_bindings( shaderc_compile_options_t options, bool preserve_bindings); // Sets whether the compiler should automatically assign locations to // uniform variables that don't have explicit locations in the shader source. SHADERC_EXPORT void shaderc_compile_options_set_auto_map_locations( shaderc_compile_options_t options, bool auto_map); // Sets a descriptor set and binding for an HLSL register in the given stage. // This method keeps a copy of the string data. SHADERC_EXPORT void shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage( shaderc_compile_options_t options, shaderc_shader_kind shader_kind, const char* reg, const char* set, const char* binding); // Like shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage, // but affects all shader stages. SHADERC_EXPORT void shaderc_compile_options_set_hlsl_register_set_and_binding( shaderc_compile_options_t options, const char* reg, const char* set, const char* binding); // Sets whether the compiler should enable extension // SPV_GOOGLE_hlsl_functionality1. SHADERC_EXPORT void shaderc_compile_options_set_hlsl_functionality1( shaderc_compile_options_t options, bool enable); // Sets whether 16-bit types are supported in HLSL or not. SHADERC_EXPORT void shaderc_compile_options_set_hlsl_16bit_types( shaderc_compile_options_t options, bool enable); // Enables or disables relaxed Vulkan rules. // // This allows most OpenGL shaders to compile under Vulkan semantics. SHADERC_EXPORT void shaderc_compile_options_set_vulkan_rules_relaxed( shaderc_compile_options_t options, bool enable); // Sets whether the compiler should invert position.Y output in vertex shader. SHADERC_EXPORT void shaderc_compile_options_set_invert_y( shaderc_compile_options_t options, bool enable); // Sets whether the compiler generates code for max and min builtins which, // if given a NaN operand, will return the other operand. Similarly, the clamp // builtin will favour the non-NaN operands, as if clamp were implemented // as a composition of max and min. SHADERC_EXPORT void shaderc_compile_options_set_nan_clamp( shaderc_compile_options_t options, bool enable); // An opaque handle to the results of a call to any shaderc_compile_into_*() // function. typedef struct shaderc_compilation_result* shaderc_compilation_result_t; // Takes a GLSL source string and the associated shader kind, input file // name, compiles it according to the given additional_options. If the shader // kind is not set to a specified kind, but shaderc_glslc_infer_from_source, // the compiler will try to deduce the shader kind from the source // string and a failure in deducing will generate an error. Currently only // #pragma annotation is supported. If the shader kind is set to one of the // default shader kinds, the compiler will fall back to the default shader // kind in case it failed to deduce the shader kind from source string. // The input_file_name is a null-termintated string. It is used as a tag to // identify the source string in cases like emitting error messages. It // doesn't have to be a 'file name'. // The source string will be compiled into SPIR-V binary and a // shaderc_compilation_result will be returned to hold the results. // The entry_point_name null-terminated string defines the name of the entry // point to associate with this GLSL source. If the additional_options // parameter is not null, then the compilation is modified by any options // present. May be safely called from multiple threads without explicit // synchronization. If there was failure in allocating the compiler object, // null will be returned. SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_spv( const shaderc_compiler_t compiler, const char* source_text, size_t source_text_size, shaderc_shader_kind shader_kind, const char* input_file_name, const char* entry_point_name, const shaderc_compile_options_t additional_options); // Like shaderc_compile_into_spv, but the result contains SPIR-V assembly text // instead of a SPIR-V binary module. The SPIR-V assembly syntax is as defined // by the SPIRV-Tools open source project. SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_spv_assembly( const shaderc_compiler_t compiler, const char* source_text, size_t source_text_size, shaderc_shader_kind shader_kind, const char* input_file_name, const char* entry_point_name, const shaderc_compile_options_t additional_options); // Like shaderc_compile_into_spv, but the result contains preprocessed source // code instead of a SPIR-V binary module SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_preprocessed_text( const shaderc_compiler_t compiler, const char* source_text, size_t source_text_size, shaderc_shader_kind shader_kind, const char* input_file_name, const char* entry_point_name, const shaderc_compile_options_t additional_options); // Takes an assembly string of the format defined in the SPIRV-Tools project // (https://github.com/KhronosGroup/SPIRV-Tools/blob/master/syntax.md), // assembles it into SPIR-V binary and a shaderc_compilation_result will be // returned to hold the results. // The assembling will pick options suitable for assembling specified in the // additional_options parameter. // May be safely called from multiple threads without explicit synchronization. // If there was failure in allocating the compiler object, null will be // returned. SHADERC_EXPORT shaderc_compilation_result_t shaderc_assemble_into_spv( const shaderc_compiler_t compiler, const char* source_assembly, size_t source_assembly_size, const shaderc_compile_options_t additional_options); // The following functions, operating on shaderc_compilation_result_t objects, // offer only the basic thread-safety guarantee. // Releases the resources held by the result object. It is invalid to use the // result object for any further operations. SHADERC_EXPORT void shaderc_result_release(shaderc_compilation_result_t result); // Returns the number of bytes of the compilation output data in a result // object. SHADERC_EXPORT size_t shaderc_result_get_length(const shaderc_compilation_result_t result); // Returns the number of warnings generated during the compilation. SHADERC_EXPORT size_t shaderc_result_get_num_warnings( const shaderc_compilation_result_t result); // Returns the number of errors generated during the compilation. SHADERC_EXPORT size_t shaderc_result_get_num_errors(const shaderc_compilation_result_t result); // Returns the compilation status, indicating whether the compilation succeeded, // or failed due to some reasons, like invalid shader stage or compilation // errors. SHADERC_EXPORT shaderc_compilation_status shaderc_result_get_compilation_status( const shaderc_compilation_result_t); // Returns a pointer to the start of the compilation output data bytes, either // SPIR-V binary or char string. When the source string is compiled into SPIR-V // binary, this is guaranteed to be castable to a uint32_t*. If the result // contains assembly text or preprocessed source text, the pointer will point to // the resulting array of characters. SHADERC_EXPORT const char* shaderc_result_get_bytes(const shaderc_compilation_result_t result); // Returns a null-terminated string that contains any error messages generated // during the compilation. SHADERC_EXPORT const char* shaderc_result_get_error_message( const shaderc_compilation_result_t result); // Provides the version & revision of the SPIR-V which will be produced SHADERC_EXPORT void shaderc_get_spv_version(unsigned int* version, unsigned int* revision); // Parses the version and profile from a given null-terminated string // containing both version and profile, like: '450core'. Returns false if // the string can not be parsed. Returns true when the parsing succeeds. The // parsed version and profile are returned through arguments. SHADERC_EXPORT bool shaderc_parse_version_profile(const char* str, int* version, shaderc_profile* profile); #ifdef __cplusplus } #endif // __cplusplus #endif // SHADERC_SHADERC_H_