1 /* 2 * Copyright 2016-2021 Robert Konrad 3 * SPDX-License-Identifier: Apache-2.0 OR MIT 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /* 19 * At your option, you may choose to accept this material under either: 20 * 1. The Apache License, Version 2.0, found at <http://www.apache.org/licenses/LICENSE-2.0>, or 21 * 2. The MIT License, found at <http://opensource.org/licenses/MIT>. 22 */ 23 24 #ifndef SPIRV_HLSL_HPP 25 #define SPIRV_HLSL_HPP 26 27 #include "spirv_glsl.hpp" 28 #include <utility> 29 30 namespace SPIRV_CROSS_NAMESPACE 31 { 32 // Interface which remaps vertex inputs to a fixed semantic name to make linking easier. 33 struct HLSLVertexAttributeRemap 34 { 35 uint32_t location; 36 std::string semantic; 37 }; 38 // Specifying a root constant (d3d12) or push constant range (vulkan). 39 // 40 // `start` and `end` denotes the range of the root constant in bytes. 41 // Both values need to be multiple of 4. 42 struct RootConstants 43 { 44 uint32_t start; 45 uint32_t end; 46 47 uint32_t binding; 48 uint32_t space; 49 }; 50 51 // For finer control, decorations may be removed from specific resources instead with unset_decoration(). 52 enum HLSLBindingFlagBits 53 { 54 HLSL_BINDING_AUTO_NONE_BIT = 0, 55 56 // Push constant (root constant) resources will be declared as CBVs (b-space) without a register() declaration. 57 // A register will be automatically assigned by the D3D compiler, but must therefore be reflected in D3D-land. 58 // Push constants do not normally have a DecorationBinding set, but if they do, this can be used to ignore it. 59 HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0, 60 61 // cbuffer resources will be declared as CBVs (b-space) without a register() declaration. 62 // A register will be automatically assigned, but must be reflected in D3D-land. 63 HLSL_BINDING_AUTO_CBV_BIT = 1 << 1, 64 65 // All SRVs (t-space) will be declared without a register() declaration. 66 HLSL_BINDING_AUTO_SRV_BIT = 1 << 2, 67 68 // All UAVs (u-space) will be declared without a register() declaration. 69 HLSL_BINDING_AUTO_UAV_BIT = 1 << 3, 70 71 // All samplers (s-space) will be declared without a register() declaration. 72 HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4, 73 74 // No resources will be declared with register(). 75 HLSL_BINDING_AUTO_ALL = 0x7fffffff 76 }; 77 using HLSLBindingFlags = uint32_t; 78 79 // By matching stage, desc_set and binding for a SPIR-V resource, 80 // register bindings are set based on whether the HLSL resource is a 81 // CBV, UAV, SRV or Sampler. A single binding in SPIR-V might contain multiple 82 // resource types, e.g. COMBINED_IMAGE_SAMPLER, and SRV/Sampler bindings will be used respectively. 83 // On SM 5.0 and lower, register_space is ignored. 84 // 85 // To remap a push constant block which does not have any desc_set/binding associated with it, 86 // use ResourceBindingPushConstant{DescriptorSet,Binding} as values for desc_set/binding. 87 // For deeper control of push constants, set_root_constant_layouts() can be used instead. 88 struct HLSLResourceBinding 89 { 90 spv::ExecutionModel stage = spv::ExecutionModelMax; 91 uint32_t desc_set = 0; 92 uint32_t binding = 0; 93 94 struct Binding 95 { 96 uint32_t register_space = 0; 97 uint32_t register_binding = 0; 98 } cbv, uav, srv, sampler; 99 }; 100 101 class CompilerHLSL : public CompilerGLSL 102 { 103 public: 104 struct Options 105 { 106 uint32_t shader_model = 30; // TODO: map ps_4_0_level_9_0,... somehow 107 108 // Allows the PointSize builtin, and ignores it, as PointSize is not supported in HLSL. 109 bool point_size_compat = false; 110 111 // Allows the PointCoord builtin, returns float2(0.5, 0.5), as PointCoord is not supported in HLSL. 112 bool point_coord_compat = false; 113 114 // If true, the backend will assume that VertexIndex and InstanceIndex will need to apply 115 // a base offset, and you will need to fill in a cbuffer with offsets. 116 // Set to false if you know you will never use base instance or base vertex 117 // functionality as it might remove an internal cbuffer. 118 bool support_nonzero_base_vertex_base_instance = false; 119 120 // Forces a storage buffer to always be declared as UAV, even if the readonly decoration is used. 121 // By default, a readonly storage buffer will be declared as ByteAddressBuffer (SRV) instead. 122 // Alternatively, use set_hlsl_force_storage_buffer_as_uav to specify individually. 123 bool force_storage_buffer_as_uav = false; 124 125 // Forces any storage image type marked as NonWritable to be considered an SRV instead. 126 // For this to work with function call parameters, NonWritable must be considered to be part of the type system 127 // so that NonWritable image arguments are also translated to Texture rather than RWTexture. 128 bool nonwritable_uav_texture_as_srv = false; 129 130 // Enables native 16-bit types. Needs SM 6.2. 131 // Uses half/int16_t/uint16_t instead of min16* types. 132 // Also adds support for 16-bit load-store from (RW)ByteAddressBuffer. 133 bool enable_16bit_types = false; 134 135 // If matrices are used as IO variables, flatten the attribute declaration to use 136 // TEXCOORD{N,N+1,N+2,...} rather than TEXCOORDN_{0,1,2,3}. 137 // If add_vertex_attribute_remap is used and this feature is used, 138 // the semantic name will be queried once per active location. 139 bool flatten_matrix_vertex_input_semantics = false; 140 }; 141 CompilerHLSL(std::vector<uint32_t> spirv_)142 explicit CompilerHLSL(std::vector<uint32_t> spirv_) 143 : CompilerGLSL(std::move(spirv_)) 144 { 145 } 146 CompilerHLSL(const uint32_t * ir_,size_t size)147 CompilerHLSL(const uint32_t *ir_, size_t size) 148 : CompilerGLSL(ir_, size) 149 { 150 } 151 CompilerHLSL(const ParsedIR & ir_)152 explicit CompilerHLSL(const ParsedIR &ir_) 153 : CompilerGLSL(ir_) 154 { 155 } 156 CompilerHLSL(ParsedIR && ir_)157 explicit CompilerHLSL(ParsedIR &&ir_) 158 : CompilerGLSL(std::move(ir_)) 159 { 160 } 161 get_hlsl_options() const162 const Options &get_hlsl_options() const 163 { 164 return hlsl_options; 165 } 166 set_hlsl_options(const Options & opts)167 void set_hlsl_options(const Options &opts) 168 { 169 hlsl_options = opts; 170 } 171 172 // Optionally specify a custom root constant layout. 173 // 174 // Push constants ranges will be split up according to the 175 // layout specified. 176 void set_root_constant_layouts(std::vector<RootConstants> layout); 177 178 // Compiles and remaps vertex attributes at specific locations to a fixed semantic. 179 // The default is TEXCOORD# where # denotes location. 180 // Matrices are unrolled to vectors with notation ${SEMANTIC}_#, where # denotes row. 181 // $SEMANTIC is either TEXCOORD# or a semantic name specified here. 182 void add_vertex_attribute_remap(const HLSLVertexAttributeRemap &vertex_attributes); 183 std::string compile() override; 184 185 // This is a special HLSL workaround for the NumWorkGroups builtin. 186 // This does not exist in HLSL, so the calling application must create a dummy cbuffer in 187 // which the application will store this builtin. 188 // The cbuffer layout will be: 189 // cbuffer SPIRV_Cross_NumWorkgroups : register(b#, space#) { uint3 SPIRV_Cross_NumWorkgroups_count; }; 190 // This must be called before compile(). 191 // The function returns 0 if NumWorkGroups builtin is not statically used in the shader from the current entry point. 192 // If non-zero, this returns the variable ID of a cbuffer which corresponds to 193 // the cbuffer declared above. By default, no binding or descriptor set decoration is set, 194 // so the calling application should declare explicit bindings on this ID before calling compile(). 195 VariableID remap_num_workgroups_builtin(); 196 197 // Controls how resource bindings are declared in the output HLSL. 198 void set_resource_binding_flags(HLSLBindingFlags flags); 199 200 // resource is a resource binding to indicate the HLSL CBV, SRV, UAV or sampler binding 201 // to use for a particular SPIR-V description set 202 // and binding. If resource bindings are provided, 203 // is_hlsl_resource_binding_used() will return true after calling ::compile() if 204 // the set/binding combination was used by the HLSL code. 205 void add_hlsl_resource_binding(const HLSLResourceBinding &resource); 206 bool is_hlsl_resource_binding_used(spv::ExecutionModel model, uint32_t set, uint32_t binding) const; 207 208 // Controls which storage buffer bindings will be forced to be declared as UAVs. 209 void set_hlsl_force_storage_buffer_as_uav(uint32_t desc_set, uint32_t binding); 210 211 private: 212 std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override; 213 std::string image_type_hlsl(const SPIRType &type, uint32_t id); 214 std::string image_type_hlsl_modern(const SPIRType &type, uint32_t id); 215 std::string image_type_hlsl_legacy(const SPIRType &type, uint32_t id); 216 void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags) override; 217 void emit_hlsl_entry_point(); 218 void emit_header() override; 219 void emit_resources(); 220 void declare_undefined_values() override; 221 void emit_interface_block_globally(const SPIRVariable &type); 222 void emit_interface_block_in_struct(const SPIRVariable &var, std::unordered_set<uint32_t> &active_locations); 223 void emit_interface_block_member_in_struct(const SPIRVariable &var, uint32_t member_index, 224 uint32_t location, 225 std::unordered_set<uint32_t> &active_locations); 226 void emit_builtin_inputs_in_struct(); 227 void emit_builtin_outputs_in_struct(); 228 void emit_texture_op(const Instruction &i, bool sparse) override; 229 void emit_instruction(const Instruction &instruction) override; 230 void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, 231 uint32_t count) override; 232 void emit_buffer_block(const SPIRVariable &type) override; 233 void emit_push_constant_block(const SPIRVariable &var) override; 234 void emit_uniform(const SPIRVariable &var) override; 235 void emit_modern_uniform(const SPIRVariable &var); 236 void emit_legacy_uniform(const SPIRVariable &var); 237 void emit_specialization_constants_and_structs(); 238 void emit_composite_constants(); 239 void emit_fixup() override; 240 std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage) override; 241 std::string layout_for_member(const SPIRType &type, uint32_t index) override; 242 std::string to_interpolation_qualifiers(const Bitset &flags) override; 243 std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override; 244 bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0) override; 245 std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override; 246 std::string to_sampler_expression(uint32_t id); 247 std::string to_resource_binding(const SPIRVariable &var); 248 std::string to_resource_binding_sampler(const SPIRVariable &var); 249 std::string to_resource_register(HLSLBindingFlagBits flag, char space, uint32_t binding, uint32_t set); 250 std::string to_initializer_expression(const SPIRVariable &var) override; 251 void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id) override; 252 void emit_access_chain(const Instruction &instruction); 253 void emit_load(const Instruction &instruction); 254 void read_access_chain(std::string *expr, const std::string &lhs, const SPIRAccessChain &chain); 255 void read_access_chain_struct(const std::string &lhs, const SPIRAccessChain &chain); 256 void read_access_chain_array(const std::string &lhs, const SPIRAccessChain &chain); 257 void write_access_chain(const SPIRAccessChain &chain, uint32_t value, const SmallVector<uint32_t> &composite_chain); 258 void write_access_chain_struct(const SPIRAccessChain &chain, uint32_t value, 259 const SmallVector<uint32_t> &composite_chain); 260 void write_access_chain_array(const SPIRAccessChain &chain, uint32_t value, 261 const SmallVector<uint32_t> &composite_chain); 262 std::string write_access_chain_value(uint32_t value, const SmallVector<uint32_t> &composite_chain, bool enclose); 263 void emit_store(const Instruction &instruction); 264 void emit_atomic(const uint32_t *ops, uint32_t length, spv::Op op); 265 void emit_subgroup_op(const Instruction &i) override; 266 void emit_block_hints(const SPIRBlock &block) override; 267 268 void emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index, const std::string &qualifier, 269 uint32_t base_offset = 0) override; 270 271 const char *to_storage_qualifiers_glsl(const SPIRVariable &var) override; 272 void replace_illegal_names() override; 273 274 bool is_hlsl_force_storage_buffer_as_uav(ID id) const; 275 276 Options hlsl_options; 277 278 // TODO: Refactor this to be more similar to MSL, maybe have some common system in place? 279 bool requires_op_fmod = false; 280 bool requires_fp16_packing = false; 281 bool requires_uint2_packing = false; 282 bool requires_explicit_fp16_packing = false; 283 bool requires_unorm8_packing = false; 284 bool requires_snorm8_packing = false; 285 bool requires_unorm16_packing = false; 286 bool requires_snorm16_packing = false; 287 bool requires_bitfield_insert = false; 288 bool requires_bitfield_extract = false; 289 bool requires_inverse_2x2 = false; 290 bool requires_inverse_3x3 = false; 291 bool requires_inverse_4x4 = false; 292 bool requires_scalar_reflect = false; 293 bool requires_scalar_refract = false; 294 bool requires_scalar_faceforward = false; 295 296 struct TextureSizeVariants 297 { 298 // MSVC 2013 workaround. TextureSizeVariantsSPIRV_CROSS_NAMESPACE::CompilerHLSL::TextureSizeVariants299 TextureSizeVariants() 300 { 301 srv = 0; 302 for (auto &unorm : uav) 303 for (auto &u : unorm) 304 u = 0; 305 } 306 uint64_t srv; 307 uint64_t uav[3][4]; 308 } required_texture_size_variants; 309 310 void require_texture_query_variant(uint32_t var_id); 311 void emit_texture_size_variants(uint64_t variant_mask, const char *vecsize_qualifier, bool uav, 312 const char *type_qualifier); 313 314 enum TextureQueryVariantDim 315 { 316 Query1D = 0, 317 Query1DArray, 318 Query2D, 319 Query2DArray, 320 Query3D, 321 QueryBuffer, 322 QueryCube, 323 QueryCubeArray, 324 Query2DMS, 325 Query2DMSArray, 326 QueryDimCount 327 }; 328 329 enum TextureQueryVariantType 330 { 331 QueryTypeFloat = 0, 332 QueryTypeInt = 16, 333 QueryTypeUInt = 32, 334 QueryTypeCount = 3 335 }; 336 337 enum BitcastType 338 { 339 TypeNormal, 340 TypePackUint2x32, 341 TypeUnpackUint64 342 }; 343 344 BitcastType get_bitcast_type(uint32_t result_type, uint32_t op0); 345 346 void emit_builtin_variables(); 347 bool require_output = false; 348 bool require_input = false; 349 SmallVector<HLSLVertexAttributeRemap> remap_vertex_attributes; 350 351 uint32_t type_to_consumed_locations(const SPIRType &type) const; 352 353 std::string to_semantic(uint32_t location, spv::ExecutionModel em, spv::StorageClass sc); 354 355 uint32_t num_workgroups_builtin = 0; 356 HLSLBindingFlags resource_binding_flags = 0; 357 358 // Custom root constant layout, which should be emitted 359 // when translating push constant ranges. 360 std::vector<RootConstants> root_constants_layout; 361 362 void validate_shader_model(); 363 364 std::string get_unique_identifier(); 365 uint32_t unique_identifier_count = 0; 366 367 std::unordered_map<StageSetBinding, std::pair<HLSLResourceBinding, bool>, InternalHasher> resource_bindings; 368 void remap_hlsl_resource_binding(HLSLBindingFlagBits type, uint32_t &desc_set, uint32_t &binding); 369 370 std::unordered_set<SetBindingPair, InternalHasher> force_uav_buffer_bindings; 371 372 // Returns true for BuiltInSampleMask because gl_SampleMask[] is an array in SPIR-V, but SV_Coverage is a scalar in HLSL. 373 bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const override; 374 375 std::vector<TypeID> composite_selection_workaround_types; 376 }; 377 } // namespace SPIRV_CROSS_NAMESPACE 378 379 #endif 380