1 /* 2 * Copyright 2019-2021 Hans-Kristian Arntzen 3 * SPDX-License-Identifier: Apache-2.0 OR MIT 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /* 19 * At your option, you may choose to accept this material under either: 20 * 1. The Apache License, Version 2.0, found at <http://www.apache.org/licenses/LICENSE-2.0>, or 21 * 2. The MIT License, found at <http://opensource.org/licenses/MIT>. 22 */ 23 24 #ifndef SPIRV_CROSS_C_API_H 25 #define SPIRV_CROSS_C_API_H 26 27 #include <stddef.h> 28 #include "spirv.h" 29 30 /* 31 * C89-compatible wrapper for SPIRV-Cross' API. 32 * Documentation here is sparse unless the behavior does not map 1:1 with C++ API. 33 * It is recommended to look at the canonical C++ API for more detailed information. 34 */ 35 36 #ifdef __cplusplus 37 extern "C" { 38 #endif 39 40 /* Bumped if ABI or API breaks backwards compatibility. */ 41 #define SPVC_C_API_VERSION_MAJOR 0 42 /* Bumped if APIs or enumerations are added in a backwards compatible way. */ 43 #define SPVC_C_API_VERSION_MINOR 48 44 /* Bumped if internal implementation details change. */ 45 #define SPVC_C_API_VERSION_PATCH 0 46 47 #if !defined(SPVC_PUBLIC_API) 48 #if defined(SPVC_EXPORT_SYMBOLS) 49 /* Exports symbols. Standard C calling convention is used. */ 50 #if defined(__GNUC__) 51 #define SPVC_PUBLIC_API __attribute__((visibility("default"))) 52 #elif defined(_MSC_VER) 53 #define SPVC_PUBLIC_API __declspec(dllexport) 54 #else 55 #define SPVC_PUBLIC_API 56 #endif 57 #else 58 #define SPVC_PUBLIC_API 59 #endif 60 #endif 61 62 /* 63 * Gets the SPVC_C_API_VERSION_* used to build this library. 64 * Can be used to check for ABI mismatch if so-versioning did not catch it. 65 */ 66 SPVC_PUBLIC_API void spvc_get_version(unsigned *major, unsigned *minor, unsigned *patch); 67 68 /* Gets a human readable version string to identify which commit a particular binary was created from. */ 69 SPVC_PUBLIC_API const char *spvc_get_commit_revision_and_timestamp(void); 70 71 /* These types are opaque to the user. */ 72 typedef struct spvc_context_s *spvc_context; 73 typedef struct spvc_parsed_ir_s *spvc_parsed_ir; 74 typedef struct spvc_compiler_s *spvc_compiler; 75 typedef struct spvc_compiler_options_s *spvc_compiler_options; 76 typedef struct spvc_resources_s *spvc_resources; 77 struct spvc_type_s; 78 typedef const struct spvc_type_s *spvc_type; 79 typedef struct spvc_constant_s *spvc_constant; 80 struct spvc_set_s; 81 typedef const struct spvc_set_s *spvc_set; 82 83 /* 84 * Shallow typedefs. All SPIR-V IDs are plain 32-bit numbers, but this helps communicate which data is used. 85 * Maps to a SPIRType. 86 */ 87 typedef SpvId spvc_type_id; 88 /* Maps to a SPIRVariable. */ 89 typedef SpvId spvc_variable_id; 90 /* Maps to a SPIRConstant. */ 91 typedef SpvId spvc_constant_id; 92 93 /* See C++ API. */ 94 typedef struct spvc_reflected_resource 95 { 96 spvc_variable_id id; 97 spvc_type_id base_type_id; 98 spvc_type_id type_id; 99 const char *name; 100 } spvc_reflected_resource; 101 102 typedef struct spvc_reflected_builtin_resource 103 { 104 SpvBuiltIn builtin; 105 spvc_type_id value_type_id; 106 spvc_reflected_resource resource; 107 } spvc_reflected_builtin_resource; 108 109 /* See C++ API. */ 110 typedef struct spvc_entry_point 111 { 112 SpvExecutionModel execution_model; 113 const char *name; 114 } spvc_entry_point; 115 116 /* See C++ API. */ 117 typedef struct spvc_combined_image_sampler 118 { 119 spvc_variable_id combined_id; 120 spvc_variable_id image_id; 121 spvc_variable_id sampler_id; 122 } spvc_combined_image_sampler; 123 124 /* See C++ API. */ 125 typedef struct spvc_specialization_constant 126 { 127 spvc_constant_id id; 128 unsigned constant_id; 129 } spvc_specialization_constant; 130 131 /* See C++ API. */ 132 typedef struct spvc_buffer_range 133 { 134 unsigned index; 135 size_t offset; 136 size_t range; 137 } spvc_buffer_range; 138 139 /* See C++ API. */ 140 typedef struct spvc_hlsl_root_constants 141 { 142 unsigned start; 143 unsigned end; 144 unsigned binding; 145 unsigned space; 146 } spvc_hlsl_root_constants; 147 148 /* See C++ API. */ 149 typedef struct spvc_hlsl_vertex_attribute_remap 150 { 151 unsigned location; 152 const char *semantic; 153 } spvc_hlsl_vertex_attribute_remap; 154 155 /* 156 * Be compatible with non-C99 compilers, which do not have stdbool. 157 * Only recent MSVC compilers supports this for example, and ideally SPIRV-Cross should be linkable 158 * from a wide range of compilers in its C wrapper. 159 */ 160 typedef unsigned char spvc_bool; 161 #define SPVC_TRUE ((spvc_bool)1) 162 #define SPVC_FALSE ((spvc_bool)0) 163 164 typedef enum spvc_result 165 { 166 /* Success. */ 167 SPVC_SUCCESS = 0, 168 169 /* The SPIR-V is invalid. Should have been caught by validation ideally. */ 170 SPVC_ERROR_INVALID_SPIRV = -1, 171 172 /* The SPIR-V might be valid or invalid, but SPIRV-Cross currently cannot correctly translate this to your target language. */ 173 SPVC_ERROR_UNSUPPORTED_SPIRV = -2, 174 175 /* If for some reason we hit this, new or malloc failed. */ 176 SPVC_ERROR_OUT_OF_MEMORY = -3, 177 178 /* Invalid API argument. */ 179 SPVC_ERROR_INVALID_ARGUMENT = -4, 180 181 SPVC_ERROR_INT_MAX = 0x7fffffff 182 } spvc_result; 183 184 typedef enum spvc_capture_mode 185 { 186 /* The Parsed IR payload will be copied, and the handle can be reused to create other compiler instances. */ 187 SPVC_CAPTURE_MODE_COPY = 0, 188 189 /* 190 * The payload will now be owned by the compiler. 191 * parsed_ir should now be considered a dead blob and must not be used further. 192 * This is optimal for performance and should be the go-to option. 193 */ 194 SPVC_CAPTURE_MODE_TAKE_OWNERSHIP = 1, 195 196 SPVC_CAPTURE_MODE_INT_MAX = 0x7fffffff 197 } spvc_capture_mode; 198 199 typedef enum spvc_backend 200 { 201 /* This backend can only perform reflection, no compiler options are supported. Maps to spirv_cross::Compiler. */ 202 SPVC_BACKEND_NONE = 0, 203 SPVC_BACKEND_GLSL = 1, /* spirv_cross::CompilerGLSL */ 204 SPVC_BACKEND_HLSL = 2, /* CompilerHLSL */ 205 SPVC_BACKEND_MSL = 3, /* CompilerMSL */ 206 SPVC_BACKEND_CPP = 4, /* CompilerCPP */ 207 SPVC_BACKEND_JSON = 5, /* CompilerReflection w/ JSON backend */ 208 SPVC_BACKEND_INT_MAX = 0x7fffffff 209 } spvc_backend; 210 211 /* Maps to C++ API. */ 212 typedef enum spvc_resource_type 213 { 214 SPVC_RESOURCE_TYPE_UNKNOWN = 0, 215 SPVC_RESOURCE_TYPE_UNIFORM_BUFFER = 1, 216 SPVC_RESOURCE_TYPE_STORAGE_BUFFER = 2, 217 SPVC_RESOURCE_TYPE_STAGE_INPUT = 3, 218 SPVC_RESOURCE_TYPE_STAGE_OUTPUT = 4, 219 SPVC_RESOURCE_TYPE_SUBPASS_INPUT = 5, 220 SPVC_RESOURCE_TYPE_STORAGE_IMAGE = 6, 221 SPVC_RESOURCE_TYPE_SAMPLED_IMAGE = 7, 222 SPVC_RESOURCE_TYPE_ATOMIC_COUNTER = 8, 223 SPVC_RESOURCE_TYPE_PUSH_CONSTANT = 9, 224 SPVC_RESOURCE_TYPE_SEPARATE_IMAGE = 10, 225 SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS = 11, 226 SPVC_RESOURCE_TYPE_ACCELERATION_STRUCTURE = 12, 227 SPVC_RESOURCE_TYPE_RAY_QUERY = 13, 228 SPVC_RESOURCE_TYPE_INT_MAX = 0x7fffffff 229 } spvc_resource_type; 230 231 typedef enum spvc_builtin_resource_type 232 { 233 SPVC_BUILTIN_RESOURCE_TYPE_UNKNOWN = 0, 234 SPVC_BUILTIN_RESOURCE_TYPE_STAGE_INPUT = 1, 235 SPVC_BUILTIN_RESOURCE_TYPE_STAGE_OUTPUT = 2, 236 SPVC_BUILTIN_RESOURCE_TYPE_INT_MAX = 0x7fffffff 237 } spvc_builtin_resource_type; 238 239 /* Maps to spirv_cross::SPIRType::BaseType. */ 240 typedef enum spvc_basetype 241 { 242 SPVC_BASETYPE_UNKNOWN = 0, 243 SPVC_BASETYPE_VOID = 1, 244 SPVC_BASETYPE_BOOLEAN = 2, 245 SPVC_BASETYPE_INT8 = 3, 246 SPVC_BASETYPE_UINT8 = 4, 247 SPVC_BASETYPE_INT16 = 5, 248 SPVC_BASETYPE_UINT16 = 6, 249 SPVC_BASETYPE_INT32 = 7, 250 SPVC_BASETYPE_UINT32 = 8, 251 SPVC_BASETYPE_INT64 = 9, 252 SPVC_BASETYPE_UINT64 = 10, 253 SPVC_BASETYPE_ATOMIC_COUNTER = 11, 254 SPVC_BASETYPE_FP16 = 12, 255 SPVC_BASETYPE_FP32 = 13, 256 SPVC_BASETYPE_FP64 = 14, 257 SPVC_BASETYPE_STRUCT = 15, 258 SPVC_BASETYPE_IMAGE = 16, 259 SPVC_BASETYPE_SAMPLED_IMAGE = 17, 260 SPVC_BASETYPE_SAMPLER = 18, 261 SPVC_BASETYPE_ACCELERATION_STRUCTURE = 19, 262 263 SPVC_BASETYPE_INT_MAX = 0x7fffffff 264 } spvc_basetype; 265 266 #define SPVC_COMPILER_OPTION_COMMON_BIT 0x1000000 267 #define SPVC_COMPILER_OPTION_GLSL_BIT 0x2000000 268 #define SPVC_COMPILER_OPTION_HLSL_BIT 0x4000000 269 #define SPVC_COMPILER_OPTION_MSL_BIT 0x8000000 270 #define SPVC_COMPILER_OPTION_LANG_BITS 0x0f000000 271 #define SPVC_COMPILER_OPTION_ENUM_BITS 0xffffff 272 273 #define SPVC_MAKE_MSL_VERSION(major, minor, patch) ((major) * 10000 + (minor) * 100 + (patch)) 274 275 /* Maps to C++ API. */ 276 typedef enum spvc_msl_platform 277 { 278 SPVC_MSL_PLATFORM_IOS = 0, 279 SPVC_MSL_PLATFORM_MACOS = 1, 280 SPVC_MSL_PLATFORM_MAX_INT = 0x7fffffff 281 } spvc_msl_platform; 282 283 /* Maps to C++ API. */ 284 typedef enum spvc_msl_index_type 285 { 286 SPVC_MSL_INDEX_TYPE_NONE = 0, 287 SPVC_MSL_INDEX_TYPE_UINT16 = 1, 288 SPVC_MSL_INDEX_TYPE_UINT32 = 2, 289 SPVC_MSL_INDEX_TYPE_MAX_INT = 0x7fffffff 290 } spvc_msl_index_type; 291 292 /* Maps to C++ API. */ 293 typedef enum spvc_msl_shader_input_format 294 { 295 SPVC_MSL_SHADER_INPUT_FORMAT_OTHER = 0, 296 SPVC_MSL_SHADER_INPUT_FORMAT_UINT8 = 1, 297 SPVC_MSL_SHADER_INPUT_FORMAT_UINT16 = 2, 298 SPVC_MSL_SHADER_INPUT_FORMAT_ANY16 = 3, 299 SPVC_MSL_SHADER_INPUT_FORMAT_ANY32 = 4, 300 301 /* Deprecated names. */ 302 SPVC_MSL_VERTEX_FORMAT_OTHER = SPVC_MSL_SHADER_INPUT_FORMAT_OTHER, 303 SPVC_MSL_VERTEX_FORMAT_UINT8 = SPVC_MSL_SHADER_INPUT_FORMAT_UINT8, 304 SPVC_MSL_VERTEX_FORMAT_UINT16 = SPVC_MSL_SHADER_INPUT_FORMAT_UINT16, 305 306 SPVC_MSL_SHADER_INPUT_FORMAT_INT_MAX = 0x7fffffff 307 } spvc_msl_shader_input_format, spvc_msl_vertex_format; 308 309 /* Maps to C++ API. Deprecated; use spvc_msl_shader_input. */ 310 typedef struct spvc_msl_vertex_attribute 311 { 312 unsigned location; 313 314 /* Obsolete, do not use. Only lingers on for ABI compatibility. */ 315 unsigned msl_buffer; 316 /* Obsolete, do not use. Only lingers on for ABI compatibility. */ 317 unsigned msl_offset; 318 /* Obsolete, do not use. Only lingers on for ABI compatibility. */ 319 unsigned msl_stride; 320 /* Obsolete, do not use. Only lingers on for ABI compatibility. */ 321 spvc_bool per_instance; 322 323 spvc_msl_vertex_format format; 324 SpvBuiltIn builtin; 325 } spvc_msl_vertex_attribute; 326 327 /* 328 * Initializes the vertex attribute struct. 329 */ 330 SPVC_PUBLIC_API void spvc_msl_vertex_attribute_init(spvc_msl_vertex_attribute *attr); 331 332 /* Maps to C++ API. */ 333 typedef struct spvc_msl_shader_input 334 { 335 unsigned location; 336 spvc_msl_vertex_format format; 337 SpvBuiltIn builtin; 338 unsigned vecsize; 339 } spvc_msl_shader_input; 340 341 /* 342 * Initializes the shader input struct. 343 */ 344 SPVC_PUBLIC_API void spvc_msl_shader_input_init(spvc_msl_shader_input *input); 345 346 /* Maps to C++ API. */ 347 typedef struct spvc_msl_resource_binding 348 { 349 SpvExecutionModel stage; 350 unsigned desc_set; 351 unsigned binding; 352 unsigned msl_buffer; 353 unsigned msl_texture; 354 unsigned msl_sampler; 355 } spvc_msl_resource_binding; 356 357 /* 358 * Initializes the resource binding struct. 359 * The defaults are non-zero. 360 */ 361 SPVC_PUBLIC_API void spvc_msl_resource_binding_init(spvc_msl_resource_binding *binding); 362 363 #define SPVC_MSL_PUSH_CONSTANT_DESC_SET (~(0u)) 364 #define SPVC_MSL_PUSH_CONSTANT_BINDING (0) 365 #define SPVC_MSL_SWIZZLE_BUFFER_BINDING (~(1u)) 366 #define SPVC_MSL_BUFFER_SIZE_BUFFER_BINDING (~(2u)) 367 #define SPVC_MSL_ARGUMENT_BUFFER_BINDING (~(3u)) 368 369 /* Obsolete. Sticks around for backwards compatibility. */ 370 #define SPVC_MSL_AUX_BUFFER_STRUCT_VERSION 1 371 372 /* Runtime check for incompatibility. Obsolete. */ 373 SPVC_PUBLIC_API unsigned spvc_msl_get_aux_buffer_struct_version(void); 374 375 /* Maps to C++ API. */ 376 typedef enum spvc_msl_sampler_coord 377 { 378 SPVC_MSL_SAMPLER_COORD_NORMALIZED = 0, 379 SPVC_MSL_SAMPLER_COORD_PIXEL = 1, 380 SPVC_MSL_SAMPLER_INT_MAX = 0x7fffffff 381 } spvc_msl_sampler_coord; 382 383 /* Maps to C++ API. */ 384 typedef enum spvc_msl_sampler_filter 385 { 386 SPVC_MSL_SAMPLER_FILTER_NEAREST = 0, 387 SPVC_MSL_SAMPLER_FILTER_LINEAR = 1, 388 SPVC_MSL_SAMPLER_FILTER_INT_MAX = 0x7fffffff 389 } spvc_msl_sampler_filter; 390 391 /* Maps to C++ API. */ 392 typedef enum spvc_msl_sampler_mip_filter 393 { 394 SPVC_MSL_SAMPLER_MIP_FILTER_NONE = 0, 395 SPVC_MSL_SAMPLER_MIP_FILTER_NEAREST = 1, 396 SPVC_MSL_SAMPLER_MIP_FILTER_LINEAR = 2, 397 SPVC_MSL_SAMPLER_MIP_FILTER_INT_MAX = 0x7fffffff 398 } spvc_msl_sampler_mip_filter; 399 400 /* Maps to C++ API. */ 401 typedef enum spvc_msl_sampler_address 402 { 403 SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO = 0, 404 SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE = 1, 405 SPVC_MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER = 2, 406 SPVC_MSL_SAMPLER_ADDRESS_REPEAT = 3, 407 SPVC_MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT = 4, 408 SPVC_MSL_SAMPLER_ADDRESS_INT_MAX = 0x7fffffff 409 } spvc_msl_sampler_address; 410 411 /* Maps to C++ API. */ 412 typedef enum spvc_msl_sampler_compare_func 413 { 414 SPVC_MSL_SAMPLER_COMPARE_FUNC_NEVER = 0, 415 SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS = 1, 416 SPVC_MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL = 2, 417 SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER = 3, 418 SPVC_MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL = 4, 419 SPVC_MSL_SAMPLER_COMPARE_FUNC_EQUAL = 5, 420 SPVC_MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL = 6, 421 SPVC_MSL_SAMPLER_COMPARE_FUNC_ALWAYS = 7, 422 SPVC_MSL_SAMPLER_COMPARE_FUNC_INT_MAX = 0x7fffffff 423 } spvc_msl_sampler_compare_func; 424 425 /* Maps to C++ API. */ 426 typedef enum spvc_msl_sampler_border_color 427 { 428 SPVC_MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK = 0, 429 SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK = 1, 430 SPVC_MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE = 2, 431 SPVC_MSL_SAMPLER_BORDER_COLOR_INT_MAX = 0x7fffffff 432 } spvc_msl_sampler_border_color; 433 434 /* Maps to C++ API. */ 435 typedef enum spvc_msl_format_resolution 436 { 437 SPVC_MSL_FORMAT_RESOLUTION_444 = 0, 438 SPVC_MSL_FORMAT_RESOLUTION_422, 439 SPVC_MSL_FORMAT_RESOLUTION_420, 440 SPVC_MSL_FORMAT_RESOLUTION_INT_MAX = 0x7fffffff 441 } spvc_msl_format_resolution; 442 443 /* Maps to C++ API. */ 444 typedef enum spvc_msl_chroma_location 445 { 446 SPVC_MSL_CHROMA_LOCATION_COSITED_EVEN = 0, 447 SPVC_MSL_CHROMA_LOCATION_MIDPOINT, 448 SPVC_MSL_CHROMA_LOCATION_INT_MAX = 0x7fffffff 449 } spvc_msl_chroma_location; 450 451 /* Maps to C++ API. */ 452 typedef enum spvc_msl_component_swizzle 453 { 454 SPVC_MSL_COMPONENT_SWIZZLE_IDENTITY = 0, 455 SPVC_MSL_COMPONENT_SWIZZLE_ZERO, 456 SPVC_MSL_COMPONENT_SWIZZLE_ONE, 457 SPVC_MSL_COMPONENT_SWIZZLE_R, 458 SPVC_MSL_COMPONENT_SWIZZLE_G, 459 SPVC_MSL_COMPONENT_SWIZZLE_B, 460 SPVC_MSL_COMPONENT_SWIZZLE_A, 461 SPVC_MSL_COMPONENT_SWIZZLE_INT_MAX = 0x7fffffff 462 } spvc_msl_component_swizzle; 463 464 /* Maps to C++ API. */ 465 typedef enum spvc_msl_sampler_ycbcr_model_conversion 466 { 467 SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, 468 SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, 469 SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709, 470 SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601, 471 SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020, 472 SPVC_MSL_SAMPLER_YCBCR_MODEL_CONVERSION_INT_MAX = 0x7fffffff 473 } spvc_msl_sampler_ycbcr_model_conversion; 474 475 /* Maps to C+ API. */ 476 typedef enum spvc_msl_sampler_ycbcr_range 477 { 478 SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, 479 SPVC_MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW, 480 SPVC_MSL_SAMPLER_YCBCR_RANGE_INT_MAX = 0x7fffffff 481 } spvc_msl_sampler_ycbcr_range; 482 483 /* Maps to C++ API. */ 484 typedef struct spvc_msl_constexpr_sampler 485 { 486 spvc_msl_sampler_coord coord; 487 spvc_msl_sampler_filter min_filter; 488 spvc_msl_sampler_filter mag_filter; 489 spvc_msl_sampler_mip_filter mip_filter; 490 spvc_msl_sampler_address s_address; 491 spvc_msl_sampler_address t_address; 492 spvc_msl_sampler_address r_address; 493 spvc_msl_sampler_compare_func compare_func; 494 spvc_msl_sampler_border_color border_color; 495 float lod_clamp_min; 496 float lod_clamp_max; 497 int max_anisotropy; 498 499 spvc_bool compare_enable; 500 spvc_bool lod_clamp_enable; 501 spvc_bool anisotropy_enable; 502 } spvc_msl_constexpr_sampler; 503 504 /* 505 * Initializes the constexpr sampler struct. 506 * The defaults are non-zero. 507 */ 508 SPVC_PUBLIC_API void spvc_msl_constexpr_sampler_init(spvc_msl_constexpr_sampler *sampler); 509 510 /* Maps to the sampler Y'CbCr conversion-related portions of MSLConstexprSampler. See C++ API for defaults and details. */ 511 typedef struct spvc_msl_sampler_ycbcr_conversion 512 { 513 unsigned planes; 514 spvc_msl_format_resolution resolution; 515 spvc_msl_sampler_filter chroma_filter; 516 spvc_msl_chroma_location x_chroma_offset; 517 spvc_msl_chroma_location y_chroma_offset; 518 spvc_msl_component_swizzle swizzle[4]; 519 spvc_msl_sampler_ycbcr_model_conversion ycbcr_model; 520 spvc_msl_sampler_ycbcr_range ycbcr_range; 521 unsigned bpc; 522 } spvc_msl_sampler_ycbcr_conversion; 523 524 /* 525 * Initializes the constexpr sampler struct. 526 * The defaults are non-zero. 527 */ 528 SPVC_PUBLIC_API void spvc_msl_sampler_ycbcr_conversion_init(spvc_msl_sampler_ycbcr_conversion *conv); 529 530 /* Maps to C++ API. */ 531 typedef enum spvc_hlsl_binding_flag_bits 532 { 533 SPVC_HLSL_BINDING_AUTO_NONE_BIT = 0, 534 SPVC_HLSL_BINDING_AUTO_PUSH_CONSTANT_BIT = 1 << 0, 535 SPVC_HLSL_BINDING_AUTO_CBV_BIT = 1 << 1, 536 SPVC_HLSL_BINDING_AUTO_SRV_BIT = 1 << 2, 537 SPVC_HLSL_BINDING_AUTO_UAV_BIT = 1 << 3, 538 SPVC_HLSL_BINDING_AUTO_SAMPLER_BIT = 1 << 4, 539 SPVC_HLSL_BINDING_AUTO_ALL = 0x7fffffff 540 } spvc_hlsl_binding_flag_bits; 541 typedef unsigned spvc_hlsl_binding_flags; 542 543 #define SPVC_HLSL_PUSH_CONSTANT_DESC_SET (~(0u)) 544 #define SPVC_HLSL_PUSH_CONSTANT_BINDING (0) 545 546 /* Maps to C++ API. */ 547 typedef struct spvc_hlsl_resource_binding_mapping 548 { 549 unsigned register_space; 550 unsigned register_binding; 551 } spvc_hlsl_resource_binding_mapping; 552 553 typedef struct spvc_hlsl_resource_binding 554 { 555 SpvExecutionModel stage; 556 unsigned desc_set; 557 unsigned binding; 558 559 spvc_hlsl_resource_binding_mapping cbv, uav, srv, sampler; 560 } spvc_hlsl_resource_binding; 561 562 /* 563 * Initializes the resource binding struct. 564 * The defaults are non-zero. 565 */ 566 SPVC_PUBLIC_API void spvc_hlsl_resource_binding_init(spvc_hlsl_resource_binding *binding); 567 568 /* Maps to the various spirv_cross::Compiler*::Option structures. See C++ API for defaults and details. */ 569 typedef enum spvc_compiler_option 570 { 571 SPVC_COMPILER_OPTION_UNKNOWN = 0, 572 573 SPVC_COMPILER_OPTION_FORCE_TEMPORARY = 1 | SPVC_COMPILER_OPTION_COMMON_BIT, 574 SPVC_COMPILER_OPTION_FLATTEN_MULTIDIMENSIONAL_ARRAYS = 2 | SPVC_COMPILER_OPTION_COMMON_BIT, 575 SPVC_COMPILER_OPTION_FIXUP_DEPTH_CONVENTION = 3 | SPVC_COMPILER_OPTION_COMMON_BIT, 576 SPVC_COMPILER_OPTION_FLIP_VERTEX_Y = 4 | SPVC_COMPILER_OPTION_COMMON_BIT, 577 578 SPVC_COMPILER_OPTION_GLSL_SUPPORT_NONZERO_BASE_INSTANCE = 5 | SPVC_COMPILER_OPTION_GLSL_BIT, 579 SPVC_COMPILER_OPTION_GLSL_SEPARATE_SHADER_OBJECTS = 6 | SPVC_COMPILER_OPTION_GLSL_BIT, 580 SPVC_COMPILER_OPTION_GLSL_ENABLE_420PACK_EXTENSION = 7 | SPVC_COMPILER_OPTION_GLSL_BIT, 581 SPVC_COMPILER_OPTION_GLSL_VERSION = 8 | SPVC_COMPILER_OPTION_GLSL_BIT, 582 SPVC_COMPILER_OPTION_GLSL_ES = 9 | SPVC_COMPILER_OPTION_GLSL_BIT, 583 SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS = 10 | SPVC_COMPILER_OPTION_GLSL_BIT, 584 SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_FLOAT_PRECISION_HIGHP = 11 | SPVC_COMPILER_OPTION_GLSL_BIT, 585 SPVC_COMPILER_OPTION_GLSL_ES_DEFAULT_INT_PRECISION_HIGHP = 12 | SPVC_COMPILER_OPTION_GLSL_BIT, 586 587 SPVC_COMPILER_OPTION_HLSL_SHADER_MODEL = 13 | SPVC_COMPILER_OPTION_HLSL_BIT, 588 SPVC_COMPILER_OPTION_HLSL_POINT_SIZE_COMPAT = 14 | SPVC_COMPILER_OPTION_HLSL_BIT, 589 SPVC_COMPILER_OPTION_HLSL_POINT_COORD_COMPAT = 15 | SPVC_COMPILER_OPTION_HLSL_BIT, 590 SPVC_COMPILER_OPTION_HLSL_SUPPORT_NONZERO_BASE_VERTEX_BASE_INSTANCE = 16 | SPVC_COMPILER_OPTION_HLSL_BIT, 591 592 SPVC_COMPILER_OPTION_MSL_VERSION = 17 | SPVC_COMPILER_OPTION_MSL_BIT, 593 SPVC_COMPILER_OPTION_MSL_TEXEL_BUFFER_TEXTURE_WIDTH = 18 | SPVC_COMPILER_OPTION_MSL_BIT, 594 595 /* Obsolete, use SWIZZLE_BUFFER_INDEX instead. */ 596 SPVC_COMPILER_OPTION_MSL_AUX_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT, 597 SPVC_COMPILER_OPTION_MSL_SWIZZLE_BUFFER_INDEX = 19 | SPVC_COMPILER_OPTION_MSL_BIT, 598 599 SPVC_COMPILER_OPTION_MSL_INDIRECT_PARAMS_BUFFER_INDEX = 20 | SPVC_COMPILER_OPTION_MSL_BIT, 600 SPVC_COMPILER_OPTION_MSL_SHADER_OUTPUT_BUFFER_INDEX = 21 | SPVC_COMPILER_OPTION_MSL_BIT, 601 SPVC_COMPILER_OPTION_MSL_SHADER_PATCH_OUTPUT_BUFFER_INDEX = 22 | SPVC_COMPILER_OPTION_MSL_BIT, 602 SPVC_COMPILER_OPTION_MSL_SHADER_TESS_FACTOR_OUTPUT_BUFFER_INDEX = 23 | SPVC_COMPILER_OPTION_MSL_BIT, 603 SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_WORKGROUP_INDEX = 24 | SPVC_COMPILER_OPTION_MSL_BIT, 604 SPVC_COMPILER_OPTION_MSL_ENABLE_POINT_SIZE_BUILTIN = 25 | SPVC_COMPILER_OPTION_MSL_BIT, 605 SPVC_COMPILER_OPTION_MSL_DISABLE_RASTERIZATION = 26 | SPVC_COMPILER_OPTION_MSL_BIT, 606 SPVC_COMPILER_OPTION_MSL_CAPTURE_OUTPUT_TO_BUFFER = 27 | SPVC_COMPILER_OPTION_MSL_BIT, 607 SPVC_COMPILER_OPTION_MSL_SWIZZLE_TEXTURE_SAMPLES = 28 | SPVC_COMPILER_OPTION_MSL_BIT, 608 SPVC_COMPILER_OPTION_MSL_PAD_FRAGMENT_OUTPUT_COMPONENTS = 29 | SPVC_COMPILER_OPTION_MSL_BIT, 609 SPVC_COMPILER_OPTION_MSL_TESS_DOMAIN_ORIGIN_LOWER_LEFT = 30 | SPVC_COMPILER_OPTION_MSL_BIT, 610 SPVC_COMPILER_OPTION_MSL_PLATFORM = 31 | SPVC_COMPILER_OPTION_MSL_BIT, 611 SPVC_COMPILER_OPTION_MSL_ARGUMENT_BUFFERS = 32 | SPVC_COMPILER_OPTION_MSL_BIT, 612 613 SPVC_COMPILER_OPTION_GLSL_EMIT_PUSH_CONSTANT_AS_UNIFORM_BUFFER = 33 | SPVC_COMPILER_OPTION_GLSL_BIT, 614 615 SPVC_COMPILER_OPTION_MSL_TEXTURE_BUFFER_NATIVE = 34 | SPVC_COMPILER_OPTION_MSL_BIT, 616 617 SPVC_COMPILER_OPTION_GLSL_EMIT_UNIFORM_BUFFER_AS_PLAIN_UNIFORMS = 35 | SPVC_COMPILER_OPTION_GLSL_BIT, 618 619 SPVC_COMPILER_OPTION_MSL_BUFFER_SIZE_BUFFER_INDEX = 36 | SPVC_COMPILER_OPTION_MSL_BIT, 620 621 SPVC_COMPILER_OPTION_EMIT_LINE_DIRECTIVES = 37 | SPVC_COMPILER_OPTION_COMMON_BIT, 622 623 SPVC_COMPILER_OPTION_MSL_MULTIVIEW = 38 | SPVC_COMPILER_OPTION_MSL_BIT, 624 SPVC_COMPILER_OPTION_MSL_VIEW_MASK_BUFFER_INDEX = 39 | SPVC_COMPILER_OPTION_MSL_BIT, 625 SPVC_COMPILER_OPTION_MSL_DEVICE_INDEX = 40 | SPVC_COMPILER_OPTION_MSL_BIT, 626 SPVC_COMPILER_OPTION_MSL_VIEW_INDEX_FROM_DEVICE_INDEX = 41 | SPVC_COMPILER_OPTION_MSL_BIT, 627 SPVC_COMPILER_OPTION_MSL_DISPATCH_BASE = 42 | SPVC_COMPILER_OPTION_MSL_BIT, 628 SPVC_COMPILER_OPTION_MSL_DYNAMIC_OFFSETS_BUFFER_INDEX = 43 | SPVC_COMPILER_OPTION_MSL_BIT, 629 SPVC_COMPILER_OPTION_MSL_TEXTURE_1D_AS_2D = 44 | SPVC_COMPILER_OPTION_MSL_BIT, 630 SPVC_COMPILER_OPTION_MSL_ENABLE_BASE_INDEX_ZERO = 45 | SPVC_COMPILER_OPTION_MSL_BIT, 631 632 /* Obsolete. Use MSL_FRAMEBUFFER_FETCH_SUBPASS instead. */ 633 SPVC_COMPILER_OPTION_MSL_IOS_FRAMEBUFFER_FETCH_SUBPASS = 46 | SPVC_COMPILER_OPTION_MSL_BIT, 634 SPVC_COMPILER_OPTION_MSL_FRAMEBUFFER_FETCH_SUBPASS = 46 | SPVC_COMPILER_OPTION_MSL_BIT, 635 636 SPVC_COMPILER_OPTION_MSL_INVARIANT_FP_MATH = 47 | SPVC_COMPILER_OPTION_MSL_BIT, 637 SPVC_COMPILER_OPTION_MSL_EMULATE_CUBEMAP_ARRAY = 48 | SPVC_COMPILER_OPTION_MSL_BIT, 638 SPVC_COMPILER_OPTION_MSL_ENABLE_DECORATION_BINDING = 49 | SPVC_COMPILER_OPTION_MSL_BIT, 639 SPVC_COMPILER_OPTION_MSL_FORCE_ACTIVE_ARGUMENT_BUFFER_RESOURCES = 50 | SPVC_COMPILER_OPTION_MSL_BIT, 640 SPVC_COMPILER_OPTION_MSL_FORCE_NATIVE_ARRAYS = 51 | SPVC_COMPILER_OPTION_MSL_BIT, 641 642 SPVC_COMPILER_OPTION_ENABLE_STORAGE_IMAGE_QUALIFIER_DEDUCTION = 52 | SPVC_COMPILER_OPTION_COMMON_BIT, 643 644 SPVC_COMPILER_OPTION_HLSL_FORCE_STORAGE_BUFFER_AS_UAV = 53 | SPVC_COMPILER_OPTION_HLSL_BIT, 645 646 SPVC_COMPILER_OPTION_FORCE_ZERO_INITIALIZED_VARIABLES = 54 | SPVC_COMPILER_OPTION_COMMON_BIT, 647 648 SPVC_COMPILER_OPTION_HLSL_NONWRITABLE_UAV_TEXTURE_AS_SRV = 55 | SPVC_COMPILER_OPTION_HLSL_BIT, 649 650 SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK = 56 | SPVC_COMPILER_OPTION_MSL_BIT, 651 SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN = 57 | SPVC_COMPILER_OPTION_MSL_BIT, 652 SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN = 58 | SPVC_COMPILER_OPTION_MSL_BIT, 653 SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING = 59 | SPVC_COMPILER_OPTION_MSL_BIT, 654 655 SPVC_COMPILER_OPTION_HLSL_ENABLE_16BIT_TYPES = 60 | SPVC_COMPILER_OPTION_HLSL_BIT, 656 657 SPVC_COMPILER_OPTION_MSL_MULTI_PATCH_WORKGROUP = 61 | SPVC_COMPILER_OPTION_MSL_BIT, 658 SPVC_COMPILER_OPTION_MSL_SHADER_INPUT_BUFFER_INDEX = 62 | SPVC_COMPILER_OPTION_MSL_BIT, 659 SPVC_COMPILER_OPTION_MSL_SHADER_INDEX_BUFFER_INDEX = 63 | SPVC_COMPILER_OPTION_MSL_BIT, 660 SPVC_COMPILER_OPTION_MSL_VERTEX_FOR_TESSELLATION = 64 | SPVC_COMPILER_OPTION_MSL_BIT, 661 SPVC_COMPILER_OPTION_MSL_VERTEX_INDEX_TYPE = 65 | SPVC_COMPILER_OPTION_MSL_BIT, 662 663 SPVC_COMPILER_OPTION_GLSL_FORCE_FLATTENED_IO_BLOCKS = 66 | SPVC_COMPILER_OPTION_GLSL_BIT, 664 665 SPVC_COMPILER_OPTION_MSL_MULTIVIEW_LAYERED_RENDERING = 67 | SPVC_COMPILER_OPTION_MSL_BIT, 666 SPVC_COMPILER_OPTION_MSL_ARRAYED_SUBPASS_INPUT = 68 | SPVC_COMPILER_OPTION_MSL_BIT, 667 SPVC_COMPILER_OPTION_MSL_R32UI_LINEAR_TEXTURE_ALIGNMENT = 69 | SPVC_COMPILER_OPTION_MSL_BIT, 668 SPVC_COMPILER_OPTION_MSL_R32UI_ALIGNMENT_CONSTANT_ID = 70 | SPVC_COMPILER_OPTION_MSL_BIT, 669 670 SPVC_COMPILER_OPTION_HLSL_FLATTEN_MATRIX_VERTEX_INPUT_SEMANTICS = 71 | SPVC_COMPILER_OPTION_HLSL_BIT, 671 672 SPVC_COMPILER_OPTION_MSL_IOS_USE_SIMDGROUP_FUNCTIONS = 72 | SPVC_COMPILER_OPTION_MSL_BIT, 673 SPVC_COMPILER_OPTION_MSL_EMULATE_SUBGROUPS = 73 | SPVC_COMPILER_OPTION_MSL_BIT, 674 SPVC_COMPILER_OPTION_MSL_FIXED_SUBGROUP_SIZE = 74 | SPVC_COMPILER_OPTION_MSL_BIT, 675 SPVC_COMPILER_OPTION_MSL_FORCE_SAMPLE_RATE_SHADING = 75 | SPVC_COMPILER_OPTION_MSL_BIT, 676 SPVC_COMPILER_OPTION_MSL_IOS_SUPPORT_BASE_VERTEX_INSTANCE = 76 | SPVC_COMPILER_OPTION_MSL_BIT, 677 678 SPVC_COMPILER_OPTION_GLSL_OVR_MULTIVIEW_VIEW_COUNT = 77 | SPVC_COMPILER_OPTION_GLSL_BIT, 679 680 SPVC_COMPILER_OPTION_INT_MAX = 0x7fffffff 681 } spvc_compiler_option; 682 683 /* 684 * Context is the highest-level API construct. 685 * The context owns all memory allocations made by its child object hierarchy, including various non-opaque structs and strings. 686 * This means that the API user only has to care about one "destroy" call ever when using the C API. 687 * All pointers handed out by the APIs are only valid as long as the context 688 * is alive and spvc_context_release_allocations has not been called. 689 */ 690 SPVC_PUBLIC_API spvc_result spvc_context_create(spvc_context *context); 691 692 /* Frees all memory allocations and objects associated with the context and its child objects. */ 693 SPVC_PUBLIC_API void spvc_context_destroy(spvc_context context); 694 695 /* Frees all memory allocations and objects associated with the context and its child objects, but keeps the context alive. */ 696 SPVC_PUBLIC_API void spvc_context_release_allocations(spvc_context context); 697 698 /* Get the string for the last error which was logged. */ 699 SPVC_PUBLIC_API const char *spvc_context_get_last_error_string(spvc_context context); 700 701 /* Get notified in a callback when an error triggers. Useful for debugging. */ 702 typedef void (*spvc_error_callback)(void *userdata, const char *error); 703 SPVC_PUBLIC_API void spvc_context_set_error_callback(spvc_context context, spvc_error_callback cb, void *userdata); 704 705 /* SPIR-V parsing interface. Maps to Parser which then creates a ParsedIR, and that IR is extracted into the handle. */ 706 SPVC_PUBLIC_API spvc_result spvc_context_parse_spirv(spvc_context context, const SpvId *spirv, size_t word_count, 707 spvc_parsed_ir *parsed_ir); 708 709 /* 710 * Create a compiler backend. Capture mode controls if we construct by copy or move semantics. 711 * It is always recommended to use SPVC_CAPTURE_MODE_TAKE_OWNERSHIP if you only intend to cross-compile the IR once. 712 */ 713 SPVC_PUBLIC_API spvc_result spvc_context_create_compiler(spvc_context context, spvc_backend backend, 714 spvc_parsed_ir parsed_ir, spvc_capture_mode mode, 715 spvc_compiler *compiler); 716 717 /* Maps directly to C++ API. */ 718 SPVC_PUBLIC_API unsigned spvc_compiler_get_current_id_bound(spvc_compiler compiler); 719 720 /* Create compiler options, which will initialize defaults. */ 721 SPVC_PUBLIC_API spvc_result spvc_compiler_create_compiler_options(spvc_compiler compiler, 722 spvc_compiler_options *options); 723 /* Override options. Will return error if e.g. MSL options are used for the HLSL backend, etc. */ 724 SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_bool(spvc_compiler_options options, 725 spvc_compiler_option option, spvc_bool value); 726 SPVC_PUBLIC_API spvc_result spvc_compiler_options_set_uint(spvc_compiler_options options, 727 spvc_compiler_option option, unsigned value); 728 /* Set compiler options. */ 729 SPVC_PUBLIC_API spvc_result spvc_compiler_install_compiler_options(spvc_compiler compiler, 730 spvc_compiler_options options); 731 732 /* Compile IR into a string. *source is owned by the context, and caller must not free it themselves. */ 733 SPVC_PUBLIC_API spvc_result spvc_compiler_compile(spvc_compiler compiler, const char **source); 734 735 /* Maps to C++ API. */ 736 SPVC_PUBLIC_API spvc_result spvc_compiler_add_header_line(spvc_compiler compiler, const char *line); 737 SPVC_PUBLIC_API spvc_result spvc_compiler_require_extension(spvc_compiler compiler, const char *ext); 738 SPVC_PUBLIC_API spvc_result spvc_compiler_flatten_buffer_block(spvc_compiler compiler, spvc_variable_id id); 739 740 SPVC_PUBLIC_API spvc_bool spvc_compiler_variable_is_depth_or_compare(spvc_compiler compiler, spvc_variable_id id); 741 742 SPVC_PUBLIC_API spvc_result spvc_compiler_mask_stage_output_by_location(spvc_compiler compiler, 743 unsigned location, unsigned component); 744 SPVC_PUBLIC_API spvc_result spvc_compiler_mask_stage_output_by_builtin(spvc_compiler compiler, SpvBuiltIn builtin); 745 746 /* 747 * HLSL specifics. 748 * Maps to C++ API. 749 */ 750 SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_root_constants_layout(spvc_compiler compiler, 751 const spvc_hlsl_root_constants *constant_info, 752 size_t count); 753 SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_vertex_attribute_remap(spvc_compiler compiler, 754 const spvc_hlsl_vertex_attribute_remap *remap, 755 size_t remaps); 756 SPVC_PUBLIC_API spvc_variable_id spvc_compiler_hlsl_remap_num_workgroups_builtin(spvc_compiler compiler); 757 758 SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_set_resource_binding_flags(spvc_compiler compiler, 759 spvc_hlsl_binding_flags flags); 760 761 SPVC_PUBLIC_API spvc_result spvc_compiler_hlsl_add_resource_binding(spvc_compiler compiler, 762 const spvc_hlsl_resource_binding *binding); 763 SPVC_PUBLIC_API spvc_bool spvc_compiler_hlsl_is_resource_used(spvc_compiler compiler, 764 SpvExecutionModel model, 765 unsigned set, 766 unsigned binding); 767 768 /* 769 * MSL specifics. 770 * Maps to C++ API. 771 */ 772 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_rasterization_disabled(spvc_compiler compiler); 773 774 /* Obsolete. Renamed to needs_swizzle_buffer. */ 775 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_aux_buffer(spvc_compiler compiler); 776 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_swizzle_buffer(spvc_compiler compiler); 777 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_buffer_size_buffer(spvc_compiler compiler); 778 779 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_output_buffer(spvc_compiler compiler); 780 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_patch_output_buffer(spvc_compiler compiler); 781 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_needs_input_threadgroup_mem(spvc_compiler compiler); 782 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_vertex_attribute(spvc_compiler compiler, 783 const spvc_msl_vertex_attribute *attrs); 784 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_resource_binding(spvc_compiler compiler, 785 const spvc_msl_resource_binding *binding); 786 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_shader_input(spvc_compiler compiler, 787 const spvc_msl_shader_input *input); 788 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_discrete_descriptor_set(spvc_compiler compiler, unsigned desc_set); 789 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_argument_buffer_device_address_space(spvc_compiler compiler, unsigned desc_set, spvc_bool device_address); 790 791 /* Obsolete, use is_shader_input_used. */ 792 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_vertex_attribute_used(spvc_compiler compiler, unsigned location); 793 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_shader_input_used(spvc_compiler compiler, unsigned location); 794 795 SPVC_PUBLIC_API spvc_bool spvc_compiler_msl_is_resource_used(spvc_compiler compiler, 796 SpvExecutionModel model, 797 unsigned set, 798 unsigned binding); 799 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler); 800 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler); 801 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_ycbcr(spvc_compiler compiler, spvc_variable_id id, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv); 802 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_remap_constexpr_sampler_by_binding_ycbcr(spvc_compiler compiler, unsigned desc_set, unsigned binding, const spvc_msl_constexpr_sampler *sampler, const spvc_msl_sampler_ycbcr_conversion *conv); 803 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_fragment_output_components(spvc_compiler compiler, unsigned location, unsigned components); 804 805 SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding(spvc_compiler compiler, spvc_variable_id id); 806 SPVC_PUBLIC_API unsigned spvc_compiler_msl_get_automatic_resource_binding_secondary(spvc_compiler compiler, spvc_variable_id id); 807 808 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_dynamic_buffer(spvc_compiler compiler, unsigned desc_set, unsigned binding, unsigned index); 809 810 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_add_inline_uniform_block(spvc_compiler compiler, unsigned desc_set, unsigned binding); 811 812 SPVC_PUBLIC_API spvc_result spvc_compiler_msl_set_combined_sampler_suffix(spvc_compiler compiler, const char *suffix); 813 SPVC_PUBLIC_API const char *spvc_compiler_msl_get_combined_sampler_suffix(spvc_compiler compiler); 814 815 /* 816 * Reflect resources. 817 * Maps almost 1:1 to C++ API. 818 */ 819 SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_interface_variables(spvc_compiler compiler, spvc_set *set); 820 SPVC_PUBLIC_API spvc_result spvc_compiler_set_enabled_interface_variables(spvc_compiler compiler, spvc_set set); 821 SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources(spvc_compiler compiler, spvc_resources *resources); 822 SPVC_PUBLIC_API spvc_result spvc_compiler_create_shader_resources_for_active_variables(spvc_compiler compiler, 823 spvc_resources *resources, 824 spvc_set active); 825 SPVC_PUBLIC_API spvc_result spvc_resources_get_resource_list_for_type(spvc_resources resources, spvc_resource_type type, 826 const spvc_reflected_resource **resource_list, 827 size_t *resource_size); 828 829 SPVC_PUBLIC_API spvc_result spvc_resources_get_builtin_resource_list_for_type( 830 spvc_resources resources, spvc_builtin_resource_type type, 831 const spvc_reflected_builtin_resource **resource_list, 832 size_t *resource_size); 833 834 /* 835 * Decorations. 836 * Maps to C++ API. 837 */ 838 SPVC_PUBLIC_API void spvc_compiler_set_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration, 839 unsigned argument); 840 SPVC_PUBLIC_API void spvc_compiler_set_decoration_string(spvc_compiler compiler, SpvId id, SpvDecoration decoration, 841 const char *argument); 842 SPVC_PUBLIC_API void spvc_compiler_set_name(spvc_compiler compiler, SpvId id, const char *argument); 843 SPVC_PUBLIC_API void spvc_compiler_set_member_decoration(spvc_compiler compiler, spvc_type_id id, unsigned member_index, 844 SpvDecoration decoration, unsigned argument); 845 SPVC_PUBLIC_API void spvc_compiler_set_member_decoration_string(spvc_compiler compiler, spvc_type_id id, 846 unsigned member_index, SpvDecoration decoration, 847 const char *argument); 848 SPVC_PUBLIC_API void spvc_compiler_set_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index, 849 const char *argument); 850 SPVC_PUBLIC_API void spvc_compiler_unset_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); 851 SPVC_PUBLIC_API void spvc_compiler_unset_member_decoration(spvc_compiler compiler, spvc_type_id id, 852 unsigned member_index, SpvDecoration decoration); 853 854 SPVC_PUBLIC_API spvc_bool spvc_compiler_has_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); 855 SPVC_PUBLIC_API spvc_bool spvc_compiler_has_member_decoration(spvc_compiler compiler, spvc_type_id id, 856 unsigned member_index, SpvDecoration decoration); 857 SPVC_PUBLIC_API const char *spvc_compiler_get_name(spvc_compiler compiler, SpvId id); 858 SPVC_PUBLIC_API unsigned spvc_compiler_get_decoration(spvc_compiler compiler, SpvId id, SpvDecoration decoration); 859 SPVC_PUBLIC_API const char *spvc_compiler_get_decoration_string(spvc_compiler compiler, SpvId id, 860 SpvDecoration decoration); 861 SPVC_PUBLIC_API unsigned spvc_compiler_get_member_decoration(spvc_compiler compiler, spvc_type_id id, 862 unsigned member_index, SpvDecoration decoration); 863 SPVC_PUBLIC_API const char *spvc_compiler_get_member_decoration_string(spvc_compiler compiler, spvc_type_id id, 864 unsigned member_index, SpvDecoration decoration); 865 SPVC_PUBLIC_API const char *spvc_compiler_get_member_name(spvc_compiler compiler, spvc_type_id id, unsigned member_index); 866 867 /* 868 * Entry points. 869 * Maps to C++ API. 870 */ 871 SPVC_PUBLIC_API spvc_result spvc_compiler_get_entry_points(spvc_compiler compiler, 872 const spvc_entry_point **entry_points, 873 size_t *num_entry_points); 874 SPVC_PUBLIC_API spvc_result spvc_compiler_set_entry_point(spvc_compiler compiler, const char *name, 875 SpvExecutionModel model); 876 SPVC_PUBLIC_API spvc_result spvc_compiler_rename_entry_point(spvc_compiler compiler, const char *old_name, 877 const char *new_name, SpvExecutionModel model); 878 SPVC_PUBLIC_API const char *spvc_compiler_get_cleansed_entry_point_name(spvc_compiler compiler, const char *name, 879 SpvExecutionModel model); 880 SPVC_PUBLIC_API void spvc_compiler_set_execution_mode(spvc_compiler compiler, SpvExecutionMode mode); 881 SPVC_PUBLIC_API void spvc_compiler_unset_execution_mode(spvc_compiler compiler, SpvExecutionMode mode); 882 SPVC_PUBLIC_API void spvc_compiler_set_execution_mode_with_arguments(spvc_compiler compiler, SpvExecutionMode mode, 883 unsigned arg0, unsigned arg1, unsigned arg2); 884 SPVC_PUBLIC_API spvc_result spvc_compiler_get_execution_modes(spvc_compiler compiler, const SpvExecutionMode **modes, 885 size_t *num_modes); 886 SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument(spvc_compiler compiler, SpvExecutionMode mode); 887 SPVC_PUBLIC_API unsigned spvc_compiler_get_execution_mode_argument_by_index(spvc_compiler compiler, 888 SpvExecutionMode mode, unsigned index); 889 SPVC_PUBLIC_API SpvExecutionModel spvc_compiler_get_execution_model(spvc_compiler compiler); 890 SPVC_PUBLIC_API void spvc_compiler_update_active_builtins(spvc_compiler compiler); 891 SPVC_PUBLIC_API spvc_bool spvc_compiler_has_active_builtin(spvc_compiler compiler, SpvBuiltIn builtin, SpvStorageClass storage); 892 893 /* 894 * Type query interface. 895 * Maps to C++ API, except it's read-only. 896 */ 897 SPVC_PUBLIC_API spvc_type spvc_compiler_get_type_handle(spvc_compiler compiler, spvc_type_id id); 898 899 /* Pulls out SPIRType::self. This effectively gives the type ID without array or pointer qualifiers. 900 * This is necessary when reflecting decoration/name information on members of a struct, 901 * which are placed in the base type, not the qualified type. 902 * This is similar to spvc_reflected_resource::base_type_id. */ 903 SPVC_PUBLIC_API spvc_type_id spvc_type_get_base_type_id(spvc_type type); 904 905 SPVC_PUBLIC_API spvc_basetype spvc_type_get_basetype(spvc_type type); 906 SPVC_PUBLIC_API unsigned spvc_type_get_bit_width(spvc_type type); 907 SPVC_PUBLIC_API unsigned spvc_type_get_vector_size(spvc_type type); 908 SPVC_PUBLIC_API unsigned spvc_type_get_columns(spvc_type type); 909 SPVC_PUBLIC_API unsigned spvc_type_get_num_array_dimensions(spvc_type type); 910 SPVC_PUBLIC_API spvc_bool spvc_type_array_dimension_is_literal(spvc_type type, unsigned dimension); 911 SPVC_PUBLIC_API SpvId spvc_type_get_array_dimension(spvc_type type, unsigned dimension); 912 SPVC_PUBLIC_API unsigned spvc_type_get_num_member_types(spvc_type type); 913 SPVC_PUBLIC_API spvc_type_id spvc_type_get_member_type(spvc_type type, unsigned index); 914 SPVC_PUBLIC_API SpvStorageClass spvc_type_get_storage_class(spvc_type type); 915 916 /* Image type query. */ 917 SPVC_PUBLIC_API spvc_type_id spvc_type_get_image_sampled_type(spvc_type type); 918 SPVC_PUBLIC_API SpvDim spvc_type_get_image_dimension(spvc_type type); 919 SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_depth(spvc_type type); 920 SPVC_PUBLIC_API spvc_bool spvc_type_get_image_arrayed(spvc_type type); 921 SPVC_PUBLIC_API spvc_bool spvc_type_get_image_multisampled(spvc_type type); 922 SPVC_PUBLIC_API spvc_bool spvc_type_get_image_is_storage(spvc_type type); 923 SPVC_PUBLIC_API SpvImageFormat spvc_type_get_image_storage_format(spvc_type type); 924 SPVC_PUBLIC_API SpvAccessQualifier spvc_type_get_image_access_qualifier(spvc_type type); 925 926 /* 927 * Buffer layout query. 928 * Maps to C++ API. 929 */ 930 SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size(spvc_compiler compiler, spvc_type struct_type, size_t *size); 931 SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_size_runtime_array(spvc_compiler compiler, 932 spvc_type struct_type, size_t array_size, size_t *size); 933 SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_struct_member_size(spvc_compiler compiler, spvc_type type, unsigned index, size_t *size); 934 935 SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_offset(spvc_compiler compiler, 936 spvc_type type, unsigned index, unsigned *offset); 937 SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_array_stride(spvc_compiler compiler, 938 spvc_type type, unsigned index, unsigned *stride); 939 SPVC_PUBLIC_API spvc_result spvc_compiler_type_struct_member_matrix_stride(spvc_compiler compiler, 940 spvc_type type, unsigned index, unsigned *stride); 941 942 /* 943 * Workaround helper functions. 944 * Maps to C++ API. 945 */ 946 SPVC_PUBLIC_API spvc_result spvc_compiler_build_dummy_sampler_for_combined_images(spvc_compiler compiler, spvc_variable_id *id); 947 SPVC_PUBLIC_API spvc_result spvc_compiler_build_combined_image_samplers(spvc_compiler compiler); 948 SPVC_PUBLIC_API spvc_result spvc_compiler_get_combined_image_samplers(spvc_compiler compiler, 949 const spvc_combined_image_sampler **samplers, 950 size_t *num_samplers); 951 952 /* 953 * Constants 954 * Maps to C++ API. 955 */ 956 SPVC_PUBLIC_API spvc_result spvc_compiler_get_specialization_constants(spvc_compiler compiler, 957 const spvc_specialization_constant **constants, 958 size_t *num_constants); 959 SPVC_PUBLIC_API spvc_constant spvc_compiler_get_constant_handle(spvc_compiler compiler, 960 spvc_constant_id id); 961 962 SPVC_PUBLIC_API spvc_constant_id spvc_compiler_get_work_group_size_specialization_constants(spvc_compiler compiler, 963 spvc_specialization_constant *x, 964 spvc_specialization_constant *y, 965 spvc_specialization_constant *z); 966 967 /* 968 * Buffer ranges 969 * Maps to C++ API. 970 */ 971 SPVC_PUBLIC_API spvc_result spvc_compiler_get_active_buffer_ranges(spvc_compiler compiler, 972 spvc_variable_id id, 973 const spvc_buffer_range **ranges, 974 size_t *num_ranges); 975 976 /* 977 * No stdint.h until C99, sigh :( 978 * For smaller types, the result is sign or zero-extended as appropriate. 979 * Maps to C++ API. 980 * TODO: The SPIRConstant query interface and modification interface is not quite complete. 981 */ 982 SPVC_PUBLIC_API float spvc_constant_get_scalar_fp16(spvc_constant constant, unsigned column, unsigned row); 983 SPVC_PUBLIC_API float spvc_constant_get_scalar_fp32(spvc_constant constant, unsigned column, unsigned row); 984 SPVC_PUBLIC_API double spvc_constant_get_scalar_fp64(spvc_constant constant, unsigned column, unsigned row); 985 SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u32(spvc_constant constant, unsigned column, unsigned row); 986 SPVC_PUBLIC_API int spvc_constant_get_scalar_i32(spvc_constant constant, unsigned column, unsigned row); 987 SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u16(spvc_constant constant, unsigned column, unsigned row); 988 SPVC_PUBLIC_API int spvc_constant_get_scalar_i16(spvc_constant constant, unsigned column, unsigned row); 989 SPVC_PUBLIC_API unsigned spvc_constant_get_scalar_u8(spvc_constant constant, unsigned column, unsigned row); 990 SPVC_PUBLIC_API int spvc_constant_get_scalar_i8(spvc_constant constant, unsigned column, unsigned row); 991 SPVC_PUBLIC_API void spvc_constant_get_subconstants(spvc_constant constant, const spvc_constant_id **constituents, size_t *count); 992 SPVC_PUBLIC_API spvc_type_id spvc_constant_get_type(spvc_constant constant); 993 994 /* 995 * Misc reflection 996 * Maps to C++ API. 997 */ 998 SPVC_PUBLIC_API spvc_bool spvc_compiler_get_binary_offset_for_decoration(spvc_compiler compiler, 999 spvc_variable_id id, 1000 SpvDecoration decoration, 1001 unsigned *word_offset); 1002 1003 SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_is_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id); 1004 SPVC_PUBLIC_API spvc_bool spvc_compiler_buffer_get_hlsl_counter_buffer(spvc_compiler compiler, spvc_variable_id id, 1005 spvc_variable_id *counter_id); 1006 1007 SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_capabilities(spvc_compiler compiler, 1008 const SpvCapability **capabilities, 1009 size_t *num_capabilities); 1010 SPVC_PUBLIC_API spvc_result spvc_compiler_get_declared_extensions(spvc_compiler compiler, const char ***extensions, 1011 size_t *num_extensions); 1012 1013 SPVC_PUBLIC_API const char *spvc_compiler_get_remapped_declared_block_name(spvc_compiler compiler, spvc_variable_id id); 1014 SPVC_PUBLIC_API spvc_result spvc_compiler_get_buffer_block_decorations(spvc_compiler compiler, spvc_variable_id id, 1015 const SpvDecoration **decorations, 1016 size_t *num_decorations); 1017 1018 #ifdef __cplusplus 1019 } 1020 #endif 1021 #endif 1022