/* * Copyright 2015-2016 ARM Limited * * 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 SPIRV_CROSS_GLSL_HPP #define SPIRV_CROSS_GLSL_HPP #include "spirv_cross.hpp" #include #include #include #include namespace spirv_cross { enum PlsFormat { PlsNone = 0, PlsR11FG11FB10F, PlsR32F, PlsRG16F, PlsRGB10A2, PlsRGBA8, PlsRG16, PlsRGBA8I, PlsRG16I, PlsRGB10A2UI, PlsRGBA8UI, PlsRG16UI, PlsR32UI }; struct PlsRemap { uint32_t id; PlsFormat format; }; class CompilerGLSL : public Compiler { public: struct Options { uint32_t version = 450; bool es = false; bool force_temporary = false; // If true, variables will be moved to their appropriate scope through CFG analysis. bool cfg_analysis = true; // If true, Vulkan GLSL features are used instead of GL-compatible features. // Mostly useful for debugging SPIR-V files. bool vulkan_semantics = false; enum Precision { DontCare, Lowp, Mediump, Highp }; struct { // In vertex shaders, rewrite [0, w] depth (Vulkan/D3D style) to [-w, w] depth (GL style). bool fixup_clipspace = true; } vertex; struct { // Add precision mediump float in ES targets when emitting GLES source. // Add precision highp int in ES targets when emitting GLES source. Precision default_float_precision = Mediump; Precision default_int_precision = Highp; } fragment; }; void remap_pixel_local_storage(std::vector inputs, std::vector outputs) { pls_inputs = std::move(inputs); pls_outputs = std::move(outputs); remap_pls_variables(); } CompilerGLSL(std::vector spirv_) : Compiler(move(spirv_)) { if (source.known) { options.es = source.es; options.version = source.version; } } const Options &get_options() const { return options; } void set_options(Options &opts) { options = opts; } std::string compile() override; // Returns the current string held in the conversion buffer. Useful for // capturing what has been converted so far when compile() throws an error. std::string get_partial_source(); // Adds a line to be added right after #version in GLSL backend. // This is useful for enabling custom extensions which are outside the scope of SPIRV-Cross. // This can be combined with variable remapping. // A new-line will be added. // // While add_header_line() is a more generic way of adding arbitrary text to the header // of a GLSL file, require_extension() should be used when adding extensions since it will // avoid creating collisions with SPIRV-Cross generated extensions. // // Code added via add_header_line() is typically backend-specific. void add_header_line(const std::string &str); // Adds an extension which is required to run this shader, e.g. // require_extension("GL_KHR_my_extension"); void require_extension(const std::string &ext); // Legacy GLSL compatibility method. // Takes a uniform or push constant variable and flattens it into a (i|u)vec4 array[N]; array instead. // For this to work, all types in the block must be the same basic type, e.g. mixing vec2 and vec4 is fine, but // mixing int and float is not. // The name of the uniform array will be the same as the interface block name. void flatten_buffer_block(uint32_t id); protected: void reset(); void emit_function(SPIRFunction &func, uint64_t return_flags); // Virtualize methods which need to be overridden by subclass targets like C++ and such. virtual void emit_function_prototype(SPIRFunction &func, uint64_t return_flags); virtual void emit_instruction(const Instruction &instr); virtual void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count); virtual void emit_header(); virtual void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id); virtual void emit_texture_op(const Instruction &i); virtual std::string type_to_glsl(const SPIRType &type); virtual std::string builtin_to_glsl(spv::BuiltIn builtin); virtual std::string member_decl(const SPIRType &type, const SPIRType &member_type, uint32_t member); virtual std::string image_type_glsl(const SPIRType &type); virtual std::string constant_expression(const SPIRConstant &c); std::string constant_op_expression(const SPIRConstantOp &cop); virtual std::string constant_expression_vector(const SPIRConstant &c, uint32_t vector); virtual void emit_fixup(); virtual std::string variable_decl(const SPIRType &type, const std::string &name); virtual std::string to_func_call_arg(uint32_t id); virtual std::string to_function_name(uint32_t img, const SPIRType &imgtype, bool is_fetch, bool is_gather, bool is_proj, bool has_array_offsets, bool has_offset, bool has_grad, bool has_lod, bool has_dref); virtual std::string to_function_args(uint32_t img, const SPIRType &imgtype, bool is_fetch, bool is_gather, bool is_proj, uint32_t coord, uint32_t coord_components, uint32_t dref, uint32_t grad_x, uint32_t grad_y, uint32_t lod, uint32_t coffset, uint32_t offset, uint32_t bias, uint32_t comp, uint32_t sample, bool *p_forward); virtual std::string clean_func_name(std::string func_name); std::unique_ptr buffer; template inline void statement_inner(T &&t) { (*buffer) << std::forward(t); statement_count++; } template inline void statement_inner(T &&t, Ts &&... ts) { (*buffer) << std::forward(t); statement_count++; statement_inner(std::forward(ts)...); } template inline void statement(Ts &&... ts) { if (redirect_statement) redirect_statement->push_back(join(std::forward(ts)...)); else { for (uint32_t i = 0; i < indent; i++) (*buffer) << " "; statement_inner(std::forward(ts)...); (*buffer) << '\n'; } } template inline void statement_no_indent(Ts &&... ts) { auto old_indent = indent; indent = 0; statement(std::forward(ts)...); indent = old_indent; } // Used for implementing continue blocks where // we want to obtain a list of statements we can merge // on a single line separated by comma. std::vector *redirect_statement = nullptr; const SPIRBlock *current_continue_block = nullptr; void begin_scope(); void end_scope(); void end_scope_decl(); void end_scope_decl(const std::string &decl); Options options; std::string type_to_array_glsl(const SPIRType &type); std::string to_array_size(const SPIRType &type, uint32_t index); uint32_t to_array_size_literal(const SPIRType &type, uint32_t index) const; std::string variable_decl(const SPIRVariable &variable); void add_local_variable_name(uint32_t id); void add_resource_name(uint32_t id); void add_member_name(SPIRType &type, uint32_t name); bool is_non_native_row_major_matrix(uint32_t id); bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index); virtual std::string convert_row_major_matrix(std::string exp_str); std::unordered_set local_variable_names; std::unordered_set resource_names; bool processing_entry_point = false; // Can be overriden by subclass backends for trivial things which // shouldn't need polymorphism. struct BackendVariations { std::string discard_literal = "discard"; bool float_literal_suffix = false; bool double_literal_suffix = true; bool uint32_t_literal_suffix = true; bool long_long_literal_suffix = false; const char *basic_int_type = "int"; const char *basic_uint_type = "uint"; bool swizzle_is_function = false; bool shared_is_implied = false; bool flexible_member_array_supported = true; bool explicit_struct_type = false; bool use_initializer_list = false; bool native_row_major_matrix = true; bool use_constructor_splatting = true; } backend; void emit_struct(SPIRType &type); void emit_resources(); void emit_buffer_block(const SPIRVariable &type); void emit_buffer_block_native(const SPIRVariable &var); void emit_buffer_block_legacy(const SPIRVariable &var); void emit_buffer_block_flattened(const SPIRVariable &type); void emit_push_constant_block(const SPIRVariable &var); void emit_push_constant_block_vulkan(const SPIRVariable &var); void emit_push_constant_block_glsl(const SPIRVariable &var); void emit_interface_block(const SPIRVariable &type); void emit_block_chain(SPIRBlock &block); void emit_specialization_constant(const SPIRConstant &constant); std::string emit_continue_block(uint32_t continue_block); bool attempt_emit_loop_header(SPIRBlock &block, SPIRBlock::Method method); void emit_uniform(const SPIRVariable &var); void propagate_loop_dominators(const SPIRBlock &block); void branch(uint32_t from, uint32_t to); void branch(uint32_t from, uint32_t cond, uint32_t true_block, uint32_t false_block); void flush_phi(uint32_t from, uint32_t to); bool flush_phi_required(uint32_t from, uint32_t to); void flush_variable_declaration(uint32_t id); void flush_undeclared_variables(SPIRBlock &block); bool should_forward(uint32_t id); void emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp); bool to_trivial_mix_op(const SPIRType &type, std::string &op, uint32_t left, uint32_t right, uint32_t lerp); void emit_quaternary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, uint32_t op3, const char *op); void emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2, const char *op); void emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); void emit_binary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type); void emit_unary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op); void emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op); void emit_binary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type); SPIRType binary_op_bitcast_helper(std::string &cast_op0, std::string &cast_op1, SPIRType::BaseType &input_type, uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type); void emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op); bool expression_is_forwarded(uint32_t id); SPIRExpression &emit_op(uint32_t result_type, uint32_t result_id, const std::string &rhs, bool forward_rhs, bool suppress_usage_tracking = false); std::string access_chain(uint32_t base, const uint32_t *indices, uint32_t count, bool index_is_literal, bool chain_only = false, bool *need_transpose = nullptr); std::string access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, bool *need_transpose = nullptr); std::string flattened_access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride = 0, bool need_transpose = false); std::string flattened_access_chain_struct(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset); std::string flattened_access_chain_matrix(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride, bool need_transpose); std::string flattened_access_chain_vector_scalar(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type, uint32_t offset); std::pair flattened_access_chain_offset(uint32_t base, const uint32_t *indices, uint32_t count, uint32_t offset, bool *need_transpose = nullptr, uint32_t *matrix_stride = nullptr); const char *index_to_swizzle(uint32_t index); std::string remap_swizzle(uint32_t result_type, uint32_t input_components, uint32_t expr); std::string declare_temporary(uint32_t type, uint32_t id); void append_global_func_args(const SPIRFunction &func, uint32_t index, std::vector &arglist); std::string to_expression(uint32_t id); std::string to_enclosed_expression(uint32_t id); void strip_enclosed_expression(std::string &expr); std::string to_member_name(const SPIRType &type, uint32_t index); std::string type_to_glsl_constructor(const SPIRType &type); std::string argument_decl(const SPIRFunction::Parameter &arg); std::string to_qualifiers_glsl(uint32_t id); const char *to_precision_qualifiers_glsl(uint32_t id); const char *flags_to_precision_qualifiers_glsl(const SPIRType &type, uint64_t flags); const char *format_to_glsl(spv::ImageFormat format); std::string layout_for_member(const SPIRType &type, uint32_t index); std::string to_interpolation_qualifiers(uint64_t flags); uint64_t combined_decoration_for_member(const SPIRType &type, uint32_t index); std::string layout_for_variable(const SPIRVariable &variable); std::string to_combined_image_sampler(uint32_t image_id, uint32_t samp_id); bool skip_argument(uint32_t id) const; bool ssbo_is_std430_packing(const SPIRType &type); uint32_t type_to_std430_base_size(const SPIRType &type); uint32_t type_to_std430_alignment(const SPIRType &type, uint64_t flags); uint32_t type_to_std430_array_stride(const SPIRType &type, uint64_t flags); uint32_t type_to_std430_size(const SPIRType &type, uint64_t flags); std::string bitcast_glsl(const SPIRType &result_type, uint32_t arg); std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type); std::string build_composite_combiner(const uint32_t *elems, uint32_t length); bool remove_duplicate_swizzle(std::string &op); bool remove_unity_swizzle(uint32_t base, std::string &op); // Can modify flags to remote readonly/writeonly if image type // and force recompile. bool check_atomic_image(uint32_t id); void replace_illegal_names(); void replace_fragment_output(SPIRVariable &var); void replace_fragment_outputs(); std::string legacy_tex_op(const std::string &op, const SPIRType &imgtype); uint32_t indent = 0; std::unordered_set emitted_functions; std::unordered_set flattened_buffer_blocks; // Usage tracking. If a temporary is used more than once, use the temporary instead to // avoid AST explosion when SPIRV is generated with pure SSA and doesn't write stuff to variables. std::unordered_map expression_usage_counts; std::unordered_set forced_temporaries; std::unordered_set forwarded_temporaries; void track_expression_read(uint32_t id); std::unordered_set forced_extensions; std::vector header_lines; uint32_t statement_count; inline bool is_legacy() const { return (options.es && options.version < 300) || (!options.es && options.version < 130); } inline bool is_legacy_es() const { return options.es && options.version < 300; } inline bool is_legacy_desktop() const { return !options.es && options.version < 130; } bool args_will_forward(uint32_t id, const uint32_t *args, uint32_t num_args, bool pure); void register_call_out_argument(uint32_t id); void register_impure_function_call(); // GL_EXT_shader_pixel_local_storage support. std::vector pls_inputs; std::vector pls_outputs; std::string pls_decl(const PlsRemap &variable); const char *to_pls_qualifiers_glsl(const SPIRVariable &variable); void emit_pls(); void remap_pls_variables(); void add_variable(std::unordered_set &variables, uint32_t id); void check_function_call_constraints(const uint32_t *args, uint32_t length); void handle_invalid_expression(uint32_t id); void find_static_extensions(); std::string emit_for_loop_initializers(const SPIRBlock &block); bool optimize_read_modify_write(const std::string &lhs, const std::string &rhs); void fixup_image_load_store_access(); }; } #endif