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