Debian Codegraph @

third_party/spirv-cross/spirv_cross_c.cpp

raw
1 /*
2 * Copyright 2019-2020 Hans-Kristian Arntzen
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 #include "spirv_cross_c.h"
18
19 #if SPIRV_CROSS_C_API_CPP
20 #include "spirv_cpp.hpp"
21 #endif
22 #if SPIRV_CROSS_C_API_GLSL
23 #include "spirv_glsl.hpp"
24 #else
25 #include "spirv_cross.hpp"
26 #endif
27 #if SPIRV_CROSS_C_API_HLSL
28 #include "spirv_hlsl.hpp"
29 #endif
30 #if SPIRV_CROSS_C_API_MSL
31 #include "spirv_msl.hpp"
32 #endif
33 #if SPIRV_CROSS_C_API_REFLECT
34 #include "spirv_reflect.hpp"
35 #endif
36
37 #ifdef HAVE_SPIRV_CROSS_GIT_VERSION
38 #include "gitversion.h"
39 #endif
40
41 #include "spirv_parser.hpp"
42 #include <memory>
43 #include <new>
44 #include <string.h>
45
46 // clang-format off
47
48 #ifdef _MSC_VER
49 #pragma warning(push)
50 #pragma warning(disable : 4996)
51 #endif
52
53 #ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS
54 #define SPVC_BEGIN_SAFE_SCOPE try
55 #else
56 #define SPVC_BEGIN_SAFE_SCOPE
57 #endif
58
59 #ifndef SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS
60 #define SPVC_END_SAFE_SCOPE(context, error) \
61 catch (const std::exception &e) \
62 { \
63 (context)->report_error(e.what()); \
64 return (error); \
65 }
66 #else
67 #define SPVC_END_SAFE_SCOPE(context, error)
68 #endif
69
70 using namespace std;
71 using namespace SPIRV_CROSS_NAMESPACE;
72
73 struct ScratchMemoryAllocation
74 {
75 virtual ~ScratchMemoryAllocation() = default;
76 };
77
78 struct StringAllocation : ScratchMemoryAllocation
79 {
80 explicit StringAllocation(const char *name)
81 : str(name)
82 {
83 }
84
85 explicit StringAllocation(std::string name)
86 : str(std::move(name))
87 {
88 }
89
90 std::string str;
91 };
92
93 template <typename T>
94 struct TemporaryBuffer : ScratchMemoryAllocation
95 {
96 SmallVector<T> buffer;
97 };
98
99 template <typename T, typename... Ts>
100 static inline std::unique_ptr<T> spvc_allocate(Ts &&... ts)
101 {
102 return std::unique_ptr<T>(new T(std::forward<Ts>(ts)...));
103 }
104
105 struct spvc_context_s
106 {
107 string last_error;
108 SmallVector<unique_ptr<ScratchMemoryAllocation>> allocations;
109 const char *allocate_name(const std::string &name);
110
111 spvc_error_callback callback = nullptr;
112 void *callback_userdata = nullptr;
113 void report_error(std::string msg);
114 };
115
116 void spvc_context_s::report_error(std::string msg)
117 {
118 last_error = std::move(msg);
119 if (callback)
120 callback(callback_userdata, last_error.c_str());
121 }
122
123 const char *spvc_context_s::allocate_name(const std::string &name)
124 {
125 SPVC_BEGIN_SAFE_SCOPE
126 {
127 auto alloc = spvc_allocate<StringAllocation>(name);
128 auto *ret = alloc->str.c_str();
129 allocations.emplace_back(std::move(alloc));
130 return ret;
131 }
132 SPVC_END_SAFE_SCOPE(this, nullptr)
133 }
134
135 struct spvc_parsed_ir_s : ScratchMemoryAllocation
136 {
137 spvc_context context = nullptr;
138 ParsedIR parsed;
139 };
140
141 struct spvc_compiler_s : ScratchMemoryAllocation
142 {
143 spvc_context context = nullptr;
144 unique_ptr<Compiler> compiler;
145 spvc_backend backend = SPVC_BACKEND_NONE;
146 };
147
148 struct spvc_compiler_options_s : ScratchMemoryAllocation
149 {
150 spvc_context context = nullptr;
151 uint32_t backend_flags = 0;
152 #if SPIRV_CROSS_C_API_GLSL
153 CompilerGLSL::Options glsl;
154 #endif
155 #if SPIRV_CROSS_C_API_MSL
156 CompilerMSL::Options msl;
157 #endif
158 #if SPIRV_CROSS_C_API_HLSL
159 CompilerHLSL::Options hlsl;
160 #endif
161 };
162
163 struct spvc_set_s : ScratchMemoryAllocation
164 {
165 std::unordered_set<VariableID> set;
166 };
167
168 // Dummy-inherit to we can keep our opaque type handle type safe in C-land as well,
169 // and avoid just throwing void * around.
170 struct spvc_type_s : SPIRType
171 {
172 };
173
174 struct spvc_constant_s : SPIRConstant
175 {
176 };
177
178 struct spvc_resources_s : ScratchMemoryAllocation
179 {
180 spvc_context context = nullptr;
181 SmallVector<spvc_reflected_resource> uniform_buffers;
182 SmallVector<spvc_reflected_resource> storage_buffers;
183 SmallVector<spvc_reflected_resource> stage_inputs;
184 SmallVector<spvc_reflected_resource> stage_outputs;
185 SmallVector<spvc_reflected_resource> subpass_inputs;
186 SmallVector<spvc_reflected_resource> storage_images;
187 SmallVector<spvc_reflected_resource> sampled_images;
188 SmallVector<spvc_reflected_resource> atomic_counters;
189 SmallVector<spvc_reflected_resource> push_constant_buffers;
190 SmallVector<spvc_reflected_resource> separate_images;
191 SmallVector<spvc_reflected_resource> separate_samplers;
192 SmallVector<spvc_reflected_resource> acceleration_structures;
193
194 bool copy_resources(SmallVector<spvc_reflected_resource> &outputs, const SmallVector<Resource> &inputs);
195 bool copy_resources(const ShaderResources &resources);
196 };
197
198 spvc_result spvc_context_create(spvc_context *context)
199 {
200 auto *ctx = new (std::nothrow) spvc_context_s;
201 if (!ctx)
202 return SPVC_ERROR_OUT_OF_MEMORY;
203
204 *context = ctx;
205 return SPVC_SUCCESS;
206 }
207
208 void spvc_context_destroy(spvc_context context)
209 {
210 delete context;
211 }
212
213 void spvc_context_release_allocations(spvc_context context)
214 {
215 context->allocations.clear();
216 }
217
218 const char *spvc_context_get_last_error_string(spvc_context context)
219 {
220 return context->last_error.c_str();
221 }
222
223 SPVC_PUBLIC_API void spvc_context_set_error_callback(spvc_context context, spvc_error_callback cb, void *userdata)
224 {
225 context->callback = cb;
226 context->callback_userdata = userdata;
227 }
228
229 spvc_result spvc_context_parse_spirv(spvc_context context, const SpvId *spirv, size_t word_count,
230 spvc_parsed_ir *parsed_ir)
231 {
232 SPVC_BEGIN_SAFE_SCOPE
233 {
234 std::unique_ptr<spvc_parsed_ir_s> pir(new (std::nothrow) spvc_parsed_ir_s);
235 if (!pir)
236 {
237 context->report_error("Out of memory.");
238 return SPVC_ERROR_OUT_OF_MEMORY;
239 }
240
241 pir->context = context;
242 Parser parser(spirv, word_count);
243 parser.parse();
244 pir->parsed = move(parser.get_parsed_ir());
245 *parsed_ir = pir.get();
246 context->allocations.push_back(std::move(pir));
247 }
248 SPVC_END_SAFE_SCOPE(context, SPVC_ERROR_INVALID_SPIRV)
249 return SPVC_SUCCESS;
250 }
251
252 spvc_result spvc_context_create_compiler(spvc_context context, spvc_backend backend, spvc_parsed_ir parsed_ir,
253 spvc_capture_mode mode, spvc_compiler *compiler)
254 {
255 SPVC_BEGIN_SAFE_SCOPE
256 {
257 std::unique_ptr<spvc_compiler_s> comp(new (std::nothrow) spvc_compiler_s);
258 if (!comp)
259 {
260 context->report_error("Out of memory.");
261 return SPVC_ERROR_OUT_OF_MEMORY;
262 }
263 comp->backend = backend;
264 comp->context = context;
265
266 if (mode != SPVC_CAPTURE_MODE_COPY && mode != SPVC_CAPTURE_MODE_TAKE_OWNERSHIP)
267 {
268 context->report_error("Invalid argument for capture mode.");
269 return SPVC_ERROR_INVALID_ARGUMENT;
270 }
271
272 switch (backend)
273 {
274 case SPVC_BACKEND_NONE:
275 if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP)
276 comp->compiler.reset(new Compiler(move(parsed_ir->parsed)));
277 else if (mode == SPVC_CAPTURE_MODE_COPY)
278 comp->compiler.reset(new Compiler(parsed_ir->parsed));
279 break;
280
281 #if SPIRV_CROSS_C_API_GLSL
282 case SPVC_BACKEND_GLSL:
283 if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP)
284 comp->compiler.reset(new CompilerGLSL(move(parsed_ir->parsed)));
285 else if (mode == SPVC_CAPTURE_MODE_COPY)
286 comp->compiler.reset(new CompilerGLSL(parsed_ir->parsed));
287 break;
288 #endif
289
290 #if SPIRV_CROSS_C_API_HLSL
291 case SPVC_BACKEND_HLSL:
292 if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP)
293 comp->compiler.reset(new CompilerHLSL(move(parsed_ir->parsed)));
294 else if (mode == SPVC_CAPTURE_MODE_COPY)
295 comp->compiler.reset(new CompilerHLSL(parsed_ir->parsed));
296 break;
297 #endif
298
299 #if SPIRV_CROSS_C_API_MSL
300 case SPVC_BACKEND_MSL:
301 if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP)
302 comp->compiler.reset(new CompilerMSL(move(parsed_ir->parsed)));
303 else if (mode == SPVC_CAPTURE_MODE_COPY)
304 comp->compiler.reset(new CompilerMSL(parsed_ir->parsed));
305 break;
306 #endif
307
308 #if SPIRV_CROSS_C_API_CPP
309 case SPVC_BACKEND_CPP:
310 if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP)
311 comp->compiler.reset(new CompilerCPP(move(parsed_ir->parsed)));
312 else if (mode == SPVC_CAPTURE_MODE_COPY)
313 comp->compiler.reset(new CompilerCPP(parsed_ir->parsed));
314 break;
315 #endif
316
317 #if SPIRV_CROSS_C_API_REFLECT
318 case SPVC_BACKEND_JSON:
319 if (mode == SPVC_CAPTURE_MODE_TAKE_OWNERSHIP)
320 comp->compiler.reset(new CompilerReflection(move(parsed_ir->parsed)));
321 else if (mode == SPVC_CAPTURE_MODE_COPY)
322 comp->compiler.reset(new CompilerReflection(parsed_ir->parsed));
323 break;
324 #endif
325
326 default:
327 context->report_error("Invalid backend.");
328 return SPVC_ERROR_INVALID_ARGUMENT;
329 }
330
331 *compiler = comp.get();
332 context->allocations.push_back(std::move(comp));
333 }
334 SPVC_END_SAFE_SCOPE(context, SPVC_ERROR_OUT_OF_MEMORY)
335 return SPVC_SUCCESS;
336 }
337
338 spvc_result spvc_compiler_create_compiler_options(spvc_compiler compiler, spvc_compiler_options *options)
339 {
340 SPVC_BEGIN_SAFE_SCOPE
341 {
342 std::unique_ptr<spvc_compiler_options_s> opt(new (std::nothrow) spvc_compiler_options_s);
343 if (!opt)
344 {
345 compiler->context->report_error("Out of memory.");
346 return SPVC_ERROR_OUT_OF_MEMORY;
347 }
348
349 opt->context = compiler->context;
350 opt->backend_flags = 0;
351 switch (compiler->backend)
352 {
353 #if SPIRV_CROSS_C_API_MSL
354 case SPVC_BACKEND_MSL:
355 opt->backend_flags |= SPVC_COMPILER_OPTION_MSL_BIT | SPVC_COMPILER_OPTION_COMMON_BIT;
356 opt->glsl = static_cast<CompilerMSL *>(compiler->compiler.get())->get_common_options();
357 opt->msl = static_cast<CompilerMSL *>(compiler->compiler.get())->get_msl_options();
358 break;
359 #endif
360
361 #if SPIRV_CROSS_C_API_HLSL
362 case SPVC_BACKEND_HLSL:
363 opt->backend_flags |= SPVC_COMPILER_OPTION_HLSL_BIT | SPVC_COMPILER_OPTION_COMMON_BIT;
364 opt->glsl = static_cast<CompilerHLSL *>(compiler->compiler.get())->get_common_options();
365 opt->hlsl = static_cast<CompilerHLSL *>(compiler->compiler.get())->get_hlsl_options();
366 break;
367 #endif
368
369 #if SPIRV_CROSS_C_API_GLSL
370 case SPVC_BACKEND_GLSL:
371 opt->backend_flags |= SPVC_COMPILER_OPTION_GLSL_BIT | SPVC_COMPILER_OPTION_COMMON_BIT;
372 opt->glsl = static_cast<CompilerGLSL *>(compiler->compiler.get())->get_common_options();
373 break;
374 #endif
375
376 default:
377 break;
378 }
379
380 *options = opt.get();
381 compiler->context->allocations.push_back(std::move(opt));
382 }
383 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
384 return SPVC_SUCCESS;
385 }
386
387 spvc_result spvc_compiler_options_set_bool(spvc_compiler_options options, spvc_compiler_option option,
388 spvc_bool value)
389 {
390 return spvc_compiler_options_set_uint(options, option, value ? 1 : 0);
391 }
392
393 spvc_result spvc_compiler_options_set_uint(spvc_compiler_options options, spvc_compiler_option option, unsigned value)
394 {
395 (void)value;
396 (void)option;
397 uint32_t supported_mask = options->backend_flags;
398 uint32_t required_mask = option & SPVC_COMPILER_OPTION_LANG_BITS;
399 if ((required_mask | supported_mask) != supported_mask)
400 {
401 options->context->report_error("Option is not supported by current backend.");
402 return SPVC_ERROR_INVALID_ARGUMENT;
403 }
404
405 switch (option)
406 {
407 #if SPIRV_CROSS_C_API_GLSL
408 case SPVC_COMPILER_OPTION_FORCE_TEMPORARY:
409 options->glsl.force_temporary = value != 0;
410 break;
411 case SPVC_COMPILER_OPTION_FLATTEN_MULTIDIMENSIONAL_ARRAYS:
412 options->glsl.flatten_multidimensional_arrays = value != 0;
413 break;
414 case SPVC_COMPILER_OPTION_FIXUP_DEPTH_CONVENTION:
415 options->glsl.vertex.fixup_clipspace = value != 0;
416 break;
417 case SPVC_COMPILER_OPTION_FLIP_VERTEX_Y:
418 options->glsl.vertex.flip_vert_y = value != 0;
419 break;
420 case SPVC_COMPILER_OPTION_EMIT_LINE_DIRECTIVES:
421 options->glsl.emit_line_directives = value != 0;
422 break;
423 case SPVC_COMPILER_OPTION_ENABLE_STORAGE_IMAGE_QUALIFIER_DEDUCTION:
424 options->glsl.enable_storage_image_qualifier_deduction = value != 0;
425 break;
426 case SPVC_COMPILER_OPTION_FORCE_ZERO_INITIALIZED_VARIABLES:
427 options->glsl.force_zero_initialized_variables = value != 0;
428 break;
429
430 case SPVC_COMPILER_OPTION_GLSL_SUPPORT_NONZERO_BASE_INSTANCE:
431 options->glsl.vertex.support_nonzero_base_instance = value != 0;
432 break;
433 case SPVC_COMPILER_OPTION_GLSL_SEPARATE_SHADER_OBJECTS:
434 options->glsl.separate_shader_objects = value != 0;
435 break;
436 case SPVC_COMPILER_OPTION_GLSL_ENABLE_420PACK_EXTENSION:
437 options->glsl.enable_420pack_extension = value != 0;
438 break;
439 case SPVC_COMPILER_OPTION_GLSL_VERSION:
440 options->glsl.version = value;
441 break;
442 case SPVC_COMPILER_OPTION_GLSL_ES:
443 options->glsl.es = value != 0;
444 break;
445 case SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS:
446 options->glsl.vulkan_semantics = value != 0;
447 break;
448 case SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_FLOAT_PRECISION_HIGHP:
449 options->glsl.fragment.default_float_precision =
450 value != 0 ? CompilerGLSL::Options::Precision::Highp : CompilerGLSL::Options::Precision::Mediump;
451 break;
452 case SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_INT_PRECISION_HIGHP:
453 options->glsl.fragment.default_int_precision =
454 value != 0 ? CompilerGLSL::Options::Precision::Highp : CompilerGLSL::Options::Precision::Mediump;
455 break;
456 case SPVC_COMPILER_OPTION_GLSL_EMIT_PUSH_CONSTANT_AS_UNIFORM_BUFFER:
457 options->glsl.emit_push_constant_as_uniform_buffer = value != 0;
458 break;
459 case SPVC_COMPILER_OPTION_GLSL_EMIT_UNIFORM_BUFFER_AS_PLAIN_UNIFORMS:
460 options->glsl.emit_uniform_buffer_as_plain_uniforms = value != 0;
461 break;
462 case SPVC_COMPILER_OPTION_GLSL_FORCE_FLATTENED_IO_BLOCKS:
463 options->glsl.force_flattened_io_blocks = value != 0;
464 break;
465 #endif
466
467 #if SPIRV_CROSS_C_API_HLSL
468 case SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL:
469 options->hlsl.shader_model = value;
470 break;
471
472 case SPVC_COMPILER_OPTION_HLSL_POINT_SIZE_COMPAT:
473 options->hlsl.point_size_compat = value != 0;
474 break;
475
476 case SPVC_COMPILER_OPTION_HLSL_POINT_COORD_COMPAT:
477 options->hlsl.point_coord_compat = value != 0;
478 break;
479
480 case SPVC_COMPILER_OPTION_HLSL_SUPPORT_NONZERO_BASE_VERTEX_BASE_INSTANCE:
481 options->hlsl.support_nonzero_base_vertex_base_instance = value != 0;
482 break;
483
484 case SPVC_COMPILER_OPTION_HLSL_FORCE_STORAGE_BUFFER_AS_UAV:
485 options->hlsl.force_storage_buffer_as_uav = value != 0;
486 break;
487
488 case SPVC_COMPILER_OPTION_HLSL_NONWRITABLE_UAV_TEXTURE_AS_SRV:
489 options->hlsl.nonwritable_uav_texture_as_srv = value != 0;
490 break;
491
492 case SPVC_COMPILER_OPTION_HLSL_ENABLE_16BIT_TYPES:
493 options->hlsl.enable_16bit_types = value != 0;
494 break;
495
496 case SPVC_COMPILER_OPTION_HLSL_FLATTEN_MATRIX_VERTEX_INPUT_SEMANTICS:
497 options->hlsl.flatten_matrix_vertex_input_semantics = value != 0;
498 break;
499 #endif
500
501 #if SPIRV_CROSS_C_API_MSL
502 case SPVC_COMPILER_OPTION_MSL_VERSION:
503 options->msl.msl_version = value;
504 break;
505
506 case SPVC_COMPILER_OPTION_MSL_TEXEL_BUFFER_TEXTURE_WIDTH:
507 options->msl.texel_buffer_texture_width = value;
508 break;
509
510 case SPVC_COMPILER_OPTION_MSL_SWIZZLE_BUFFER_INDEX:
511 options->msl.swizzle_buffer_index = value;
512 break;
513
514 case SPVC_COMPILER_OPTION_MSL_INDIRECT_PARAMS_BUFFER_INDEX:
515 options->msl.indirect_params_buffer_index = value;
516 break;
517
518 case SPVC_COMPILER_OPTION_MSL_SHADER_OUTPUT_BUFFER_INDEX:
519 options->msl.shader_output_buffer_index = value;
520 break;
521
522 case SPVC_COMPILER_OPTION_MSL_SHADER_PATCH_OUTPUT_BUFFER_INDEX:
523 options->msl.shader_patch_output_buffer_index = value;
524 break;
525
526 case SPVC_COMPILER_OPTION_MSL_SHADER_TESS_FACTOR_OUTPUT_BUFFER_INDEX:
527 options->msl.shader_tess_factor_buffer_index = value;
528 break;
529
530 case SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_WORKGROUP_INDEX:
531 options->msl.shader_input_wg_index = value;
532 break;
533
534 case SPVC_COMPILER_OPTION_MSL_ENABLE_POINT_SIZE_BUILTIN:
535 options->msl.enable_point_size_builtin = value != 0;
536 break;
537
538 case SPVC_COMPILER_OPTION_MSL_DISABLE_RASTERIZATION:
539 options->msl.disable_rasterization = value != 0;
540 break;
541
542 case SPVC_COMPILER_OPTION_MSL_CAPTURE_OUTPUT_TO_BUFFER:
543 options->msl.capture_output_to_buffer = value != 0;
544 break;
545
546 case SPVC_COMPILER_OPTION_MSL_SWIZZLE_TEXTURE_SAMPLES:
547 options->msl.swizzle_texture_samples = value != 0;
548 break;
549
550 case SPVC_COMPILER_OPTION_MSL_PAD_FRAGMENT_OUTPUT_COMPONENTS:
551 options->msl.pad_fragment_output_components = value != 0;
552 break;
553
554 case SPVC_COMPILER_OPTION_MSL_TESS_DOMAIN_ORIGIN_LOWER_LEFT:
555 options->msl.tess_domain_origin_lower_left = value != 0;
556 break;
557
558 case SPVC_COMPILER_OPTION_MSL_PLATFORM:
559 options->msl.platform = static_cast<CompilerMSL::Options::Platform>(value);
560 break;
561
562 case SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS:
563 options->msl.argument_buffers = value != 0;
564 break;
565
566 case SPVC_COMPILER_OPTION_MSL_TEXTURE_BUFFER_NATIVE:
567 options->msl.texture_buffer_native = value != 0;
568 break;
569
570 case SPVC_COMPILER_OPTION_MSL_BUFFER_SIZE_BUFFER_INDEX:
571 options->msl.buffer_size_buffer_index = value;
572 break;
573
574 case SPVC_COMPILER_OPTION_MSL_MULTIVIEW:
575 options->msl.multiview = value != 0;
576 break;
577
578 case SPVC_COMPILER_OPTION_MSL_VIEW_MASK_BUFFER_INDEX:
579 options->msl.view_mask_buffer_index = value;
580 break;
581
582 case SPVC_COMPILER_OPTION_MSL_DEVICE_INDEX:
583 options->msl.device_index = value;
584 break;
585
586 case SPVC_COMPILER_OPTION_MSL_VIEW_INDEX_FROM_DEVICE_INDEX:
587 options->msl.view_index_from_device_index = value != 0;
588 break;
589
590 case SPVC_COMPILER_OPTION_MSL_DISPATCH_BASE:
591 options->msl.dispatch_base = value != 0;
592 break;
593
594 case SPVC_COMPILER_OPTION_MSL_DYNAMIC_OFFSETS_BUFFER_INDEX:
595 options->msl.dynamic_offsets_buffer_index = value;
596 break;
597
598 case SPVC_COMPILER_OPTION_MSL_TEXTURE_1D_AS_2D:
599 options->msl.texture_1D_as_2D = value != 0;
600 break;
601
602 case SPVC_COMPILER_OPTION_MSL_ENABLE_BASE_INDEX_ZERO:
603 options->msl.enable_base_index_zero = value != 0;
604 break;
605
606 case SPVC_COMPILER_OPTION_MSL_FRAMEBUFFER_FETCH_SUBPASS:
607 options->msl.use_framebuffer_fetch_subpasses = value != 0;
608 break;
609
610 case SPVC_COMPILER_OPTION_MSL_INVARIANT_FP_MATH:
611 options->msl.invariant_float_math = value != 0;
612 break;
613
614 case SPVC_COMPILER_OPTION_MSL_EMULATE_CUBEMAP_ARRAY:
615 options->msl.emulate_cube_array = value != 0;
616 break;
617
618 case SPVC_COMPILER_OPTION_MSL_ENABLE_DECORATION_BINDING:
619 options->msl.enable_decoration_binding = value != 0;
620 break;
621
622 case SPVC_COMPILER_OPTION_MSL_FORCE_ACTIVE_ARGUMENT_BUFFER_RESOURCES:
623 options->msl.force_active_argument_buffer_resources = value != 0;
624 break;
625
626 case SPVC_COMPILER_OPTION_MSL_FORCE_NATIVE_ARRAYS:
627 options->msl.force_native_arrays = value != 0;
628 break;
629
630 case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK:
631 options->msl.enable_frag_output_mask = value;
632 break;
633
634 case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN:
635 options->msl.enable_frag_depth_builtin = value != 0;
636 break;
637
638 case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN:
639 options->msl.enable_frag_stencil_ref_builtin = value != 0;
640 break;
641
642 case SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING:
643 options->msl.enable_clip_distance_user_varying = value != 0;
644 break;
645
646 case SPVC_COMPILER_OPTION_MSL_MULTI_PATCH_WORKGROUP:
647 options->msl.multi_patch_workgroup = value != 0;
648 break;
649
650 case SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_BUFFER_INDEX:
651 options->msl.shader_input_buffer_index = value;
652 break;
653
654 case SPVC_COMPILER_OPTION_MSL_SHADER_INDEX_BUFFER_INDEX:
655 options->msl.shader_index_buffer_index = value;
656 break;
657
658 case SPVC_COMPILER_OPTION_MSL_VERTEX_FOR_TESSELLATION:
659 options->msl.vertex_for_tessellation = value != 0;
660 break;
661
662 case SPVC_COMPILER_OPTION_MSL_VERTEX_INDEX_TYPE:
663 options->msl.vertex_index_type = static_cast<CompilerMSL::Options::IndexType>(value);
664 break;
665
666 case SPVC_COMPILER_OPTION_MSL_MULTIVIEW_LAYERED_RENDERING:
667 options->msl.multiview_layered_rendering = value != 0;
668 break;
669
670 case SPVC_COMPILER_OPTION_MSL_ARRAYED_SUBPASS_INPUT:
671 options->msl.arrayed_subpass_input = value != 0;
672 break;
673
674 case SPVC_COMPILER_OPTION_MSL_R32UI_LINEAR_TEXTURE_ALIGNMENT:
675 options->msl.r32ui_linear_texture_alignment = value;
676 break;
677
678 case SPVC_COMPILER_OPTION_MSL_R32UI_ALIGNMENT_CONSTANT_ID:
679 options->msl.r32ui_alignment_constant_id = value;
680 break;
681 #endif
682
683 default:
684 options->context->report_error("Unknown option.");
685 return SPVC_ERROR_INVALID_ARGUMENT;
686 }
687
688 return SPVC_SUCCESS;
689 }
690
691 spvc_result spvc_compiler_install_compiler_options(spvc_compiler compiler, spvc_compiler_options options)
692 {
693 (void)options;
694 switch (compiler->backend)
695 {
696 #if SPIRV_CROSS_C_API_GLSL
697 case SPVC_BACKEND_GLSL:
698 static_cast<CompilerGLSL &>(*compiler->compiler).set_common_options(options->glsl);
699 break;
700 #endif
701
702 #if SPIRV_CROSS_C_API_HLSL
703 case SPVC_BACKEND_HLSL:
704 static_cast<CompilerHLSL &>(*compiler->compiler).set_common_options(options->glsl);
705 static_cast<CompilerHLSL &>(*compiler->compiler).set_hlsl_options(options->hlsl);
706 break;
707 #endif
708
709 #if SPIRV_CROSS_C_API_MSL
710 case SPVC_BACKEND_MSL:
711 static_cast<CompilerMSL &>(*compiler->compiler).set_common_options(options->glsl);
712 static_cast<CompilerMSL &>(*compiler->compiler).set_msl_options(options->msl);
713 break;
714 #endif
715
716 default:
717 break;
718 }
719
720 return SPVC_SUCCESS;
721 }
722
723 spvc_result spvc_compiler_add_header_line(spvc_compiler compiler, const char *line)
724 {
725 #if SPIRV_CROSS_C_API_GLSL
726 if (compiler->backend == SPVC_BACKEND_NONE)
727 {
728 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
729 return SPVC_ERROR_INVALID_ARGUMENT;
730 }
731
732 static_cast<CompilerGLSL *>(compiler->compiler.get())->add_header_line(line);
733 return SPVC_SUCCESS;
734 #else
735 (void)line;
736 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
737 return SPVC_ERROR_INVALID_ARGUMENT;
738 #endif
739 }
740
741 spvc_result spvc_compiler_require_extension(spvc_compiler compiler, const char *line)
742 {
743 #if SPIRV_CROSS_C_API_GLSL
744 if (compiler->backend == SPVC_BACKEND_NONE)
745 {
746 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
747 return SPVC_ERROR_INVALID_ARGUMENT;
748 }
749
750 static_cast<CompilerGLSL *>(compiler->compiler.get())->require_extension(line);
751 return SPVC_SUCCESS;
752 #else
753 (void)line;
754 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
755 return SPVC_ERROR_INVALID_ARGUMENT;
756 #endif
757 }
758
759 spvc_result spvc_compiler_flatten_buffer_block(spvc_compiler compiler, spvc_variable_id id)
760 {
761 #if SPIRV_CROSS_C_API_GLSL
762 if (compiler->backend == SPVC_BACKEND_NONE)
763 {
764 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
765 return SPVC_ERROR_INVALID_ARGUMENT;
766 }
767
768 static_cast<CompilerGLSL *>(compiler->compiler.get())->flatten_buffer_block(id);
769 return SPVC_SUCCESS;
770 #else
771 (void)id;
772 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
773 return SPVC_ERROR_INVALID_ARGUMENT;
774 #endif
775 }
776
777 spvc_bool spvc_compiler_variable_is_depth_or_compare(spvc_compiler compiler, spvc_variable_id id)
778 {
779 #if SPIRV_CROSS_C_API_GLSL
780 if (compiler->backend == SPVC_BACKEND_NONE)
781 {
782 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
783 return SPVC_ERROR_INVALID_ARGUMENT;
784 }
785
786 return static_cast<CompilerGLSL *>(compiler->compiler.get())->variable_is_depth_or_compare(id) ? SPVC_TRUE : SPVC_FALSE;
787 #else
788 (void)id;
789 compiler->context->report_error("Cross-compilation related option used on NONE backend which only supports reflection.");
790 return SPVC_FALSE;
791 #endif
792 }
793
794 spvc_result spvc_compiler_hlsl_set_root_constants_layout(spvc_compiler compiler,
795 const spvc_hlsl_root_constants *constant_info,
796 size_t count)
797 {
798 #if SPIRV_CROSS_C_API_HLSL
799 if (compiler->backend != SPVC_BACKEND_HLSL)
800 {
801 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
802 return SPVC_ERROR_INVALID_ARGUMENT;
803 }
804
805 auto &hlsl = *static_cast<CompilerHLSL *>(compiler->compiler.get());
806 vector<RootConstants> roots;
807 roots.reserve(count);
808 for (size_t i = 0; i < count; i++)
809 {
810 RootConstants root;
811 root.binding = constant_info[i].binding;
812 root.space = constant_info[i].space;
813 root.start = constant_info[i].start;
814 root.end = constant_info[i].end;
815 roots.push_back(root);
816 }
817
818 hlsl.set_root_constant_layouts(std::move(roots));
819 return SPVC_SUCCESS;
820 #else
821 (void)constant_info;
822 (void)count;
823 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
824 return SPVC_ERROR_INVALID_ARGUMENT;
825 #endif
826 }
827
828 spvc_result spvc_compiler_hlsl_add_vertex_attribute_remap(spvc_compiler compiler,
829 const spvc_hlsl_vertex_attribute_remap *remap,
830 size_t count)
831 {
832 #if SPIRV_CROSS_C_API_HLSL
833 if (compiler->backend != SPVC_BACKEND_HLSL)
834 {
835 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
836 return SPVC_ERROR_INVALID_ARGUMENT;
837 }
838
839 HLSLVertexAttributeRemap re;
840 auto &hlsl = *static_cast<CompilerHLSL *>(compiler->compiler.get());
841 for (size_t i = 0; i < count; i++)
842 {
843 re.location = remap[i].location;
844 re.semantic = remap[i].semantic;
845 hlsl.add_vertex_attribute_remap(re);
846 }
847
848 return SPVC_SUCCESS;
849 #else
850 (void)remap;
851 (void)count;
852 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
853 return SPVC_ERROR_INVALID_ARGUMENT;
854 #endif
855 }
856
857 spvc_variable_id spvc_compiler_hlsl_remap_num_workgroups_builtin(spvc_compiler compiler)
858 {
859 #if SPIRV_CROSS_C_API_HLSL
860 if (compiler->backend != SPVC_BACKEND_HLSL)
861 {
862 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
863 return 0;
864 }
865
866 auto &hlsl = *static_cast<CompilerHLSL *>(compiler->compiler.get());
867 return hlsl.remap_num_workgroups_builtin();
868 #else
869 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
870 return 0;
871 #endif
872 }
873
874 spvc_result spvc_compiler_hlsl_set_resource_binding_flags(spvc_compiler compiler,
875 spvc_hlsl_binding_flags flags)
876 {
877 #if SPIRV_CROSS_C_API_HLSL
878 if (compiler->backend != SPVC_BACKEND_HLSL)
879 {
880 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
881 return SPVC_ERROR_INVALID_ARGUMENT;
882 }
883
884 auto &hlsl = *static_cast<CompilerHLSL *>(compiler->compiler.get());
885 hlsl.set_resource_binding_flags(flags);
886 return SPVC_SUCCESS;
887 #else
888 (void)flags;
889 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
890 return SPVC_ERROR_INVALID_ARGUMENT;
891 #endif
892 }
893
894 spvc_result spvc_compiler_hlsl_add_resource_binding(spvc_compiler compiler,
895 const spvc_hlsl_resource_binding *binding)
896 {
897 #if SPIRV_CROSS_C_API_HLSL
898 if (compiler->backend != SPVC_BACKEND_HLSL)
899 {
900 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
901 return SPVC_ERROR_INVALID_ARGUMENT;
902 }
903
904 auto &hlsl = *static_cast<CompilerHLSL *>(compiler->compiler.get());
905 HLSLResourceBinding bind;
906 bind.binding = binding->binding;
907 bind.desc_set = binding->desc_set;
908 bind.stage = static_cast<spv::ExecutionModel>(binding->stage);
909 bind.cbv.register_binding = binding->cbv.register_binding;
910 bind.cbv.register_space = binding->cbv.register_space;
911 bind.uav.register_binding = binding->uav.register_binding;
912 bind.uav.register_space = binding->uav.register_space;
913 bind.srv.register_binding = binding->srv.register_binding;
914 bind.srv.register_space = binding->srv.register_space;
915 bind.sampler.register_binding = binding->sampler.register_binding;
916 bind.sampler.register_space = binding->sampler.register_space;
917 hlsl.add_hlsl_resource_binding(bind);
918 return SPVC_SUCCESS;
919 #else
920 (void)binding;
921 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
922 return SPVC_ERROR_INVALID_ARGUMENT;
923 #endif
924 }
925
926 spvc_bool spvc_compiler_hlsl_is_resource_used(spvc_compiler compiler, SpvExecutionModel model, unsigned set,
927 unsigned binding)
928 {
929 #if SPIRV_CROSS_C_API_HLSL
930 if (compiler->backend != SPVC_BACKEND_HLSL)
931 {
932 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
933 return SPVC_FALSE;
934 }
935
936 auto &hlsl = *static_cast<CompilerHLSL *>(compiler->compiler.get());
937 return hlsl.is_hlsl_resource_binding_used(static_cast<spv::ExecutionModel>(model), set, binding) ? SPVC_TRUE :
938 SPVC_FALSE;
939 #else
940 (void)model;
941 (void)set;
942 (void)binding;
943 compiler->context->report_error("HLSL function used on a non-HLSL backend.");
944 return SPVC_FALSE;
945 #endif
946 }
947
948 spvc_bool spvc_compiler_msl_is_rasterization_disabled(spvc_compiler compiler)
949 {
950 #if SPIRV_CROSS_C_API_MSL
951 if (compiler->backend != SPVC_BACKEND_MSL)
952 {
953 compiler->context->report_error("MSL function used on a non-MSL backend.");
954 return SPVC_FALSE;
955 }
956
957 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
958 return msl.get_is_rasterization_disabled() ? SPVC_TRUE : SPVC_FALSE;
959 #else
960 compiler->context->report_error("MSL function used on a non-MSL backend.");
961 return SPVC_FALSE;
962 #endif
963 }
964
965 spvc_bool spvc_compiler_msl_needs_swizzle_buffer(spvc_compiler compiler)
966 {
967 #if SPIRV_CROSS_C_API_MSL
968 if (compiler->backend != SPVC_BACKEND_MSL)
969 {
970 compiler->context->report_error("MSL function used on a non-MSL backend.");
971 return SPVC_FALSE;
972 }
973
974 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
975 return msl.needs_swizzle_buffer() ? SPVC_TRUE : SPVC_FALSE;
976 #else
977 compiler->context->report_error("MSL function used on a non-MSL backend.");
978 return SPVC_FALSE;
979 #endif
980 }
981
982 spvc_bool spvc_compiler_msl_needs_buffer_size_buffer(spvc_compiler compiler)
983 {
984 #if SPIRV_CROSS_C_API_MSL
985 if (compiler->backend != SPVC_BACKEND_MSL)
986 {
987 compiler->context->report_error("MSL function used on a non-MSL backend.");
988 return SPVC_FALSE;
989 }
990
991 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
992 return msl.needs_buffer_size_buffer() ? SPVC_TRUE : SPVC_FALSE;
993 #else
994 compiler->context->report_error("MSL function used on a non-MSL backend.");
995 return SPVC_FALSE;
996 #endif
997 }
998
999 spvc_bool spvc_compiler_msl_needs_aux_buffer(spvc_compiler compiler)
1000 {
1001 return spvc_compiler_msl_needs_swizzle_buffer(compiler);
1002 }
1003
1004 spvc_bool spvc_compiler_msl_needs_output_buffer(spvc_compiler compiler)
1005 {
1006 #if SPIRV_CROSS_C_API_MSL
1007 if (compiler->backend != SPVC_BACKEND_MSL)
1008 {
1009 compiler->context->report_error("MSL function used on a non-MSL backend.");
1010 return SPVC_FALSE;
1011 }
1012
1013 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1014 return msl.needs_output_buffer() ? SPVC_TRUE : SPVC_FALSE;
1015 #else
1016 compiler->context->report_error("MSL function used on a non-MSL backend.");
1017 return SPVC_FALSE;
1018 #endif
1019 }
1020
1021 spvc_bool spvc_compiler_msl_needs_patch_output_buffer(spvc_compiler compiler)
1022 {
1023 #if SPIRV_CROSS_C_API_MSL
1024 if (compiler->backend != SPVC_BACKEND_MSL)
1025 {
1026 compiler->context->report_error("MSL function used on a non-MSL backend.");
1027 return SPVC_FALSE;
1028 }
1029
1030 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1031 return msl.needs_patch_output_buffer() ? SPVC_TRUE : SPVC_FALSE;
1032 #else
1033 compiler->context->report_error("MSL function used on a non-MSL backend.");
1034 return SPVC_FALSE;
1035 #endif
1036 }
1037
1038 spvc_bool spvc_compiler_msl_needs_input_threadgroup_mem(spvc_compiler compiler)
1039 {
1040 #if SPIRV_CROSS_C_API_MSL
1041 if (compiler->backend != SPVC_BACKEND_MSL)
1042 {
1043 compiler->context->report_error("MSL function used on a non-MSL backend.");
1044 return SPVC_FALSE;
1045 }
1046
1047 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1048 return msl.needs_input_threadgroup_mem() ? SPVC_TRUE : SPVC_FALSE;
1049 #else
1050 compiler->context->report_error("MSL function used on a non-MSL backend.");
1051 return SPVC_FALSE;
1052 #endif
1053 }
1054
1055 spvc_result spvc_compiler_msl_add_vertex_attribute(spvc_compiler compiler, const spvc_msl_vertex_attribute *va)
1056 {
1057 #if SPIRV_CROSS_C_API_MSL
1058 if (compiler->backend != SPVC_BACKEND_MSL)
1059 {
1060 compiler->context->report_error("MSL function used on a non-MSL backend.");
1061 return SPVC_ERROR_INVALID_ARGUMENT;
1062 }
1063
1064 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1065 MSLShaderInput attr;
1066 attr.location = va->location;
1067 attr.format = static_cast<MSLShaderInputFormat>(va->format);
1068 attr.builtin = static_cast<spv::BuiltIn>(va->builtin);
1069 msl.add_msl_shader_input(attr);
1070 return SPVC_SUCCESS;
1071 #else
1072 (void)va;
1073 compiler->context->report_error("MSL function used on a non-MSL backend.");
1074 return SPVC_ERROR_INVALID_ARGUMENT;
1075 #endif
1076 }
1077
1078 spvc_result spvc_compiler_msl_add_shader_input(spvc_compiler compiler, const spvc_msl_shader_input *si)
1079 {
1080 #if SPIRV_CROSS_C_API_MSL
1081 if (compiler->backend != SPVC_BACKEND_MSL)
1082 {
1083 compiler->context->report_error("MSL function used on a non-MSL backend.");
1084 return SPVC_ERROR_INVALID_ARGUMENT;
1085 }
1086
1087 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1088 MSLShaderInput input;
1089 input.location = si->location;
1090 input.format = static_cast<MSLShaderInputFormat>(si->format);
1091 input.builtin = static_cast<spv::BuiltIn>(si->builtin);
1092 input.vecsize = si->vecsize;
1093 msl.add_msl_shader_input(input);
1094 return SPVC_SUCCESS;
1095 #else
1096 (void)si;
1097 compiler->context->report_error("MSL function used on a non-MSL backend.");
1098 return SPVC_ERROR_INVALID_ARGUMENT;
1099 #endif
1100 }
1101
1102 spvc_result spvc_compiler_msl_add_resource_binding(spvc_compiler compiler,
1103 const spvc_msl_resource_binding *binding)
1104 {
1105 #if SPIRV_CROSS_C_API_MSL
1106 if (compiler->backend != SPVC_BACKEND_MSL)
1107 {
1108 compiler->context->report_error("MSL function used on a non-MSL backend.");
1109 return SPVC_ERROR_INVALID_ARGUMENT;
1110 }
1111
1112 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1113 MSLResourceBinding bind;
1114 bind.binding = binding->binding;
1115 bind.desc_set = binding->desc_set;
1116 bind.stage = static_cast<spv::ExecutionModel>(binding->stage);
1117 bind.msl_buffer = binding->msl_buffer;
1118 bind.msl_texture = binding->msl_texture;
1119 bind.msl_sampler = binding->msl_sampler;
1120 msl.add_msl_resource_binding(bind);
1121 return SPVC_SUCCESS;
1122 #else
1123 (void)binding;
1124 compiler->context->report_error("MSL function used on a non-MSL backend.");
1125 return SPVC_ERROR_INVALID_ARGUMENT;
1126 #endif
1127 }
1128
1129 spvc_result spvc_compiler_msl_add_dynamic_buffer(spvc_compiler compiler, unsigned desc_set, unsigned binding, unsigned index)
1130 {
1131 #if SPIRV_CROSS_C_API_MSL
1132 if (compiler->backend != SPVC_BACKEND_MSL)
1133 {
1134 compiler->context->report_error("MSL function used on a non-MSL backend.");
1135 return SPVC_ERROR_INVALID_ARGUMENT;
1136 }
1137
1138 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1139 msl.add_dynamic_buffer(desc_set, binding, index);
1140 return SPVC_SUCCESS;
1141 #else
1142 (void)binding;
1143 (void)desc_set;
1144 (void)index;
1145 compiler->context->report_error("MSL function used on a non-MSL backend.");
1146 return SPVC_ERROR_INVALID_ARGUMENT;
1147 #endif
1148 }
1149
1150 spvc_result spvc_compiler_msl_add_inline_uniform_block(spvc_compiler compiler, unsigned desc_set, unsigned binding)
1151 {
1152 #if SPIRV_CROSS_C_API_MSL
1153 if (compiler->backend != SPVC_BACKEND_MSL)
1154 {
1155 compiler->context->report_error("MSL function used on a non-MSL backend.");
1156 return SPVC_ERROR_INVALID_ARGUMENT;
1157 }
1158
1159 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1160 msl.add_inline_uniform_block(desc_set, binding);
1161 return SPVC_SUCCESS;
1162 #else
1163 (void)binding;
1164 (void)desc_set;
1165 compiler->context->report_error("MSL function used on a non-MSL backend.");
1166 return SPVC_ERROR_INVALID_ARGUMENT;
1167 #endif
1168 }
1169
1170 spvc_result spvc_compiler_msl_add_discrete_descriptor_set(spvc_compiler compiler, unsigned desc_set)
1171 {
1172 #if SPIRV_CROSS_C_API_MSL
1173 if (compiler->backend != SPVC_BACKEND_MSL)
1174 {
1175 compiler->context->report_error("MSL function used on a non-MSL backend.");
1176 return SPVC_ERROR_INVALID_ARGUMENT;
1177 }
1178
1179 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1180 msl.add_discrete_descriptor_set(desc_set);
1181 return SPVC_SUCCESS;
1182 #else
1183 (void)desc_set;
1184 compiler->context->report_error("MSL function used on a non-MSL backend.");
1185 return SPVC_ERROR_INVALID_ARGUMENT;
1186 #endif
1187 }
1188
1189 spvc_result spvc_compiler_msl_set_argument_buffer_device_address_space(spvc_compiler compiler, unsigned desc_set, spvc_bool device_address)
1190 {
1191 #if SPIRV_CROSS_C_API_MSL
1192 if (compiler->backend != SPVC_BACKEND_MSL)
1193 {
1194 compiler->context->report_error("MSL function used on a non-MSL backend.");
1195 return SPVC_ERROR_INVALID_ARGUMENT;
1196 }
1197
1198 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1199 msl.set_argument_buffer_device_address_space(desc_set, bool(device_address));
1200 return SPVC_SUCCESS;
1201 #else
1202 (void)desc_set;
1203 (void)device_address;
1204 compiler->context->report_error("MSL function used on a non-MSL backend.");
1205 return SPVC_ERROR_INVALID_ARGUMENT;
1206 #endif
1207 }
1208
1209 spvc_bool spvc_compiler_msl_is_shader_input_used(spvc_compiler compiler, unsigned location)
1210 {
1211 #if SPIRV_CROSS_C_API_MSL
1212 if (compiler->backend != SPVC_BACKEND_MSL)
1213 {
1214 compiler->context->report_error("MSL function used on a non-MSL backend.");
1215 return SPVC_FALSE;
1216 }
1217
1218 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1219 return msl.is_msl_shader_input_used(location) ? SPVC_TRUE : SPVC_FALSE;
1220 #else
1221 (void)location;
1222 compiler->context->report_error("MSL function used on a non-MSL backend.");
1223 return SPVC_FALSE;
1224 #endif
1225 }
1226
1227 spvc_bool spvc_compiler_msl_is_vertex_attribute_used(spvc_compiler compiler, unsigned location)
1228 {
1229 return spvc_compiler_msl_is_shader_input_used(compiler, location);
1230 }
1231
1232 spvc_bool spvc_compiler_msl_is_resource_used(spvc_compiler compiler, SpvExecutionModel model, unsigned set,
1233 unsigned binding)
1234 {
1235 #if SPIRV_CROSS_C_API_MSL
1236 if (compiler->backend != SPVC_BACKEND_MSL)
1237 {
1238 compiler->context->report_error("MSL function used on a non-MSL backend.");
1239 return SPVC_FALSE;
1240 }
1241
1242 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1243 return msl.is_msl_resource_binding_used(static_cast<spv::ExecutionModel>(model), set, binding) ? SPVC_TRUE :
1244 SPVC_FALSE;
1245 #else
1246 (void)model;
1247 (void)set;
1248 (void)binding;
1249 compiler->context->report_error("MSL function used on a non-MSL backend.");
1250 return SPVC_FALSE;
1251 #endif
1252 }
1253
1254 spvc_result spvc_compiler_msl_set_combined_sampler_suffix(spvc_compiler compiler, const char *suffix)
1255 {
1256 #if SPIRV_CROSS_C_API_MSL
1257 if (compiler->backend != SPVC_BACKEND_MSL)
1258 {
1259 compiler->context->report_error("MSL function used on a non-MSL backend.");
1260 return SPVC_ERROR_INVALID_ARGUMENT;
1261 }
1262
1263 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1264 msl.set_combined_sampler_suffix(suffix);
1265 return SPVC_SUCCESS;
1266 #else
1267 (void)suffix;
1268 compiler->context->report_error("MSL function used on a non-MSL backend.");
1269 return SPVC_ERROR_INVALID_ARGUMENT;
1270 #endif
1271 }
1272
1273 const char *spvc_compiler_msl_get_combined_sampler_suffix(spvc_compiler compiler)
1274 {
1275 #if SPIRV_CROSS_C_API_MSL
1276 if (compiler->backend != SPVC_BACKEND_MSL)
1277 {
1278 compiler->context->report_error("MSL function used on a non-MSL backend.");
1279 return "";
1280 }
1281
1282 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1283 return msl.get_combined_sampler_suffix();
1284 #else
1285 compiler->context->report_error("MSL function used on a non-MSL backend.");
1286 return "";
1287 #endif
1288 }
1289
1290 #if SPIRV_CROSS_C_API_MSL
1291 static void spvc_convert_msl_sampler(MSLConstexprSampler &samp, const spvc_msl_constexpr_sampler *sampler)
1292 {
1293 samp.s_address = static_cast<MSLSamplerAddress>(sampler->s_address);
1294 samp.t_address = static_cast<MSLSamplerAddress>(sampler->t_address);
1295 samp.r_address = static_cast<MSLSamplerAddress>(sampler->r_address);
1296 samp.lod_clamp_min = sampler->lod_clamp_min;
1297 samp.lod_clamp_max = sampler->lod_clamp_max;
1298 samp.lod_clamp_enable = sampler->lod_clamp_enable != 0;
1299 samp.min_filter = static_cast<MSLSamplerFilter>(sampler->min_filter);
1300 samp.mag_filter = static_cast<MSLSamplerFilter>(sampler->mag_filter);
1301 samp.mip_filter = static_cast<MSLSamplerMipFilter>(sampler->mip_filter);
1302 samp.compare_enable = sampler->compare_enable != 0;
1303 samp.anisotropy_enable = sampler->anisotropy_enable != 0;
1304 samp.max_anisotropy = sampler->max_anisotropy;
1305 samp.compare_func = static_cast<MSLSamplerCompareFunc>(sampler->compare_func);
1306 samp.coord = static_cast<MSLSamplerCoord>(sampler->coord);
1307 samp.border_color = static_cast<MSLSamplerBorderColor>(sampler->border_color);
1308 }
1309
1310 static void spvc_convert_msl_sampler_ycbcr_conversion(MSLConstexprSampler &samp, const spvc_msl_sampler_ycbcr_conversion *conv)
1311 {
1312 samp.ycbcr_conversion_enable = conv != nullptr;
1313 if (conv == nullptr) return;
1314 samp.planes = conv->planes;
1315 samp.resolution = static_cast<MSLFormatResolution>(conv->resolution);
1316 samp.chroma_filter = static_cast<MSLSamplerFilter>(conv->chroma_filter);
1317 samp.x_chroma_offset = static_cast<MSLChromaLocation>(conv->x_chroma_offset);
1318 samp.y_chroma_offset = static_cast<MSLChromaLocation>(conv->y_chroma_offset);
1319 for (int i = 0; i < 4; i++)
1320 samp.swizzle[i] = static_cast<MSLComponentSwizzle>(conv->swizzle[i]);
1321 samp.ycbcr_model = static_cast<MSLSamplerYCbCrModelConversion>(conv->ycbcr_model);
1322 samp.ycbcr_range = static_cast<MSLSamplerYCbCrRange>(conv->ycbcr_range);
1323 samp.bpc = conv->bpc;
1324 }
1325 #endif
1326
1327 spvc_result spvc_compiler_msl_remap_constexpr_sampler(spvc_compiler compiler, spvc_variable_id id,
1328 const spvc_msl_constexpr_sampler *sampler)
1329 {
1330 #if SPIRV_CROSS_C_API_MSL
1331 if (compiler->backend != SPVC_BACKEND_MSL)
1332 {
1333 compiler->context->report_error("MSL function used on a non-MSL backend.");
1334 return SPVC_ERROR_INVALID_ARGUMENT;
1335 }
1336
1337 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1338 MSLConstexprSampler samp;
1339 spvc_convert_msl_sampler(samp, sampler);
1340 msl.remap_constexpr_sampler(id, samp);
1341 return SPVC_SUCCESS;
1342 #else
1343 (void)id;
1344 (void)sampler;
1345 compiler->context->report_error("MSL function used on a non-MSL backend.");
1346 return SPVC_ERROR_INVALID_ARGUMENT;
1347 #endif
1348 }
1349
1350 spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding(spvc_compiler compiler,
1351 unsigned desc_set, unsigned binding,
1352 const spvc_msl_constexpr_sampler *sampler)
1353 {
1354 #if SPIRV_CROSS_C_API_MSL
1355 if (compiler->backend != SPVC_BACKEND_MSL)
1356 {
1357 compiler->context->report_error("MSL function used on a non-MSL backend.");
1358 return SPVC_ERROR_INVALID_ARGUMENT;
1359 }
1360
1361 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1362 MSLConstexprSampler samp;
1363 spvc_convert_msl_sampler(samp, sampler);
1364 msl.remap_constexpr_sampler_by_binding(desc_set, binding, samp);
1365 return SPVC_SUCCESS;
1366 #else
1367 (void)desc_set;
1368 (void)binding;
1369 (void)sampler;
1370 compiler->context->report_error("MSL function used on a non-MSL backend.");
1371 return SPVC_ERROR_INVALID_ARGUMENT;
1372 #endif
1373 }
1374
1375 spvc_result spvc_compiler_msl_remap_constexpr_sampler_ycbcr(spvc_compiler compiler, spvc_variable_id id,
1376 const spvc_msl_constexpr_sampler *sampler,
1377 const spvc_msl_sampler_ycbcr_conversion *conv)
1378 {
1379 #if SPIRV_CROSS_C_API_MSL
1380 if (compiler->backend != SPVC_BACKEND_MSL)
1381 {
1382 compiler->context->report_error("MSL function used on a non-MSL backend.");
1383 return SPVC_ERROR_INVALID_ARGUMENT;
1384 }
1385
1386 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1387 MSLConstexprSampler samp;
1388 spvc_convert_msl_sampler(samp, sampler);
1389 spvc_convert_msl_sampler_ycbcr_conversion(samp, conv);
1390 msl.remap_constexpr_sampler(id, samp);
1391 return SPVC_SUCCESS;
1392 #else
1393 (void)id;
1394 (void)sampler;
1395 (void)conv;
1396 compiler->context->report_error("MSL function used on a non-MSL backend.");
1397 return SPVC_ERROR_INVALID_ARGUMENT;
1398 #endif
1399 }
1400
1401 spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr(spvc_compiler compiler,
1402 unsigned desc_set, unsigned binding,
1403 const spvc_msl_constexpr_sampler *sampler,
1404 const spvc_msl_sampler_ycbcr_conversion *conv)
1405 {
1406 #if SPIRV_CROSS_C_API_MSL
1407 if (compiler->backend != SPVC_BACKEND_MSL)
1408 {
1409 compiler->context->report_error("MSL function used on a non-MSL backend.");
1410 return SPVC_ERROR_INVALID_ARGUMENT;
1411 }
1412
1413 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1414 MSLConstexprSampler samp;
1415 spvc_convert_msl_sampler(samp, sampler);
1416 spvc_convert_msl_sampler_ycbcr_conversion(samp, conv);
1417 msl.remap_constexpr_sampler_by_binding(desc_set, binding, samp);
1418 return SPVC_SUCCESS;
1419 #else
1420 (void)desc_set;
1421 (void)binding;
1422 (void)sampler;
1423 (void)conv;
1424 compiler->context->report_error("MSL function used on a non-MSL backend.");
1425 return SPVC_ERROR_INVALID_ARGUMENT;
1426 #endif
1427 }
1428
1429 spvc_result spvc_compiler_msl_set_fragment_output_components(spvc_compiler compiler, unsigned location,
1430 unsigned components)
1431 {
1432 #if SPIRV_CROSS_C_API_MSL
1433 if (compiler->backend != SPVC_BACKEND_MSL)
1434 {
1435 compiler->context->report_error("MSL function used on a non-MSL backend.");
1436 return SPVC_ERROR_INVALID_ARGUMENT;
1437 }
1438
1439 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1440 msl.set_fragment_output_components(location, components);
1441 return SPVC_SUCCESS;
1442 #else
1443 (void)location;
1444 (void)components;
1445 compiler->context->report_error("MSL function used on a non-MSL backend.");
1446 return SPVC_ERROR_INVALID_ARGUMENT;
1447 #endif
1448 }
1449
1450 unsigned spvc_compiler_msl_get_automatic_resource_binding(spvc_compiler compiler, spvc_variable_id id)
1451 {
1452 #if SPIRV_CROSS_C_API_MSL
1453 if (compiler->backend != SPVC_BACKEND_MSL)
1454 {
1455 compiler->context->report_error("MSL function used on a non-MSL backend.");
1456 return uint32_t(-1);
1457 }
1458
1459 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1460 return msl.get_automatic_msl_resource_binding(id);
1461 #else
1462 (void)id;
1463 compiler->context->report_error("MSL function used on a non-MSL backend.");
1464 return uint32_t(-1);
1465 #endif
1466 }
1467
1468 unsigned spvc_compiler_msl_get_automatic_resource_binding_secondary(spvc_compiler compiler, spvc_variable_id id)
1469 {
1470 #if SPIRV_CROSS_C_API_MSL
1471 if (compiler->backend != SPVC_BACKEND_MSL)
1472 {
1473 compiler->context->report_error("MSL function used on a non-MSL backend.");
1474 return uint32_t(-1);
1475 }
1476
1477 auto &msl = *static_cast<CompilerMSL *>(compiler->compiler.get());
1478 return msl.get_automatic_msl_resource_binding_secondary(id);
1479 #else
1480 (void)id;
1481 compiler->context->report_error("MSL function used on a non-MSL backend.");
1482 return uint32_t(-1);
1483 #endif
1484 }
1485
1486 spvc_result spvc_compiler_compile(spvc_compiler compiler, const char **source)
1487 {
1488 SPVC_BEGIN_SAFE_SCOPE
1489 {
1490 auto result = compiler->compiler->compile();
1491 if (result.empty())
1492 {
1493 compiler->context->report_error("Unsupported SPIR-V.");
1494 return SPVC_ERROR_UNSUPPORTED_SPIRV;
1495 }
1496
1497 *source = compiler->context->allocate_name(result);
1498 if (!*source)
1499 {
1500 compiler->context->report_error("Out of memory.");
1501 return SPVC_ERROR_OUT_OF_MEMORY;
1502 }
1503 return SPVC_SUCCESS;
1504 }
1505 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_UNSUPPORTED_SPIRV)
1506 }
1507
1508 bool spvc_resources_s::copy_resources(SmallVector<spvc_reflected_resource> &outputs,
1509 const SmallVector<Resource> &inputs)
1510 {
1511 for (auto &i : inputs)
1512 {
1513 spvc_reflected_resource r;
1514 r.base_type_id = i.base_type_id;
1515 r.type_id = i.type_id;
1516 r.id = i.id;
1517 r.name = context->allocate_name(i.name);
1518 if (!r.name)
1519 return false;
1520
1521 outputs.push_back(r);
1522 }
1523
1524 return true;
1525 }
1526
1527 bool spvc_resources_s::copy_resources(const ShaderResources &resources)
1528 {
1529 if (!copy_resources(uniform_buffers, resources.uniform_buffers))
1530 return false;
1531 if (!copy_resources(storage_buffers, resources.storage_buffers))
1532 return false;
1533 if (!copy_resources(stage_inputs, resources.stage_inputs))
1534 return false;
1535 if (!copy_resources(stage_outputs, resources.stage_outputs))
1536 return false;
1537 if (!copy_resources(subpass_inputs, resources.subpass_inputs))
1538 return false;
1539 if (!copy_resources(storage_images, resources.storage_images))
1540 return false;
1541 if (!copy_resources(sampled_images, resources.sampled_images))
1542 return false;
1543 if (!copy_resources(atomic_counters, resources.atomic_counters))
1544 return false;
1545 if (!copy_resources(push_constant_buffers, resources.push_constant_buffers))
1546 return false;
1547 if (!copy_resources(separate_images, resources.separate_images))
1548 return false;
1549 if (!copy_resources(separate_samplers, resources.separate_samplers))
1550 return false;
1551 if (!copy_resources(acceleration_structures, resources.acceleration_structures))
1552 return false;
1553
1554 return true;
1555 }
1556
1557 spvc_result spvc_compiler_get_active_interface_variables(spvc_compiler compiler, spvc_set *set)
1558 {
1559 SPVC_BEGIN_SAFE_SCOPE
1560 {
1561 std::unique_ptr<spvc_set_s> ptr(new (std::nothrow) spvc_set_s);
1562 if (!ptr)
1563 {
1564 compiler->context->report_error("Out of memory.");
1565 return SPVC_ERROR_OUT_OF_MEMORY;
1566 }
1567
1568 auto active = compiler->compiler->get_active_interface_variables();
1569 ptr->set = std::move(active);
1570 *set = ptr.get();
1571 compiler->context->allocations.push_back(std::move(ptr));
1572 }
1573 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
1574 return SPVC_SUCCESS;
1575 }
1576
1577 spvc_result spvc_compiler_set_enabled_interface_variables(spvc_compiler compiler, spvc_set set)
1578 {
1579 SPVC_BEGIN_SAFE_SCOPE
1580 {
1581 compiler->compiler->set_enabled_interface_variables(set->set);
1582 }
1583 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
1584 return SPVC_SUCCESS;
1585 }
1586
1587 spvc_result spvc_compiler_create_shader_resources_for_active_variables(spvc_compiler compiler, spvc_resources *resources,
1588 spvc_set set)
1589 {
1590 SPVC_BEGIN_SAFE_SCOPE
1591 {
1592 std::unique_ptr<spvc_resources_s> res(new (std::nothrow) spvc_resources_s);
1593 if (!res)
1594 {
1595 compiler->context->report_error("Out of memory.");
1596 return SPVC_ERROR_OUT_OF_MEMORY;
1597 }
1598
1599 res->context = compiler->context;
1600 auto accessed_resources = compiler->compiler->get_shader_resources(set->set);
1601
1602 if (!res->copy_resources(accessed_resources))
1603 {
1604 res->context->report_error("Out of memory.");
1605 return SPVC_ERROR_OUT_OF_MEMORY;
1606 }
1607 *resources = res.get();
1608 compiler->context->allocations.push_back(std::move(res));
1609 }
1610 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
1611 return SPVC_SUCCESS;
1612 }
1613
1614 spvc_result spvc_compiler_create_shader_resources(spvc_compiler compiler, spvc_resources *resources)
1615 {
1616 SPVC_BEGIN_SAFE_SCOPE
1617 {
1618 std::unique_ptr<spvc_resources_s> res(new (std::nothrow) spvc_resources_s);
1619 if (!res)
1620 {
1621 compiler->context->report_error("Out of memory.");
1622 return SPVC_ERROR_OUT_OF_MEMORY;
1623 }
1624
1625 res->context = compiler->context;
1626 auto accessed_resources = compiler->compiler->get_shader_resources();
1627
1628 if (!res->copy_resources(accessed_resources))
1629 {
1630 res->context->report_error("Out of memory.");
1631 return SPVC_ERROR_OUT_OF_MEMORY;
1632 }
1633
1634 *resources = res.get();
1635 compiler->context->allocations.push_back(std::move(res));
1636 }
1637 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
1638 return SPVC_SUCCESS;
1639 }
1640
1641 spvc_result spvc_resources_get_resource_list_for_type(spvc_resources resources, spvc_resource_type type,
1642 const spvc_reflected_resource **resource_list,
1643 size_t *resource_size)
1644 {
1645 const SmallVector<spvc_reflected_resource> *list = nullptr;
1646 switch (type)
1647 {
1648 case SPVC_RESOURCE_TYPE_UNIFORM_BUFFER:
1649 list = &resources->uniform_buffers;
1650 break;
1651
1652 case SPVC_RESOURCE_TYPE_STORAGE_BUFFER:
1653 list = &resources->storage_buffers;
1654 break;
1655
1656 case SPVC_RESOURCE_TYPE_STAGE_INPUT:
1657 list = &resources->stage_inputs;
1658 break;
1659
1660 case SPVC_RESOURCE_TYPE_STAGE_OUTPUT:
1661 list = &resources->stage_outputs;
1662 break;
1663
1664 case SPVC_RESOURCE_TYPE_SUBPASS_INPUT:
1665 list = &resources->subpass_inputs;
1666 break;
1667
1668 case SPVC_RESOURCE_TYPE_STORAGE_IMAGE:
1669 list = &resources->storage_images;
1670 break;
1671
1672 case SPVC_RESOURCE_TYPE_SAMPLED_IMAGE:
1673 list = &resources->sampled_images;
1674 break;
1675
1676 case SPVC_RESOURCE_TYPE_ATOMIC_COUNTER:
1677 list = &resources->atomic_counters;
1678 break;
1679
1680 case SPVC_RESOURCE_TYPE_PUSH_CONSTANT:
1681 list = &resources->push_constant_buffers;
1682 break;
1683
1684 case SPVC_RESOURCE_TYPE_SEPARATE_IMAGE:
1685 list = &resources->separate_images;
1686 break;
1687
1688 case SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS:
1689 list = &resources->separate_samplers;
1690 break;
1691
1692 case SPVC_RESOURCE_TYPE_ACCELERATION_STRUCTURE:
1693 list = &resources->acceleration_structures;
1694 break;
1695
1696 default:
1697 break;
1698 }
1699
1700 if (!list)
1701 {
1702 resources->context->report_error("Invalid argument.");
1703 return SPVC_ERROR_INVALID_ARGUMENT;
1704 }
1705
1706 *resource_size = list->size();
1707 *resource_list = list->data();
1708 return SPVC_SUCCESS;
1709 }
1710
1711 void spvc_compiler_set_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration, unsigned argument)
1712 {
1713 compiler->compiler->set_decoration(id, static_cast<spv::Decoration>(decoration), argument);
1714 }
1715
1716 void spvc_compiler_set_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration,
1717 const char *argument)
1718 {
1719 compiler->compiler->set_decoration_string(id, static_cast<spv::Decoration>(decoration), argument);
1720 }
1721
1722 void spvc_compiler_set_name(spvc_compiler compiler, SpvId id, const char *argument)
1723 {
1724 compiler->compiler->set_name(id, argument);
1725 }
1726
1727 void spvc_compiler_set_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
1728 SpvDecoration decoration, unsigned argument)
1729 {
1730 compiler->compiler->set_member_decoration(id, member_index, static_cast<spv::Decoration>(decoration), argument);
1731 }
1732
1733 void spvc_compiler_set_member_decoration_string(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
1734 SpvDecoration decoration, const char *argument)
1735 {
1736 compiler->compiler->set_member_decoration_string(id, member_index, static_cast<spv::Decoration>(decoration),
1737 argument);
1738 }
1739
1740 void spvc_compiler_set_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index, const char *argument)
1741 {
1742 compiler->compiler->set_member_name(id, member_index, argument);
1743 }
1744
1745 void spvc_compiler_unset_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration)
1746 {
1747 compiler->compiler->unset_decoration(id, static_cast<spv::Decoration>(decoration));
1748 }
1749
1750 void spvc_compiler_unset_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
1751 SpvDecoration decoration)
1752 {
1753 compiler->compiler->unset_member_decoration(id, member_index, static_cast<spv::Decoration>(decoration));
1754 }
1755
1756 spvc_bool spvc_compiler_has_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration)
1757 {
1758 return compiler->compiler->has_decoration(id, static_cast<spv::Decoration>(decoration)) ? SPVC_TRUE : SPVC_FALSE;
1759 }
1760
1761 spvc_bool spvc_compiler_has_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
1762 SpvDecoration decoration)
1763 {
1764 return compiler->compiler->has_member_decoration(id, member_index, static_cast<spv::Decoration>(decoration)) ?
1765 SPVC_TRUE :
1766 SPVC_FALSE;
1767 }
1768
1769 const char *spvc_compiler_get_name(spvc_compiler compiler, SpvId id)
1770 {
1771 return compiler->compiler->get_name(id).c_str();
1772 }
1773
1774 unsigned spvc_compiler_get_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration)
1775 {
1776 return compiler->compiler->get_decoration(id, static_cast<spv::Decoration>(decoration));
1777 }
1778
1779 const char *spvc_compiler_get_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration)
1780 {
1781 return compiler->compiler->get_decoration_string(id, static_cast<spv::Decoration>(decoration)).c_str();
1782 }
1783
1784 unsigned spvc_compiler_get_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
1785 SpvDecoration decoration)
1786 {
1787 return compiler->compiler->get_member_decoration(id, member_index, static_cast<spv::Decoration>(decoration));
1788 }
1789
1790 const char *spvc_compiler_get_member_decoration_string(spvc_compiler compiler, spvc_type_id id, unsigned member_index,
1791 SpvDecoration decoration)
1792 {
1793 return compiler->compiler->get_member_decoration_string(id, member_index, static_cast<spv::Decoration>(decoration))
1794 .c_str();
1795 }
1796
1797 const char *spvc_compiler_get_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index)
1798 {
1799 return compiler->compiler->get_member_name(id, member_index).c_str();
1800 }
1801
1802 spvc_result spvc_compiler_get_entry_points(spvc_compiler compiler, const spvc_entry_point **entry_points,
1803 size_t *num_entry_points)
1804 {
1805 SPVC_BEGIN_SAFE_SCOPE
1806 {
1807 auto entries = compiler->compiler->get_entry_points_and_stages();
1808 SmallVector<spvc_entry_point> translated;
1809 translated.reserve(entries.size());
1810
1811 for (auto &entry : entries)
1812 {
1813 spvc_entry_point new_entry;
1814 new_entry.execution_model = static_cast<SpvExecutionModel>(entry.execution_model);
1815 new_entry.name = compiler->context->allocate_name(entry.name);
1816 if (!new_entry.name)
1817 {
1818 compiler->context->report_error("Out of memory.");
1819 return SPVC_ERROR_OUT_OF_MEMORY;
1820 }
1821 translated.push_back(new_entry);
1822 }
1823
1824 auto ptr = spvc_allocate<TemporaryBuffer<spvc_entry_point>>();
1825 ptr->buffer = std::move(translated);
1826 *entry_points = ptr->buffer.data();
1827 *num_entry_points = ptr->buffer.size();
1828 compiler->context->allocations.push_back(std::move(ptr));
1829 }
1830 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
1831 return SPVC_SUCCESS;
1832 }
1833
1834 spvc_result spvc_compiler_set_entry_point(spvc_compiler compiler, const char *name, SpvExecutionModel model)
1835 {
1836 compiler->compiler->set_entry_point(name, static_cast<spv::ExecutionModel>(model));
1837 return SPVC_SUCCESS;
1838 }
1839
1840 spvc_result spvc_compiler_rename_entry_point(spvc_compiler compiler, const char *old_name, const char *new_name,
1841 SpvExecutionModel model)
1842 {
1843 SPVC_BEGIN_SAFE_SCOPE
1844 {
1845 compiler->compiler->rename_entry_point(old_name, new_name, static_cast<spv::ExecutionModel>(model));
1846 }
1847 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
1848 return SPVC_SUCCESS;
1849 }
1850
1851 const char *spvc_compiler_get_cleansed_entry_point_name(spvc_compiler compiler, const char *name,
1852 SpvExecutionModel model)
1853 {
1854 SPVC_BEGIN_SAFE_SCOPE
1855 {
1856 auto cleansed_name =
1857 compiler->compiler->get_cleansed_entry_point_name(name, static_cast<spv::ExecutionModel>(model));
1858 return compiler->context->allocate_name(cleansed_name);
1859 }
1860 SPVC_END_SAFE_SCOPE(compiler->context, nullptr)
1861 }
1862
1863 void spvc_compiler_set_execution_mode(spvc_compiler compiler, SpvExecutionMode mode)
1864 {
1865 compiler->compiler->set_execution_mode(static_cast<spv::ExecutionMode>(mode));
1866 }
1867
1868 void spvc_compiler_set_execution_mode_with_arguments(spvc_compiler compiler, SpvExecutionMode mode, unsigned arg0,
1869 unsigned arg1,
1870 unsigned arg2)
1871 {
1872 compiler->compiler->set_execution_mode(static_cast<spv::ExecutionMode>(mode), arg0, arg1, arg2);
1873 }
1874
1875 void spvc_compiler_unset_execution_mode(spvc_compiler compiler, SpvExecutionMode mode)
1876 {
1877 compiler->compiler->unset_execution_mode(static_cast<spv::ExecutionMode>(mode));
1878 }
1879
1880 spvc_result spvc_compiler_get_execution_modes(spvc_compiler compiler, const SpvExecutionMode **modes, size_t *num_modes)
1881 {
1882 SPVC_BEGIN_SAFE_SCOPE
1883 {
1884 auto ptr = spvc_allocate<TemporaryBuffer<SpvExecutionMode>>();
1885
1886 compiler->compiler->get_execution_mode_bitset().for_each_bit(
1887 [&](uint32_t bit) { ptr->buffer.push_back(static_cast<SpvExecutionMode>(bit)); });
1888
1889 *modes = ptr->buffer.data();
1890 *num_modes = ptr->buffer.size();
1891 compiler->context->allocations.push_back(std::move(ptr));
1892 }
1893 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
1894 return SPVC_SUCCESS;
1895 }
1896
1897 unsigned spvc_compiler_get_execution_mode_argument(spvc_compiler compiler, SpvExecutionMode mode)
1898 {
1899 return compiler->compiler->get_execution_mode_argument(static_cast<spv::ExecutionMode>(mode));
1900 }
1901
1902 unsigned spvc_compiler_get_execution_mode_argument_by_index(spvc_compiler compiler, SpvExecutionMode mode,
1903 unsigned index)
1904 {
1905 return compiler->compiler->get_execution_mode_argument(static_cast<spv::ExecutionMode>(mode), index);
1906 }
1907
1908 SpvExecutionModel spvc_compiler_get_execution_model(spvc_compiler compiler)
1909 {
1910 return static_cast<SpvExecutionModel>(compiler->compiler->get_execution_model());
1911 }
1912
1913 spvc_type spvc_compiler_get_type_handle(spvc_compiler compiler, spvc_type_id id)
1914 {
1915 // Should only throw if an intentionally garbage ID is passed, but the IDs are not type-safe.
1916 SPVC_BEGIN_SAFE_SCOPE
1917 {
1918 return static_cast<spvc_type>(&compiler->compiler->get_type(id));
1919 }
1920 SPVC_END_SAFE_SCOPE(compiler->context, nullptr)
1921 }
1922
1923 spvc_type_id spvc_type_get_base_type_id(spvc_type type)
1924 {
1925 return type->self;
1926 }
1927
1928 static spvc_basetype convert_basetype(SPIRType::BaseType type)
1929 {
1930 // For now the enums match up.
1931 return static_cast<spvc_basetype>(type);
1932 }
1933
1934 spvc_basetype spvc_type_get_basetype(spvc_type type)
1935 {
1936 return convert_basetype(type->basetype);
1937 }
1938
1939 unsigned spvc_type_get_bit_width(spvc_type type)
1940 {
1941 return type->width;
1942 }
1943
1944 unsigned spvc_type_get_vector_size(spvc_type type)
1945 {
1946 return type->vecsize;
1947 }
1948
1949 unsigned spvc_type_get_columns(spvc_type type)
1950 {
1951 return type->columns;
1952 }
1953
1954 unsigned spvc_type_get_num_array_dimensions(spvc_type type)
1955 {
1956 return unsigned(type->array.size());
1957 }
1958
1959 spvc_bool spvc_type_array_dimension_is_literal(spvc_type type, unsigned dimension)
1960 {
1961 return type->array_size_literal[dimension] ? SPVC_TRUE : SPVC_FALSE;
1962 }
1963
1964 SpvId spvc_type_get_array_dimension(spvc_type type, unsigned dimension)
1965 {
1966 return type->array[dimension];
1967 }
1968
1969 unsigned spvc_type_get_num_member_types(spvc_type type)
1970 {
1971 return unsigned(type->member_types.size());
1972 }
1973
1974 spvc_type_id spvc_type_get_member_type(spvc_type type, unsigned index)
1975 {
1976 return type->member_types[index];
1977 }
1978
1979 SpvStorageClass spvc_type_get_storage_class(spvc_type type)
1980 {
1981 return static_cast<SpvStorageClass>(type->storage);
1982 }
1983
1984 // Image type query.
1985 spvc_type_id spvc_type_get_image_sampled_type(spvc_type type)
1986 {
1987 return type->image.type;
1988 }
1989
1990 SpvDim spvc_type_get_image_dimension(spvc_type type)
1991 {
1992 return static_cast<SpvDim>(type->image.dim);
1993 }
1994
1995 spvc_bool spvc_type_get_image_is_depth(spvc_type type)
1996 {
1997 return type->image.depth ? SPVC_TRUE : SPVC_FALSE;
1998 }
1999
2000 spvc_bool spvc_type_get_image_arrayed(spvc_type type)
2001 {
2002 return type->image.arrayed ? SPVC_TRUE : SPVC_FALSE;
2003 }
2004
2005 spvc_bool spvc_type_get_image_multisampled(spvc_type type)
2006 {
2007 return type->image.ms ? SPVC_TRUE : SPVC_FALSE;
2008 }
2009
2010 spvc_bool spvc_type_get_image_is_storage(spvc_type type)
2011 {
2012 return type->image.sampled == 2 ? SPVC_TRUE : SPVC_FALSE;
2013 }
2014
2015 SpvImageFormat spvc_type_get_image_storage_format(spvc_type type)
2016 {
2017 return static_cast<SpvImageFormat>(static_cast<const SPIRType *>(type)->image.format);
2018 }
2019
2020 SpvAccessQualifier spvc_type_get_image_access_qualifier(spvc_type type)
2021 {
2022 return static_cast<SpvAccessQualifier>(static_cast<const SPIRType *>(type)->image.access);
2023 }
2024
2025 spvc_result spvc_compiler_get_declared_struct_size(spvc_compiler compiler, spvc_type struct_type, size_t *size)
2026 {
2027 SPVC_BEGIN_SAFE_SCOPE
2028 {
2029 *size = compiler->compiler->get_declared_struct_size(*static_cast<const SPIRType *>(struct_type));
2030 }
2031 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2032 return SPVC_SUCCESS;
2033 }
2034
2035 spvc_result spvc_compiler_get_declared_struct_size_runtime_array(spvc_compiler compiler, spvc_type struct_type,
2036 size_t array_size, size_t *size)
2037 {
2038 SPVC_BEGIN_SAFE_SCOPE
2039 {
2040 *size = compiler->compiler->get_declared_struct_size_runtime_array(*static_cast<const SPIRType *>(struct_type),
2041 array_size);
2042 }
2043 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2044 return SPVC_SUCCESS;
2045 }
2046
2047 spvc_result spvc_compiler_get_declared_struct_member_size(spvc_compiler compiler, spvc_type struct_type, unsigned index, size_t *size)
2048 {
2049 SPVC_BEGIN_SAFE_SCOPE
2050 {
2051 *size = compiler->compiler->get_declared_struct_member_size(*static_cast<const SPIRType *>(struct_type), index);
2052 }
2053 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2054 return SPVC_SUCCESS;
2055 }
2056
2057 spvc_result spvc_compiler_type_struct_member_offset(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *offset)
2058 {
2059 SPVC_BEGIN_SAFE_SCOPE
2060 {
2061 *offset = compiler->compiler->type_struct_member_offset(*static_cast<const SPIRType *>(type), index);
2062 }
2063 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2064 return SPVC_SUCCESS;
2065 }
2066
2067 spvc_result spvc_compiler_type_struct_member_array_stride(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *stride)
2068 {
2069 SPVC_BEGIN_SAFE_SCOPE
2070 {
2071 *stride = compiler->compiler->type_struct_member_array_stride(*static_cast<const SPIRType *>(type), index);
2072 }
2073 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2074 return SPVC_SUCCESS;
2075 }
2076
2077 spvc_result spvc_compiler_type_struct_member_matrix_stride(spvc_compiler compiler, spvc_type type, unsigned index, unsigned *stride)
2078 {
2079 SPVC_BEGIN_SAFE_SCOPE
2080 {
2081 *stride = compiler->compiler->type_struct_member_matrix_stride(*static_cast<const SPIRType *>(type), index);
2082 }
2083 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2084 return SPVC_SUCCESS;
2085 }
2086
2087 spvc_result spvc_compiler_build_dummy_sampler_for_combined_images(spvc_compiler compiler, spvc_variable_id *id)
2088 {
2089 SPVC_BEGIN_SAFE_SCOPE
2090 {
2091 *id = compiler->compiler->build_dummy_sampler_for_combined_images();
2092 }
2093 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2094 return SPVC_SUCCESS;
2095 }
2096
2097 spvc_result spvc_compiler_build_combined_image_samplers(spvc_compiler compiler)
2098 {
2099 SPVC_BEGIN_SAFE_SCOPE
2100 {
2101 compiler->compiler->build_combined_image_samplers();
2102 }
2103 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_UNSUPPORTED_SPIRV)
2104 return SPVC_SUCCESS;
2105 }
2106
2107 spvc_result spvc_compiler_get_combined_image_samplers(spvc_compiler compiler,
2108 const spvc_combined_image_sampler **samplers,
2109 size_t *num_samplers)
2110 {
2111 SPVC_BEGIN_SAFE_SCOPE
2112 {
2113 auto combined = compiler->compiler->get_combined_image_samplers();
2114 SmallVector<spvc_combined_image_sampler> translated;
2115 translated.reserve(combined.size());
2116 for (auto &c : combined)
2117 {
2118 spvc_combined_image_sampler trans = { c.combined_id, c.image_id, c.sampler_id };
2119 translated.push_back(trans);
2120 }
2121
2122 auto ptr = spvc_allocate<TemporaryBuffer<spvc_combined_image_sampler>>();
2123 ptr->buffer = std::move(translated);
2124 *samplers = ptr->buffer.data();
2125 *num_samplers = ptr->buffer.size();
2126 compiler->context->allocations.push_back(std::move(ptr));
2127 }
2128 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
2129 return SPVC_SUCCESS;
2130 }
2131
2132 spvc_result spvc_compiler_get_specialization_constants(spvc_compiler compiler,
2133 const spvc_specialization_constant **constants,
2134 size_t *num_constants)
2135 {
2136 SPVC_BEGIN_SAFE_SCOPE
2137 {
2138 auto spec_constants = compiler->compiler->get_specialization_constants();
2139 SmallVector<spvc_specialization_constant> translated;
2140 translated.reserve(spec_constants.size());
2141 for (auto &c : spec_constants)
2142 {
2143 spvc_specialization_constant trans = { c.id, c.constant_id };
2144 translated.push_back(trans);
2145 }
2146
2147 auto ptr = spvc_allocate<TemporaryBuffer<spvc_specialization_constant>>();
2148 ptr->buffer = std::move(translated);
2149 *constants = ptr->buffer.data();
2150 *num_constants = ptr->buffer.size();
2151 compiler->context->allocations.push_back(std::move(ptr));
2152 }
2153 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
2154 return SPVC_SUCCESS;
2155 }
2156
2157 spvc_constant spvc_compiler_get_constant_handle(spvc_compiler compiler, spvc_variable_id id)
2158 {
2159 SPVC_BEGIN_SAFE_SCOPE
2160 {
2161 return static_cast<spvc_constant>(&compiler->compiler->get_constant(id));
2162 }
2163 SPVC_END_SAFE_SCOPE(compiler->context, nullptr)
2164 }
2165
2166 spvc_constant_id spvc_compiler_get_work_group_size_specialization_constants(spvc_compiler compiler,
2167 spvc_specialization_constant *x,
2168 spvc_specialization_constant *y,
2169 spvc_specialization_constant *z)
2170 {
2171 SpecializationConstant tmpx;
2172 SpecializationConstant tmpy;
2173 SpecializationConstant tmpz;
2174 spvc_constant_id ret = compiler->compiler->get_work_group_size_specialization_constants(tmpx, tmpy, tmpz);
2175 x->id = tmpx.id;
2176 x->constant_id = tmpx.constant_id;
2177 y->id = tmpy.id;
2178 y->constant_id = tmpy.constant_id;
2179 z->id = tmpz.id;
2180 z->constant_id = tmpz.constant_id;
2181 return ret;
2182 }
2183
2184 spvc_result spvc_compiler_get_active_buffer_ranges(spvc_compiler compiler,
2185 spvc_variable_id id,
2186 const spvc_buffer_range **ranges,
2187 size_t *num_ranges)
2188 {
2189 SPVC_BEGIN_SAFE_SCOPE
2190 {
2191 auto active_ranges = compiler->compiler->get_active_buffer_ranges(id);
2192 SmallVector<spvc_buffer_range> translated;
2193 translated.reserve(active_ranges.size());
2194 for (auto &r : active_ranges)
2195 {
2196 spvc_buffer_range trans = { r.index, r.offset, r.range };
2197 translated.push_back(trans);
2198 }
2199
2200 auto ptr = spvc_allocate<TemporaryBuffer<spvc_buffer_range>>();
2201 ptr->buffer = std::move(translated);
2202 *ranges = ptr->buffer.data();
2203 *num_ranges = ptr->buffer.size();
2204 compiler->context->allocations.push_back(std::move(ptr));
2205 }
2206 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
2207 return SPVC_SUCCESS;
2208 }
2209
2210 float spvc_constant_get_scalar_fp16(spvc_constant constant, unsigned column, unsigned row)
2211 {
2212 return constant->scalar_f16(column, row);
2213 }
2214
2215 float spvc_constant_get_scalar_fp32(spvc_constant constant, unsigned column, unsigned row)
2216 {
2217 return constant->scalar_f32(column, row);
2218 }
2219
2220 double spvc_constant_get_scalar_fp64(spvc_constant constant, unsigned column, unsigned row)
2221 {
2222 return constant->scalar_f64(column, row);
2223 }
2224
2225 unsigned spvc_constant_get_scalar_u32(spvc_constant constant, unsigned column, unsigned row)
2226 {
2227 return constant->scalar(column, row);
2228 }
2229
2230 int spvc_constant_get_scalar_i32(spvc_constant constant, unsigned column, unsigned row)
2231 {
2232 return constant->scalar_i32(column, row);
2233 }
2234
2235 unsigned spvc_constant_get_scalar_u16(spvc_constant constant, unsigned column, unsigned row)
2236 {
2237 return constant->scalar_u16(column, row);
2238 }
2239
2240 int spvc_constant_get_scalar_i16(spvc_constant constant, unsigned column, unsigned row)
2241 {
2242 return constant->scalar_i16(column, row);
2243 }
2244
2245 unsigned spvc_constant_get_scalar_u8(spvc_constant constant, unsigned column, unsigned row)
2246 {
2247 return constant->scalar_u8(column, row);
2248 }
2249
2250 int spvc_constant_get_scalar_i8(spvc_constant constant, unsigned column, unsigned row)
2251 {
2252 return constant->scalar_i8(column, row);
2253 }
2254
2255 void spvc_constant_get_subconstants(spvc_constant constant, const spvc_constant_id **constituents, size_t *count)
2256 {
2257 static_assert(sizeof(spvc_constant_id) == sizeof(constant->subconstants.front()), "ID size is not consistent.");
2258 *constituents = reinterpret_cast<spvc_constant_id *>(constant->subconstants.data());
2259 *count = constant->subconstants.size();
2260 }
2261
2262 spvc_type_id spvc_constant_get_type(spvc_constant constant)
2263 {
2264 return constant->constant_type;
2265 }
2266
2267 spvc_bool spvc_compiler_get_binary_offset_for_decoration(spvc_compiler compiler, spvc_variable_id id,
2268 SpvDecoration decoration,
2269 unsigned *word_offset)
2270 {
2271 uint32_t off = 0;
2272 bool ret = compiler->compiler->get_binary_offset_for_decoration(id, static_cast<spv::Decoration>(decoration), off);
2273 if (ret)
2274 {
2275 *word_offset = off;
2276 return SPVC_TRUE;
2277 }
2278 else
2279 return SPVC_FALSE;
2280 }
2281
2282 spvc_bool spvc_compiler_buffer_is_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id)
2283 {
2284 return compiler->compiler->buffer_is_hlsl_counter_buffer(id) ? SPVC_TRUE : SPVC_FALSE;
2285 }
2286
2287 spvc_bool spvc_compiler_buffer_get_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id,
2288 spvc_variable_id *counter_id)
2289 {
2290 uint32_t buffer;
2291 bool ret = compiler->compiler->buffer_get_hlsl_counter_buffer(id, buffer);
2292 if (ret)
2293 {
2294 *counter_id = buffer;
2295 return SPVC_TRUE;
2296 }
2297 else
2298 return SPVC_FALSE;
2299 }
2300
2301 spvc_result spvc_compiler_get_declared_capabilities(spvc_compiler compiler, const SpvCapability **capabilities,
2302 size_t *num_capabilities)
2303 {
2304 auto &caps = compiler->compiler->get_declared_capabilities();
2305 static_assert(sizeof(SpvCapability) == sizeof(spv::Capability), "Enum size mismatch.");
2306 *capabilities = reinterpret_cast<const SpvCapability *>(caps.data());
2307 *num_capabilities = caps.size();
2308 return SPVC_SUCCESS;
2309 }
2310
2311 spvc_result spvc_compiler_get_declared_extensions(spvc_compiler compiler, const char ***extensions,
2312 size_t *num_extensions)
2313 {
2314 SPVC_BEGIN_SAFE_SCOPE
2315 {
2316 auto &exts = compiler->compiler->get_declared_extensions();
2317 SmallVector<const char *> duped;
2318 duped.reserve(exts.size());
2319 for (auto &ext : exts)
2320 duped.push_back(compiler->context->allocate_name(ext));
2321
2322 auto ptr = spvc_allocate<TemporaryBuffer<const char *>>();
2323 ptr->buffer = std::move(duped);
2324 *extensions = ptr->buffer.data();
2325 *num_extensions = ptr->buffer.size();
2326 compiler->context->allocations.push_back(std::move(ptr));
2327 }
2328 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_OUT_OF_MEMORY)
2329 return SPVC_SUCCESS;
2330 }
2331
2332 const char *spvc_compiler_get_remapped_declared_block_name(spvc_compiler compiler, spvc_variable_id id)
2333 {
2334 SPVC_BEGIN_SAFE_SCOPE
2335 {
2336 auto name = compiler->compiler->get_remapped_declared_block_name(id);
2337 return compiler->context->allocate_name(name);
2338 }
2339 SPVC_END_SAFE_SCOPE(compiler->context, nullptr)
2340 }
2341
2342 spvc_result spvc_compiler_get_buffer_block_decorations(spvc_compiler compiler, spvc_variable_id id,
2343 const SpvDecoration **decorations, size_t *num_decorations)
2344 {
2345 SPVC_BEGIN_SAFE_SCOPE
2346 {
2347 auto flags = compiler->compiler->get_buffer_block_flags(id);
2348 auto bitset = spvc_allocate<TemporaryBuffer<SpvDecoration>>();
2349
2350 flags.for_each_bit([&](uint32_t bit) { bitset->buffer.push_back(static_cast<SpvDecoration>(bit)); });
2351
2352 *decorations = bitset->buffer.data();
2353 *num_decorations = bitset->buffer.size();
2354 compiler->context->allocations.push_back(std::move(bitset));
2355 }
2356 SPVC_END_SAFE_SCOPE(compiler->context, SPVC_ERROR_INVALID_ARGUMENT)
2357 return SPVC_SUCCESS;
2358 }
2359
2360 unsigned spvc_msl_get_aux_buffer_struct_version(void)
2361 {
2362 return SPVC_MSL_AUX_BUFFER_STRUCT_VERSION;
2363 }
2364
2365 void spvc_msl_vertex_attribute_init(spvc_msl_vertex_attribute *attr)
2366 {
2367 #if SPIRV_CROSS_C_API_MSL
2368 // Crude, but works.
2369 MSLShaderInput attr_default;
2370 attr->location = attr_default.location;
2371 attr->format = static_cast<spvc_msl_vertex_format>(attr_default.format);
2372 attr->builtin = static_cast<SpvBuiltIn>(attr_default.builtin);
2373 #else
2374 memset(attr, 0, sizeof(*attr));
2375 #endif
2376 }
2377
2378 void spvc_msl_shader_input_init(spvc_msl_shader_input *input)
2379 {
2380 #if SPIRV_CROSS_C_API_MSL
2381 MSLShaderInput input_default;
2382 input->location = input_default.location;
2383 input->format = static_cast<spvc_msl_shader_input_format>(input_default.format);
2384 input->builtin = static_cast<SpvBuiltIn>(input_default.builtin);
2385 input->vecsize = input_default.vecsize;
2386 #else
2387 memset(input, 0, sizeof(*input));
2388 #endif
2389 }
2390
2391 void spvc_msl_resource_binding_init(spvc_msl_resource_binding *binding)
2392 {
2393 #if SPIRV_CROSS_C_API_MSL
2394 MSLResourceBinding binding_default;
2395 binding->desc_set = binding_default.desc_set;
2396 binding->binding = binding_default.binding;
2397 binding->msl_buffer = binding_default.msl_buffer;
2398 binding->msl_texture = binding_default.msl_texture;
2399 binding->msl_sampler = binding_default.msl_sampler;
2400 binding->stage = static_cast<SpvExecutionModel>(binding_default.stage);
2401 #else
2402 memset(binding, 0, sizeof(*binding));
2403 #endif
2404 }
2405
2406 void spvc_hlsl_resource_binding_init(spvc_hlsl_resource_binding *binding)
2407 {
2408 #if SPIRV_CROSS_C_API_HLSL
2409 HLSLResourceBinding binding_default;
2410 binding->desc_set = binding_default.desc_set;
2411 binding->binding = binding_default.binding;
2412 binding->cbv.register_binding = binding_default.cbv.register_binding;
2413 binding->cbv.register_space = binding_default.cbv.register_space;
2414 binding->srv.register_binding = binding_default.srv.register_binding;
2415 binding->srv.register_space = binding_default.srv.register_space;
2416 binding->uav.register_binding = binding_default.uav.register_binding;
2417 binding->uav.register_space = binding_default.uav.register_space;
2418 binding->sampler.register_binding = binding_default.sampler.register_binding;
2419 binding->sampler.register_space = binding_default.sampler.register_space;
2420 binding->stage = static_cast<SpvExecutionModel>(binding_default.stage);
2421 #else
2422 memset(binding, 0, sizeof(*binding));
2423 #endif
2424 }
2425
2426 void spvc_msl_constexpr_sampler_init(spvc_msl_constexpr_sampler *sampler)
2427 {
2428 #if SPIRV_CROSS_C_API_MSL
2429 MSLConstexprSampler defaults;
2430 sampler->anisotropy_enable = defaults.anisotropy_enable ? SPVC_TRUE : SPVC_FALSE;
2431 sampler->border_color = static_cast<spvc_msl_sampler_border_color>(defaults.border_color);
2432 sampler->compare_enable = defaults.compare_enable ? SPVC_TRUE : SPVC_FALSE;
2433 sampler->coord = static_cast<spvc_msl_sampler_coord>(defaults.coord);
2434 sampler->compare_func = static_cast<spvc_msl_sampler_compare_func>(defaults.compare_func);
2435 sampler->lod_clamp_enable = defaults.lod_clamp_enable ? SPVC_TRUE : SPVC_FALSE;
2436 sampler->lod_clamp_max = defaults.lod_clamp_max;
2437 sampler->lod_clamp_min = defaults.lod_clamp_min;
2438 sampler->mag_filter = static_cast<spvc_msl_sampler_filter>(defaults.mag_filter);
2439 sampler->min_filter = static_cast<spvc_msl_sampler_filter>(defaults.min_filter);
2440 sampler->mip_filter = static_cast<spvc_msl_sampler_mip_filter>(defaults.mip_filter);
2441 sampler->max_anisotropy = defaults.max_anisotropy;
2442 sampler->s_address = static_cast<spvc_msl_sampler_address>(defaults.s_address);
2443 sampler->t_address = static_cast<spvc_msl_sampler_address>(defaults.t_address);
2444 sampler->r_address = static_cast<spvc_msl_sampler_address>(defaults.r_address);
2445 #else
2446 memset(sampler, 0, sizeof(*sampler));
2447 #endif
2448 }
2449
2450 void spvc_msl_sampler_ycbcr_conversion_init(spvc_msl_sampler_ycbcr_conversion *conv)
2451 {
2452 #if SPIRV_CROSS_C_API_MSL
2453 MSLConstexprSampler defaults;
2454 conv->planes = defaults.planes;
2455 conv->resolution = static_cast<spvc_msl_format_resolution>(defaults.resolution);
2456 conv->chroma_filter = static_cast<spvc_msl_sampler_filter>(defaults.chroma_filter);
2457 conv->x_chroma_offset = static_cast<spvc_msl_chroma_location>(defaults.x_chroma_offset);
2458 conv->y_chroma_offset = static_cast<spvc_msl_chroma_location>(defaults.y_chroma_offset);
2459 for (int i = 0; i < 4; i++)
2460 conv->swizzle[i] = static_cast<spvc_msl_component_swizzle>(defaults.swizzle[i]);
2461 conv->ycbcr_model = static_cast<spvc_msl_sampler_ycbcr_model_conversion>(defaults.ycbcr_model);
2462 conv->ycbcr_range = static_cast<spvc_msl_sampler_ycbcr_range>(defaults.ycbcr_range);
2463 #else
2464 memset(conv, 0, sizeof(*conv));
2465 #endif
2466 }
2467
2468 unsigned spvc_compiler_get_current_id_bound(spvc_compiler compiler)
2469 {
2470 return compiler->compiler->get_current_id_bound();
2471 }
2472
2473 void spvc_get_version(unsigned *major, unsigned *minor, unsigned *patch)
2474 {
2475 *major = SPVC_C_API_VERSION_MAJOR;
2476 *minor = SPVC_C_API_VERSION_MINOR;
2477 *patch = SPVC_C_API_VERSION_PATCH;
2478 }
2479
2480 const char *spvc_get_commit_revision_and_timestamp(void)
2481 {
2482 #ifdef HAVE_SPIRV_CROSS_GIT_VERSION
2483 return SPIRV_CROSS_GIT_REVISION;
2484 #else
2485 return "";
2486 #endif
2487 }
2488
2489 #ifdef _MSC_VER
2490 #pragma warning(pop)
2491 #endif