Debian Codegraph @

third_party/spirv-cross/spirv_hlsl.hpp

raw
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