1 /++ 2 + Machine generated D bindings for Sokol library. 3 + 4 + Generated on: 2025-06-15 12:55:08 5 + 6 + Source header: sokol_gfx.h 7 + Module: sokol.gfx 8 + 9 + Do not edit manually; regenerate using gen_d.py. 10 +/ 11 module sokol.gfx; 12 13 /++ 14 + Resource id typedefs: 15 + 16 + sg_buffer: vertex- and index-buffers 17 + sg_image: images used as textures and render-pass attachments 18 + sg_sampler sampler objects describing how a texture is sampled in a shader 19 + sg_shader: vertex- and fragment-shaders and shader interface information 20 + sg_pipeline: associated shader and vertex-layouts, and render states 21 + sg_attachments: a baked collection of render pass attachment images 22 + 23 + Instead of pointers, resource creation functions return a 32-bit 24 + handle which uniquely identifies the resource object. 25 + 26 + The 32-bit resource id is split into a 16-bit pool index in the lower bits, 27 + and a 16-bit 'generation counter' in the upper bits. The index allows fast 28 + pool lookups, and combined with the generation-counter it allows to detect 29 + 'dangling accesses' (trying to use an object which no longer exists, and 30 + its pool slot has been reused for a new object) 31 + 32 + The resource ids are wrapped into a strongly-typed struct so that 33 + trying to pass an incompatible resource id is a compile error. 34 +/ 35 extern(C) struct Buffer { 36 uint id = 0; 37 } 38 extern(C) struct Image { 39 uint id = 0; 40 } 41 extern(C) struct Sampler { 42 uint id = 0; 43 } 44 extern(C) struct Shader { 45 uint id = 0; 46 } 47 extern(C) struct Pipeline { 48 uint id = 0; 49 } 50 extern(C) struct Attachments { 51 uint id = 0; 52 } 53 /++ 54 + sg_range is a pointer-size-pair struct used to pass memory blobs into 55 + sokol-gfx. When initialized from a value type (array or struct), you can 56 + use the SG_RANGE() macro to build an sg_range struct. For functions which 57 + take either a sg_range pointer, or a (C++) sg_range reference, use the 58 + SG_RANGE_REF macro as a solution which compiles both in C and C++. 59 +/ 60 extern(C) struct Range { 61 const(void)* ptr = null; 62 size_t size = 0; 63 } 64 /++ 65 + various compile-time constants in the public API 66 +/ 67 enum invalid_id = 0; 68 enum num_inflight_frames = 2; 69 enum max_color_attachments = 4; 70 enum max_storage_attachments = 4; 71 enum max_uniformblock_members = 16; 72 enum max_vertex_attributes = 16; 73 enum max_mipmaps = 16; 74 enum max_texturearray_layers = 128; 75 enum max_uniformblock_bindslots = 8; 76 enum max_vertexbuffer_bindslots = 8; 77 enum max_image_bindslots = 16; 78 enum max_sampler_bindslots = 16; 79 enum max_storagebuffer_bindslots = 8; 80 enum max_image_sampler_pairs = 16; 81 /++ 82 + sg_color 83 + 84 + An RGBA color value. 85 +/ 86 extern(C) struct Color { 87 float r = 0.0f; 88 float g = 0.0f; 89 float b = 0.0f; 90 float a = 0.0f; 91 } 92 /++ 93 + sg_backend 94 + 95 + The active 3D-API backend, use the function sg_query_backend() 96 + to get the currently active backend. 97 +/ 98 enum Backend { 99 Glcore, 100 Gles3, 101 D3d11, 102 Metal_ios, 103 Metal_macos, 104 Metal_simulator, 105 Wgpu, 106 Dummy, 107 } 108 /++ 109 + sg_pixel_format 110 + 111 + sokol_gfx.h basically uses the same pixel formats as WebGPU, since these 112 + are supported on most newer GPUs. 113 + 114 + A pixelformat name consist of three parts: 115 + 116 + - components (R, RG, RGB or RGBA) 117 + - bit width per component (8, 16 or 32) 118 + - component data type: 119 + - unsigned normalized (no postfix) 120 + - signed normalized (SN postfix) 121 + - unsigned integer (UI postfix) 122 + - signed integer (SI postfix) 123 + - float (F postfix) 124 + 125 + Not all pixel formats can be used for everything, call sg_query_pixelformat() 126 + to inspect the capabilities of a given pixelformat. The function returns 127 + an sg_pixelformat_info struct with the following members: 128 + 129 + - sample: the pixelformat can be sampled as texture at least with 130 + nearest filtering 131 + - filter: the pixelformat can be sampled as texture with linear 132 + filtering 133 + - render: the pixelformat can be used as render-pass attachment 134 + - blend: blending is supported when used as render-pass attachment 135 + - msaa: multisample-antialiasing is supported when used 136 + as render-pass attachment 137 + - depth: the pixelformat can be used for depth-stencil attachments 138 + - compressed: this is a block-compressed format 139 + - bytes_per_pixel: the numbers of bytes in a pixel (0 for compressed formats) 140 + 141 + The default pixel format for texture images is SG_PIXELFORMAT_RGBA8. 142 + 143 + The default pixel format for render target images is platform-dependent 144 + and taken from the sg_environment struct passed into sg_setup(). Typically 145 + the default formats are: 146 + 147 + - for the Metal, D3D11 and WebGPU backends: SG_PIXELFORMAT_BGRA8 148 + - for GL backends: SG_PIXELFORMAT_RGBA8 149 +/ 150 enum PixelFormat { 151 Default, 152 None, 153 R8, 154 R8sn, 155 R8ui, 156 R8si, 157 R16, 158 R16sn, 159 R16ui, 160 R16si, 161 R16f, 162 Rg8, 163 Rg8sn, 164 Rg8ui, 165 Rg8si, 166 R32ui, 167 R32si, 168 R32f, 169 Rg16, 170 Rg16sn, 171 Rg16ui, 172 Rg16si, 173 Rg16f, 174 Rgba8, 175 Srgb8a8, 176 Rgba8sn, 177 Rgba8ui, 178 Rgba8si, 179 Bgra8, 180 Rgb10a2, 181 Rg11b10f, 182 Rgb9e5, 183 Rg32ui, 184 Rg32si, 185 Rg32f, 186 Rgba16, 187 Rgba16sn, 188 Rgba16ui, 189 Rgba16si, 190 Rgba16f, 191 Rgba32ui, 192 Rgba32si, 193 Rgba32f, 194 Depth, 195 Depth_stencil, 196 Bc1_rgba, 197 Bc2_rgba, 198 Bc3_rgba, 199 Bc3_srgba, 200 Bc4_r, 201 Bc4_rsn, 202 Bc5_rg, 203 Bc5_rgsn, 204 Bc6h_rgbf, 205 Bc6h_rgbuf, 206 Bc7_rgba, 207 Bc7_srgba, 208 Etc2_rgb8, 209 Etc2_srgb8, 210 Etc2_rgb8a1, 211 Etc2_rgba8, 212 Etc2_srgb8a8, 213 Eac_r11, 214 Eac_r11sn, 215 Eac_rg11, 216 Eac_rg11sn, 217 Astc_4x4_rgba, 218 Astc_4x4_srgba, 219 Num, 220 } 221 /++ 222 + Runtime information about a pixel format, returned by sg_query_pixelformat(). 223 +/ 224 extern(C) struct PixelformatInfo { 225 bool sample = false; 226 bool filter = false; 227 bool render = false; 228 bool blend = false; 229 bool msaa = false; 230 bool depth = false; 231 bool compressed = false; 232 bool read = false; 233 bool write = false; 234 int bytes_per_pixel = 0; 235 } 236 /++ 237 + Runtime information about available optional features, returned by sg_query_features() 238 +/ 239 extern(C) struct Features { 240 bool origin_top_left = false; 241 bool image_clamp_to_border = false; 242 bool mrt_independent_blend_state = false; 243 bool mrt_independent_write_mask = false; 244 bool compute = false; 245 bool msaa_image_bindings = false; 246 bool separate_buffer_types = false; 247 } 248 /++ 249 + Runtime information about resource limits, returned by sg_query_limit() 250 +/ 251 extern(C) struct Limits { 252 int max_image_size_2d = 0; 253 int max_image_size_cube = 0; 254 int max_image_size_3d = 0; 255 int max_image_size_array = 0; 256 int max_image_array_layers = 0; 257 int max_vertex_attrs = 0; 258 int gl_max_vertex_uniform_components = 0; 259 int gl_max_combined_texture_image_units = 0; 260 } 261 /++ 262 + sg_resource_state 263 + 264 + The current state of a resource in its resource pool. 265 + Resources start in the INITIAL state, which means the 266 + pool slot is unoccupied and can be allocated. When a resource is 267 + created, first an id is allocated, and the resource pool slot 268 + is set to state ALLOC. After allocation, the resource is 269 + initialized, which may result in the VALID or FAILED state. The 270 + reason why allocation and initialization are separate is because 271 + some resource types (e.g. buffers and images) might be asynchronously 272 + initialized by the user application. If a resource which is not 273 + in the VALID state is attempted to be used for rendering, rendering 274 + operations will silently be dropped. 275 + 276 + The special INVALID state is returned in sg_query_xxx_state() if no 277 + resource object exists for the provided resource id. 278 +/ 279 enum ResourceState { 280 Initial, 281 Alloc, 282 Valid, 283 Failed, 284 Invalid, 285 } 286 /++ 287 + sg_index_type 288 + 289 + Indicates whether indexed rendering (fetching vertex-indices from an 290 + index buffer) is used, and if yes, the index data type (16- or 32-bits). 291 + 292 + This is used in the sg_pipeline_desc.index_type member when creating a 293 + pipeline object. 294 + 295 + The default index type is SG_INDEXTYPE_NONE. 296 +/ 297 enum IndexType { 298 Default, 299 None, 300 Uint16, 301 Uint32, 302 Num, 303 } 304 /++ 305 + sg_image_type 306 + 307 + Indicates the basic type of an image object (2D-texture, cubemap, 308 + 3D-texture or 2D-array-texture). Used in the sg_image_desc.type member when 309 + creating an image, and in sg_shader_image_desc to describe a sampled texture 310 + in the shader (both must match and will be checked in the validation layer 311 + when calling sg_apply_bindings). 312 + 313 + The default image type when creating an image is SG_IMAGETYPE_2D. 314 +/ 315 enum ImageType { 316 Default, 317 _2d, 318 Cube, 319 _3d, 320 Array, 321 Num, 322 } 323 /++ 324 + sg_image_sample_type 325 + 326 + The basic data type of a texture sample as expected by a shader. 327 + Must be provided in sg_shader_image and used by the validation 328 + layer in sg_apply_bindings() to check if the provided image object 329 + is compatible with what the shader expects. Apart from the sokol-gfx 330 + validation layer, WebGPU is the only backend API which actually requires 331 + matching texture and sampler type to be provided upfront for validation 332 + (other 3D APIs treat texture/sampler type mismatches as undefined behaviour). 333 + 334 + NOTE that the following texture pixel formats require the use 335 + of SG_IMAGESAMPLETYPE_UNFILTERABLE_FLOAT, combined with a sampler 336 + of type SG_SAMPLERTYPE_NONFILTERING: 337 + 338 + - SG_PIXELFORMAT_R32F 339 + - SG_PIXELFORMAT_RG32F 340 + - SG_PIXELFORMAT_RGBA32F 341 + 342 + (when using sokol-shdc, also check out the meta tags `@image_sample_type` 343 + and `@sampler_type`) 344 +/ 345 enum ImageSampleType { 346 Default, 347 Float, 348 Depth, 349 Sint, 350 Uint, 351 Unfilterable_float, 352 Num, 353 } 354 /++ 355 + sg_sampler_type 356 + 357 + The basic type of a texture sampler (sampling vs comparison) as 358 + defined in a shader. Must be provided in sg_shader_sampler_desc. 359 + 360 + sg_image_sample_type and sg_sampler_type for a texture/sampler 361 + pair must be compatible with each other, specifically only 362 + the following pairs are allowed: 363 + 364 + - SG_IMAGESAMPLETYPE_FLOAT => (SG_SAMPLERTYPE_FILTERING or SG_SAMPLERTYPE_NONFILTERING) 365 + - SG_IMAGESAMPLETYPE_UNFILTERABLE_FLOAT => SG_SAMPLERTYPE_NONFILTERING 366 + - SG_IMAGESAMPLETYPE_SINT => SG_SAMPLERTYPE_NONFILTERING 367 + - SG_IMAGESAMPLETYPE_UINT => SG_SAMPLERTYPE_NONFILTERING 368 + - SG_IMAGESAMPLETYPE_DEPTH => SG_SAMPLERTYPE_COMPARISON 369 +/ 370 enum SamplerType { 371 Default, 372 Filtering, 373 Nonfiltering, 374 Comparison, 375 Num, 376 } 377 /++ 378 + sg_cube_face 379 + 380 + The cubemap faces. Use these as indices in the sg_image_desc.content 381 + array. 382 +/ 383 enum CubeFace { 384 Pos_x, 385 Neg_x, 386 Pos_y, 387 Neg_y, 388 Pos_z, 389 Neg_z, 390 Num, 391 } 392 /++ 393 + sg_primitive_type 394 + 395 + This is the common subset of 3D primitive types supported across all 3D 396 + APIs. This is used in the sg_pipeline_desc.primitive_type member when 397 + creating a pipeline object. 398 + 399 + The default primitive type is SG_PRIMITIVETYPE_TRIANGLES. 400 +/ 401 enum PrimitiveType { 402 Default, 403 Points, 404 Lines, 405 Line_strip, 406 Triangles, 407 Triangle_strip, 408 Num, 409 } 410 /++ 411 + sg_filter 412 + 413 + The filtering mode when sampling a texture image. This is 414 + used in the sg_sampler_desc.min_filter, sg_sampler_desc.mag_filter 415 + and sg_sampler_desc.mipmap_filter members when creating a sampler object. 416 + 417 + For the default is SG_FILTER_NEAREST. 418 +/ 419 enum Filter { 420 Default, 421 Nearest, 422 Linear, 423 Num, 424 } 425 /++ 426 + sg_wrap 427 + 428 + The texture coordinates wrapping mode when sampling a texture 429 + image. This is used in the sg_image_desc.wrap_u, .wrap_v 430 + and .wrap_w members when creating an image. 431 + 432 + The default wrap mode is SG_WRAP_REPEAT. 433 + 434 + NOTE: SG_WRAP_CLAMP_TO_BORDER is not supported on all backends 435 + and platforms. To check for support, call sg_query_features() 436 + and check the "clamp_to_border" boolean in the returned 437 + sg_features struct. 438 + 439 + Platforms which don't support SG_WRAP_CLAMP_TO_BORDER will silently fall back 440 + to SG_WRAP_CLAMP_TO_EDGE without a validation error. 441 +/ 442 enum Wrap { 443 Default, 444 Repeat, 445 Clamp_to_edge, 446 Clamp_to_border, 447 Mirrored_repeat, 448 Num, 449 } 450 /++ 451 + sg_border_color 452 + 453 + The border color to use when sampling a texture, and the UV wrap 454 + mode is SG_WRAP_CLAMP_TO_BORDER. 455 + 456 + The default border color is SG_BORDERCOLOR_OPAQUE_BLACK 457 +/ 458 enum BorderColor { 459 Default, 460 Transparent_black, 461 Opaque_black, 462 Opaque_white, 463 Num, 464 } 465 /++ 466 + sg_vertex_format 467 + 468 + The data type of a vertex component. This is used to describe 469 + the layout of input vertex data when creating a pipeline object. 470 + 471 + NOTE that specific mapping rules exist from the CPU-side vertex 472 + formats to the vertex attribute base type in the vertex shader code 473 + (see doc header section 'ON VERTEX FORMATS'). 474 +/ 475 enum VertexFormat { 476 Invalid, 477 Float, 478 Float2, 479 Float3, 480 Float4, 481 Int, 482 Int2, 483 Int3, 484 Int4, 485 Uint, 486 Uint2, 487 Uint3, 488 Uint4, 489 Byte4, 490 Byte4n, 491 Ubyte4, 492 Ubyte4n, 493 Short2, 494 Short2n, 495 Ushort2, 496 Ushort2n, 497 Short4, 498 Short4n, 499 Ushort4, 500 Ushort4n, 501 Uint10_n2, 502 Half2, 503 Half4, 504 Num, 505 } 506 /++ 507 + sg_vertex_step 508 + 509 + Defines whether the input pointer of a vertex input stream is advanced 510 + 'per vertex' or 'per instance'. The default step-func is 511 + SG_VERTEXSTEP_PER_VERTEX. SG_VERTEXSTEP_PER_INSTANCE is used with 512 + instanced-rendering. 513 + 514 + The vertex-step is part of the vertex-layout definition 515 + when creating pipeline objects. 516 +/ 517 enum VertexStep { 518 Default, 519 Per_vertex, 520 Per_instance, 521 Num, 522 } 523 /++ 524 + sg_uniform_type 525 + 526 + The data type of a uniform block member. This is used to 527 + describe the internal layout of uniform blocks when creating 528 + a shader object. This is only required for the GL backend, all 529 + other backends will ignore the interior layout of uniform blocks. 530 +/ 531 enum UniformType { 532 Invalid, 533 Float, 534 Float2, 535 Float3, 536 Float4, 537 Int, 538 Int2, 539 Int3, 540 Int4, 541 Mat4, 542 Num, 543 } 544 /++ 545 + sg_uniform_layout 546 + 547 + A hint for the interior memory layout of uniform blocks. This is 548 + only relevant for the GL backend where the internal layout 549 + of uniform blocks must be known to sokol-gfx. For all other backends the 550 + internal memory layout of uniform blocks doesn't matter, sokol-gfx 551 + will just pass uniform data as an opaque memory blob to the 552 + 3D backend. 553 + 554 + SG_UNIFORMLAYOUT_NATIVE (default) 555 + Native layout means that a 'backend-native' memory layout 556 + is used. For the GL backend this means that uniforms 557 + are packed tightly in memory (e.g. there are no padding 558 + bytes). 559 + 560 + SG_UNIFORMLAYOUT_STD140 561 + The memory layout is a subset of std140. Arrays are only 562 + allowed for the FLOAT4, INT4 and MAT4. Alignment is as 563 + is as follows: 564 + 565 + FLOAT, INT: 4 byte alignment 566 + FLOAT2, INT2: 8 byte alignment 567 + FLOAT3, INT3: 16 byte alignment(!) 568 + FLOAT4, INT4: 16 byte alignment 569 + MAT4: 16 byte alignment 570 + FLOAT4[], INT4[]: 16 byte alignment 571 + 572 + The overall size of the uniform block must be a multiple 573 + of 16. 574 + 575 + For more information search for 'UNIFORM DATA LAYOUT' in the documentation block 576 + at the start of the header. 577 +/ 578 enum UniformLayout { 579 Default, 580 Native, 581 Std140, 582 Num, 583 } 584 /++ 585 + sg_cull_mode 586 + 587 + The face-culling mode, this is used in the 588 + sg_pipeline_desc.cull_mode member when creating a 589 + pipeline object. 590 + 591 + The default cull mode is SG_CULLMODE_NONE 592 +/ 593 enum CullMode { 594 Default, 595 None, 596 Front, 597 Back, 598 Num, 599 } 600 /++ 601 + sg_face_winding 602 + 603 + The vertex-winding rule that determines a front-facing primitive. This 604 + is used in the member sg_pipeline_desc.face_winding 605 + when creating a pipeline object. 606 + 607 + The default winding is SG_FACEWINDING_CW (clockwise) 608 +/ 609 enum FaceWinding { 610 Default, 611 Ccw, 612 Cw, 613 Num, 614 } 615 /++ 616 + sg_compare_func 617 + 618 + The compare-function for configuring depth- and stencil-ref tests 619 + in pipeline objects, and for texture samplers which perform a comparison 620 + instead of regular sampling operation. 621 + 622 + Used in the following structs: 623 + 624 + sg_pipeline_desc 625 + .depth 626 + .compare 627 + .stencil 628 + .front.compare 629 + .back.compare 630 + 631 + sg_sampler_desc 632 + .compare 633 + 634 + The default compare func for depth- and stencil-tests is 635 + SG_COMPAREFUNC_ALWAYS. 636 + 637 + The default compare func for samplers is SG_COMPAREFUNC_NEVER. 638 +/ 639 enum CompareFunc { 640 Default, 641 Never, 642 Less, 643 Equal, 644 Less_equal, 645 Greater, 646 Not_equal, 647 Greater_equal, 648 Always, 649 Num, 650 } 651 /++ 652 + sg_stencil_op 653 + 654 + The operation performed on a currently stored stencil-value when a 655 + comparison test passes or fails. This is used when creating a pipeline 656 + object in the following sg_pipeline_desc struct items: 657 + 658 + sg_pipeline_desc 659 + .stencil 660 + .front 661 + .fail_op 662 + .depth_fail_op 663 + .pass_op 664 + .back 665 + .fail_op 666 + .depth_fail_op 667 + .pass_op 668 + 669 + The default value is SG_STENCILOP_KEEP. 670 +/ 671 enum StencilOp { 672 Default, 673 Keep, 674 Zero, 675 Replace, 676 Incr_clamp, 677 Decr_clamp, 678 Invert, 679 Incr_wrap, 680 Decr_wrap, 681 Num, 682 } 683 /++ 684 + sg_blend_factor 685 + 686 + The source and destination factors in blending operations. 687 + This is used in the following members when creating a pipeline object: 688 + 689 + sg_pipeline_desc 690 + .colors[i] 691 + .blend 692 + .src_factor_rgb 693 + .dst_factor_rgb 694 + .src_factor_alpha 695 + .dst_factor_alpha 696 + 697 + The default value is SG_BLENDFACTOR_ONE for source 698 + factors, and for the destination SG_BLENDFACTOR_ZERO if the associated 699 + blend-op is ADD, SUBTRACT or REVERSE_SUBTRACT or SG_BLENDFACTOR_ONE 700 + if the associated blend-op is MIN or MAX. 701 +/ 702 enum BlendFactor { 703 Default, 704 Zero, 705 One, 706 Src_color, 707 One_minus_src_color, 708 Src_alpha, 709 One_minus_src_alpha, 710 Dst_color, 711 One_minus_dst_color, 712 Dst_alpha, 713 One_minus_dst_alpha, 714 Src_alpha_saturated, 715 Blend_color, 716 One_minus_blend_color, 717 Blend_alpha, 718 One_minus_blend_alpha, 719 Num, 720 } 721 /++ 722 + sg_blend_op 723 + 724 + Describes how the source and destination values are combined in the 725 + fragment blending operation. It is used in the following struct items 726 + when creating a pipeline object: 727 + 728 + sg_pipeline_desc 729 + .colors[i] 730 + .blend 731 + .op_rgb 732 + .op_alpha 733 + 734 + The default value is SG_BLENDOP_ADD. 735 +/ 736 enum BlendOp { 737 Default, 738 Add, 739 Subtract, 740 Reverse_subtract, 741 Min, 742 Max, 743 Num, 744 } 745 /++ 746 + sg_color_mask 747 + 748 + Selects the active color channels when writing a fragment color to the 749 + framebuffer. This is used in the members 750 + sg_pipeline_desc.colors[i].write_mask when creating a pipeline object. 751 + 752 + The default colormask is SG_COLORMASK_RGBA (write all colors channels) 753 + 754 + NOTE: since the color mask value 0 is reserved for the default value 755 + (SG_COLORMASK_RGBA), use SG_COLORMASK_NONE if all color channels 756 + should be disabled. 757 +/ 758 enum ColorMask { 759 Default = 0, 760 None = 16, 761 R = 1, 762 G = 2, 763 Rg = 3, 764 B = 4, 765 Rb = 5, 766 Gb = 6, 767 Rgb = 7, 768 A = 8, 769 Ra = 9, 770 Ga = 10, 771 Rga = 11, 772 Ba = 12, 773 Rba = 13, 774 Gba = 14, 775 Rgba = 15, 776 } 777 /++ 778 + sg_load_action 779 + 780 + Defines the load action that should be performed at the start of a render pass: 781 + 782 + SG_LOADACTION_CLEAR: clear the render target 783 + SG_LOADACTION_LOAD: load the previous content of the render target 784 + SG_LOADACTION_DONTCARE: leave the render target in an undefined state 785 + 786 + This is used in the sg_pass_action structure. 787 + 788 + The default load action for all pass attachments is SG_LOADACTION_CLEAR, 789 + with the values rgba = { 0.5f, 0.5f, 0.5f, 1.0f }, depth=1.0f and stencil=0. 790 + 791 + If you want to override the default behaviour, it is important to not 792 + only set the clear color, but the 'action' field as well (as long as this 793 + is _SG_LOADACTION_DEFAULT, the value fields will be ignored). 794 +/ 795 enum LoadAction { 796 Default, 797 Clear, 798 Load, 799 Dontcare, 800 } 801 /++ 802 + sg_store_action 803 + 804 + Defines the store action that should be performed at the end of a render pass: 805 + 806 + SG_STOREACTION_STORE: store the rendered content to the color attachment image 807 + SG_STOREACTION_DONTCARE: allows the GPU to discard the rendered content 808 +/ 809 enum StoreAction { 810 Default, 811 Store, 812 Dontcare, 813 } 814 /++ 815 + sg_pass_action 816 + 817 + The sg_pass_action struct defines the actions to be performed 818 + at the start and end of a render pass. 819 + 820 + - at the start of the pass: whether the render attachments should be cleared, 821 + loaded with their previous content, or start in an undefined state 822 + - for clear operations: the clear value (color, depth, or stencil values) 823 + - at the end of the pass: whether the rendering result should be 824 + stored back into the render attachment or discarded 825 +/ 826 extern(C) struct ColorAttachmentAction { 827 LoadAction load_action = LoadAction.Default; 828 StoreAction store_action = StoreAction.Default; 829 Color clear_value = {}; 830 } 831 extern(C) struct DepthAttachmentAction { 832 LoadAction load_action = LoadAction.Default; 833 StoreAction store_action = StoreAction.Default; 834 float clear_value = 0.0f; 835 } 836 extern(C) struct StencilAttachmentAction { 837 LoadAction load_action = LoadAction.Default; 838 StoreAction store_action = StoreAction.Default; 839 ubyte clear_value = 0; 840 } 841 extern(C) struct PassAction { 842 ColorAttachmentAction[4] colors = []; 843 DepthAttachmentAction depth = {}; 844 StencilAttachmentAction stencil = {}; 845 } 846 /++ 847 + sg_swapchain 848 + 849 + Used in sg_begin_pass() to provide details about an external swapchain 850 + (pixel formats, sample count and backend-API specific render surface objects). 851 + 852 + The following information must be provided: 853 + 854 + - the width and height of the swapchain surfaces in number of pixels, 855 + - the pixel format of the render- and optional msaa-resolve-surface 856 + - the pixel format of the optional depth- or depth-stencil-surface 857 + - the MSAA sample count for the render and depth-stencil surface 858 + 859 + If the pixel formats and MSAA sample counts are left zero-initialized, 860 + their defaults are taken from the sg_environment struct provided in the 861 + sg_setup() call. 862 + 863 + The width and height *must* be > 0. 864 + 865 + Additionally the following backend API specific objects must be passed in 866 + as 'type erased' void pointers: 867 + 868 + GL: 869 + - on all GL backends, a GL framebuffer object must be provided. This 870 + can be zero for the default framebuffer. 871 + 872 + D3D11: 873 + - an ID3D11RenderTargetView for the rendering surface, without 874 + MSAA rendering this surface will also be displayed 875 + - an optional ID3D11DepthStencilView for the depth- or depth/stencil 876 + buffer surface 877 + - when MSAA rendering is used, another ID3D11RenderTargetView 878 + which serves as MSAA resolve target and will be displayed 879 + 880 + WebGPU (same as D3D11, except different types) 881 + - a WGPUTextureView for the rendering surface, without 882 + MSAA rendering this surface will also be displayed 883 + - an optional WGPUTextureView for the depth- or depth/stencil 884 + buffer surface 885 + - when MSAA rendering is used, another WGPUTextureView 886 + which serves as MSAA resolve target and will be displayed 887 + 888 + Metal (NOTE that the roles of provided surfaces is slightly different 889 + than on D3D11 or WebGPU in case of MSAA vs non-MSAA rendering): 890 + 891 + - A current CAMetalDrawable (NOT an MTLDrawable!) which will be presented. 892 + This will either be rendered to directly (if no MSAA is used), or serve 893 + as MSAA-resolve target. 894 + - an optional MTLTexture for the depth- or depth-stencil buffer 895 + - an optional multisampled MTLTexture which serves as intermediate 896 + rendering surface which will then be resolved into the 897 + CAMetalDrawable. 898 + 899 + NOTE that for Metal you must use an ObjC __bridge cast to 900 + properly tunnel the ObjC object id through a C void*, e.g.: 901 + 902 + swapchain.metal.current_drawable = (__bridge const void*) [mtkView currentDrawable]; 903 + 904 + On all other backends you shouldn't need to mess with the reference count. 905 + 906 + It's a good practice to write a helper function which returns an initialized 907 + sg_swapchain structs, which can then be plugged directly into 908 + sg_pass.swapchain. Look at the function sglue_swapchain() in the sokol_glue.h 909 + as an example. 910 +/ 911 extern(C) struct MetalSwapchain { 912 const(void)* current_drawable = null; 913 const(void)* depth_stencil_texture = null; 914 const(void)* msaa_color_texture = null; 915 } 916 extern(C) struct D3d11Swapchain { 917 const(void)* render_view = null; 918 const(void)* resolve_view = null; 919 const(void)* depth_stencil_view = null; 920 } 921 extern(C) struct WgpuSwapchain { 922 const(void)* render_view = null; 923 const(void)* resolve_view = null; 924 const(void)* depth_stencil_view = null; 925 } 926 extern(C) struct GlSwapchain { 927 uint framebuffer = 0; 928 } 929 extern(C) struct Swapchain { 930 int width = 0; 931 int height = 0; 932 int sample_count = 0; 933 PixelFormat color_format = PixelFormat.Default; 934 PixelFormat depth_format = PixelFormat.Default; 935 MetalSwapchain metal = {}; 936 D3d11Swapchain d3d11 = {}; 937 WgpuSwapchain wgpu = {}; 938 GlSwapchain gl = {}; 939 } 940 /++ 941 + sg_pass 942 + 943 + The sg_pass structure is passed as argument into the sg_begin_pass() 944 + function. 945 + 946 + For a swapchain render pass, provide an sg_pass_action and sg_swapchain 947 + struct (for instance via the sglue_swapchain() helper function from 948 + sokol_glue.h): 949 + 950 + sg_begin_pass(&(sg_pass){ 951 + .action = { ... }, 952 + .swapchain = sglue_swapchain(), 953 + }); 954 + 955 + For an offscreen render pass, provide an sg_pass_action struct and 956 + an sg_attachments handle: 957 + 958 + sg_begin_pass(&(sg_pass){ 959 + .action = { ... }, 960 + .attachments = attachments, 961 + }); 962 + 963 + You can also omit the .action object to get default pass action behaviour 964 + (clear to color=grey, depth=1 and stencil=0). 965 + 966 + For a compute pass, just set the sg_pass.compute boolean to true: 967 + 968 + sg_begin_pass(&(sg_pass){ .compute = true }); 969 +/ 970 extern(C) struct Pass { 971 uint _start_canary = 0; 972 bool compute = false; 973 PassAction action = {}; 974 Attachments attachments = {}; 975 Swapchain swapchain = {}; 976 const(char)* label = null; 977 uint _end_canary = 0; 978 } 979 /++ 980 + sg_bindings 981 + 982 + The sg_bindings structure defines the buffers, images and 983 + samplers resource bindings for the next draw call. 984 + 985 + To update the resource bindings, call sg_apply_bindings() with 986 + a pointer to a populated sg_bindings struct. Note that 987 + sg_apply_bindings() must be called after sg_apply_pipeline() 988 + and that bindings are not preserved across sg_apply_pipeline() 989 + calls, even when the new pipeline uses the same 'bindings layout'. 990 + 991 + A resource binding struct contains: 992 + 993 + - 1..N vertex buffers 994 + - 0..N vertex buffer offsets 995 + - 0..1 index buffers 996 + - 0..1 index buffer offsets 997 + - 0..N images 998 + - 0..N samplers 999 + - 0..N storage buffers 1000 + 1001 + Where 'N' is defined in the following constants: 1002 + 1003 + - SG_MAX_VERTEXBUFFER_BINDSLOTS 1004 + - SG_MAX_IMAGE_BINDLOTS 1005 + - SG_MAX_SAMPLER_BINDSLOTS 1006 + - SG_MAX_STORAGEBUFFER_BINDGLOTS 1007 + 1008 + Note that inside compute passes vertex- and index-buffer-bindings are 1009 + disallowed. 1010 + 1011 + When using sokol-shdc for shader authoring, the `layout(binding=N)` 1012 + annotation in the shader code directly maps to the slot index for that 1013 + resource type in the bindings struct, for instance the following vertex- 1014 + and fragment-shader interface for sokol-shdc: 1015 + 1016 + @vs vs 1017 + layout(binding=0) uniform vs_params { ... }; 1018 + layout(binding=0) readonly buffer ssbo { ... }; 1019 + layout(binding=0) uniform texture2D vs_tex; 1020 + layout(binding=0) uniform sampler vs_smp; 1021 + ... 1022 + @end 1023 + 1024 + @fs fs 1025 + layout(binding=1) uniform fs_params { ... }; 1026 + layout(binding=1) uniform texture2D fs_tex; 1027 + layout(binding=1) uniform sampler fs_smp; 1028 + ... 1029 + @end 1030 + 1031 + ...would map to the following sg_bindings struct: 1032 + 1033 + const sg_bindings bnd = { 1034 + .vertex_buffers[0] = ..., 1035 + .images[0] = vs_tex, 1036 + .images[1] = fs_tex, 1037 + .samplers[0] = vs_smp, 1038 + .samplers[1] = fs_smp, 1039 + .storage_buffers[0] = ssbo, 1040 + }; 1041 + 1042 + ...alternatively you can use code-generated slot indices: 1043 + 1044 + const sg_bindings bnd = { 1045 + .vertex_buffers[0] = ..., 1046 + .images[IMG_vs_tex] = vs_tex, 1047 + .images[IMG_fs_tex] = fs_tex, 1048 + .samplers[SMP_vs_smp] = vs_smp, 1049 + .samplers[SMP_fs_smp] = fs_smp, 1050 + .storage_buffers[SBUF_ssbo] = ssbo, 1051 + }; 1052 + 1053 + Resource bindslots for a specific shader/pipeline may have gaps, and an 1054 + sg_bindings struct may have populated bind slots which are not used by a 1055 + specific shader. This allows to use the same sg_bindings struct across 1056 + different shader variants. 1057 + 1058 + When not using sokol-shdc, the bindslot indices in the sg_bindings 1059 + struct need to match the per-resource reflection info slot indices 1060 + in the sg_shader_desc struct (for details about that see the 1061 + sg_shader_desc struct documentation). 1062 + 1063 + The optional buffer offsets can be used to put different unrelated 1064 + chunks of vertex- and/or index-data into the same buffer objects. 1065 +/ 1066 extern(C) struct Bindings { 1067 uint _start_canary = 0; 1068 Buffer[8] vertex_buffers = []; 1069 int[8] vertex_buffer_offsets = [0, 0, 0, 0, 0, 0, 0, 0]; 1070 Buffer index_buffer = {}; 1071 int index_buffer_offset = 0; 1072 Image[16] images = []; 1073 Sampler[16] samplers = []; 1074 Buffer[8] storage_buffers = []; 1075 uint _end_canary = 0; 1076 } 1077 /++ 1078 + sg_buffer_usage 1079 + 1080 + Describes how a buffer object is going to be used: 1081 + 1082 + .vertex_buffer (default: true) 1083 + the buffer will bound as vertex buffer via sg_bindings.vertex_buffers[] 1084 + .index_buffer (default: false) 1085 + the buffer will bound as index buffer via sg_bindings.index_buffer 1086 + .storage_buffer (default: false) 1087 + the buffer will bound as storage buffer via sg_bindings.storage_buffers[] 1088 + .immutable (default: true) 1089 + the buffer content will never be updated from the CPU side (but 1090 + may be written to by a compute shader) 1091 + .dynamic_update (default: false) 1092 + the buffer content will be infrequently updated from the CPU side 1093 + .stream_upate (default: false) 1094 + the buffer content will be updated each frame from the CPU side 1095 +/ 1096 extern(C) struct BufferUsage { 1097 bool vertex_buffer = false; 1098 bool index_buffer = false; 1099 bool storage_buffer = false; 1100 bool _immutable = false; 1101 bool dynamic_update = false; 1102 bool stream_update = false; 1103 } 1104 /++ 1105 + sg_buffer_desc 1106 + 1107 + Creation parameters for sg_buffer objects, used in the sg_make_buffer() call. 1108 + 1109 + The default configuration is: 1110 + 1111 + .size: 0 (*must* be >0 for buffers without data) 1112 + .usage .vertex_buffer = true, .immutable = true 1113 + .data.ptr 0 (*must* be valid for immutable buffers without storage buffer usage) 1114 + .data.size 0 (*must* be > 0 for immutable buffers without storage buffer usage) 1115 + .label 0 (optional string label) 1116 + 1117 + For immutable buffers which are initialized with initial data, 1118 + keep the .size item zero-initialized, and set the size together with the 1119 + pointer to the initial data in the .data item. 1120 + 1121 + For immutable or mutable buffers without initial data, keep the .data item 1122 + zero-initialized, and set the buffer size in the .size item instead. 1123 + 1124 + You can also set both size values, but currently both size values must 1125 + be identical (this may change in the future when the dynamic resource 1126 + management may become more flexible). 1127 + 1128 + NOTE: Immutable buffers without storage-buffer-usage *must* be created 1129 + with initial content, this restriction doesn't apply to storage buffer usage, 1130 + because storage buffers may also get their initial content by running 1131 + a compute shader on them. 1132 + 1133 + NOTE: Buffers without initial data will have undefined content, e.g. 1134 + do *not* expect the buffer to be zero-initialized! 1135 + 1136 + ADVANCED TOPIC: Injecting native 3D-API buffers: 1137 + 1138 + The following struct members allow to inject your own GL, Metal 1139 + or D3D11 buffers into sokol_gfx: 1140 + 1141 + .gl_buffers[SG_NUM_INFLIGHT_FRAMES] 1142 + .mtl_buffers[SG_NUM_INFLIGHT_FRAMES] 1143 + .d3d11_buffer 1144 + 1145 + You must still provide all other struct items except the .data item, and 1146 + these must match the creation parameters of the native buffers you provide. 1147 + For sg_buffer_desc.usage.immutable buffers, only provide a single native 1148 + 3D-API buffer, otherwise you need to provide SG_NUM_INFLIGHT_FRAMES buffers 1149 + (only for GL and Metal, not D3D11). Providing multiple buffers for GL and 1150 + Metal is necessary because sokol_gfx will rotate through them when calling 1151 + sg_update_buffer() to prevent lock-stalls. 1152 + 1153 + Note that it is expected that immutable injected buffer have already been 1154 + initialized with content, and the .content member must be 0! 1155 + 1156 + Also you need to call sg_reset_state_cache() after calling native 3D-API 1157 + functions, and before calling any sokol_gfx function. 1158 +/ 1159 extern(C) struct BufferDesc { 1160 uint _start_canary = 0; 1161 size_t size = 0; 1162 BufferUsage usage = {}; 1163 Range data = {}; 1164 const(char)* label = null; 1165 uint[2] gl_buffers = [0, 0]; 1166 const(void)*[2] mtl_buffers = null; 1167 const(void)* d3d11_buffer = null; 1168 const(void)* wgpu_buffer = null; 1169 uint _end_canary = 0; 1170 } 1171 /++ 1172 + sg_image_usage 1173 + 1174 + Describes how the image object is going to be used: 1175 + 1176 + .render_attachment (default: false) 1177 + the image object is used as color-, resolve- or depth-stencil- 1178 + attachment in a render pass 1179 + .storage_attachment (default: false) 1180 + the image object is used as storage-attachment in a 1181 + compute pass (to be written to by compute shaders) 1182 + .immutable (default: true) 1183 + the image content cannot be updated from the CPU side 1184 + (but may be updated by the GPU in a render- or compute-pass) 1185 + .dynamic_update (default: false) 1186 + the image content is updated infrequently by the CPU 1187 + .stream_update (default: false) 1188 + the image content is updated each frame by the CPU via 1189 + 1190 + Note that the usage as texture binding is implicit and always allowed. 1191 +/ 1192 extern(C) struct ImageUsage { 1193 bool render_attachment = false; 1194 bool storage_attachment = false; 1195 bool _immutable = false; 1196 bool dynamic_update = false; 1197 bool stream_update = false; 1198 } 1199 /++ 1200 + sg_image_data 1201 + 1202 + Defines the content of an image through a 2D array of sg_range structs. 1203 + The first array dimension is the cubemap face, and the second array 1204 + dimension the mipmap level. 1205 +/ 1206 extern(C) struct ImageData { 1207 Range[6][16] subimage = []; 1208 } 1209 /++ 1210 + sg_image_desc 1211 + 1212 + Creation parameters for sg_image objects, used in the sg_make_image() call. 1213 + 1214 + The default configuration is: 1215 + 1216 + .type SG_IMAGETYPE_2D 1217 + .usage .immutable = true 1218 + .width 0 (must be set to >0) 1219 + .height 0 (must be set to >0) 1220 + .num_slices 1 (3D textures: depth; array textures: number of layers) 1221 + .num_mipmaps 1 1222 + .pixel_format SG_PIXELFORMAT_RGBA8 for textures, or sg_desc.environment.defaults.color_format for render targets 1223 + .sample_count 1 for textures, or sg_desc.environment.defaults.sample_count for render targets 1224 + .data an sg_image_data struct to define the initial content 1225 + .label 0 (optional string label for trace hooks) 1226 + 1227 + Q: Why is the default sample_count for render targets identical with the 1228 + "default sample count" from sg_desc.environment.defaults.sample_count? 1229 + 1230 + A: So that it matches the default sample count in pipeline objects. Even 1231 + though it is a bit strange/confusing that offscreen render targets by default 1232 + get the same sample count as 'default swapchains', but it's better that 1233 + an offscreen render target created with default parameters matches 1234 + a pipeline object created with default parameters. 1235 + 1236 + NOTE: 1237 + 1238 + Regular (non-attachment) images with usage.immutable must be fully initialized by 1239 + providing a valid .data member which points to initialization data. 1240 + 1241 + Images with usage.render_attachment or usage.storage_attachment must 1242 + *not* be created with initial content. Be aware that the initial 1243 + content of render- and storage-attachment images is undefined. 1244 + 1245 + ADVANCED TOPIC: Injecting native 3D-API textures: 1246 + 1247 + The following struct members allow to inject your own GL, Metal or D3D11 1248 + textures into sokol_gfx: 1249 + 1250 + .gl_textures[SG_NUM_INFLIGHT_FRAMES] 1251 + .mtl_textures[SG_NUM_INFLIGHT_FRAMES] 1252 + .d3d11_texture 1253 + .d3d11_shader_resource_view 1254 + .wgpu_texture 1255 + .wgpu_texture_view 1256 + 1257 + For GL, you can also specify the texture target or leave it empty to use 1258 + the default texture target for the image type (GL_TEXTURE_2D for 1259 + SG_IMAGETYPE_2D etc) 1260 + 1261 + For D3D11 and WebGPU, either only provide a texture, or both a texture and 1262 + shader-resource-view / texture-view object. If you want to use access the 1263 + injected texture in a shader you *must* provide a shader-resource-view. 1264 + 1265 + The same rules apply as for injecting native buffers (see sg_buffer_desc 1266 + documentation for more details). 1267 +/ 1268 extern(C) struct ImageDesc { 1269 uint _start_canary = 0; 1270 ImageType type = ImageType.Default; 1271 ImageUsage usage = {}; 1272 int width = 0; 1273 int height = 0; 1274 int num_slices = 0; 1275 int num_mipmaps = 0; 1276 PixelFormat pixel_format = PixelFormat.Default; 1277 int sample_count = 0; 1278 ImageData data = {}; 1279 const(char)* label = null; 1280 uint[2] gl_textures = [0, 0]; 1281 uint gl_texture_target = 0; 1282 const(void)*[2] mtl_textures = null; 1283 const(void)* d3d11_texture = null; 1284 const(void)* d3d11_shader_resource_view = null; 1285 const(void)* wgpu_texture = null; 1286 const(void)* wgpu_texture_view = null; 1287 uint _end_canary = 0; 1288 } 1289 /++ 1290 + sg_sampler_desc 1291 + 1292 + Creation parameters for sg_sampler objects, used in the sg_make_sampler() call 1293 + 1294 + .min_filter: SG_FILTER_NEAREST 1295 + .mag_filter: SG_FILTER_NEAREST 1296 + .mipmap_filter SG_FILTER_NEAREST 1297 + .wrap_u: SG_WRAP_REPEAT 1298 + .wrap_v: SG_WRAP_REPEAT 1299 + .wrap_w: SG_WRAP_REPEAT (only SG_IMAGETYPE_3D) 1300 + .min_lod 0.0f 1301 + .max_lod FLT_MAX 1302 + .border_color SG_BORDERCOLOR_OPAQUE_BLACK 1303 + .compare SG_COMPAREFUNC_NEVER 1304 + .max_anisotropy 1 (must be 1..16) 1305 +/ 1306 extern(C) struct SamplerDesc { 1307 uint _start_canary = 0; 1308 Filter min_filter = Filter.Default; 1309 Filter mag_filter = Filter.Default; 1310 Filter mipmap_filter = Filter.Default; 1311 Wrap wrap_u = Wrap.Default; 1312 Wrap wrap_v = Wrap.Default; 1313 Wrap wrap_w = Wrap.Default; 1314 float min_lod = 0.0f; 1315 float max_lod = 0.0f; 1316 BorderColor border_color = BorderColor.Default; 1317 CompareFunc compare = CompareFunc.Default; 1318 uint max_anisotropy = 0; 1319 const(char)* label = null; 1320 uint gl_sampler = 0; 1321 const(void)* mtl_sampler = null; 1322 const(void)* d3d11_sampler = null; 1323 const(void)* wgpu_sampler = null; 1324 uint _end_canary = 0; 1325 } 1326 /++ 1327 + sg_shader_desc 1328 + 1329 + Used as parameter of sg_make_shader() to create a shader object which 1330 + communicates shader source or bytecode and shader interface 1331 + reflection information to sokol-gfx. 1332 + 1333 + If you use sokol-shdc you can ignore the following information since 1334 + the sg_shader_desc struct will be code-generated. 1335 + 1336 + Otherwise you need to provide the following information to the 1337 + sg_make_shader() call: 1338 + 1339 + - a vertex- and fragment-shader function: 1340 + - the shader source or bytecode 1341 + - an optional entry point name 1342 + - for D3D11: an optional compile target when source code is provided 1343 + (the defaults are "vs_4_0" and "ps_4_0") 1344 + 1345 + - ...or alternatively, a compute function: 1346 + - the shader source or bytecode 1347 + - an optional entry point name 1348 + - for D3D11: an optional compile target when source code is provided 1349 + (the default is "cs_5_0") 1350 + 1351 + - vertex attributes required by some backends (not for compute shaders): 1352 + - the vertex attribute base type (undefined, float, signed int, unsigned int), 1353 + this information is only used in the validation layer to check that the 1354 + pipeline object vertex formats are compatible with the input vertex attribute 1355 + type used in the vertex shader. NOTE that the default base type 1356 + 'undefined' skips the validation layer check. 1357 + - for the GL backend: optional vertex attribute names used for name lookup 1358 + - for the D3D11 backend: semantic names and indices 1359 + 1360 + - only for compute shaders on the Metal backend: 1361 + - the workgroup size aka 'threads per thread-group' 1362 + 1363 + In other 3D APIs this is declared in the shader code: 1364 + - GLSL: `layout(local_size_x=x, local_size_y=y, local_size_y=z) in;` 1365 + - HLSL: `[numthreads(x, y, z)]` 1366 + - WGSL: `@workgroup_size(x, y, z)` 1367 + ...but in Metal the workgroup size is declared on the CPU side 1368 + 1369 + - reflection information for each uniform block binding used by the shader: 1370 + - the shader stage the uniform block appears in (SG_SHADERSTAGE_*) 1371 + - the size in bytes of the uniform block 1372 + - backend-specific bindslots: 1373 + - HLSL: the constant buffer register `register(b0..7)` 1374 + - MSL: the buffer attribute `[[buffer(0..7)]]` 1375 + - WGSL: the binding in `@group(0) @binding(0..15)` 1376 + - GLSL only: a description of the uniform block interior 1377 + - the memory layout standard (SG_UNIFORMLAYOUT_*) 1378 + - for each member in the uniform block: 1379 + - the member type (SG_UNIFORM_*) 1380 + - if the member is an array, the array count 1381 + - the member name 1382 + 1383 + - reflection information for each texture binding used by the shader: 1384 + - the shader stage the texture appears in (SG_SHADERSTAGE_*) 1385 + - the image type (SG_IMAGETYPE_*) 1386 + - the image-sample type (SG_IMAGESAMPLETYPE_*) 1387 + - whether the texture is multisampled 1388 + - backend specific bindslots: 1389 + - HLSL: the texture register `register(t0..23)` 1390 + - MSL: the texture attribute `[[texture(0..19)]]` 1391 + - WGSL: the binding in `@group(1) @binding(0..127)` 1392 + 1393 + - reflection information for each sampler used by the shader: 1394 + - the shader stage the sampler appears in (SG_SHADERSTAGE_*) 1395 + - the sampler type (SG_SAMPLERTYPE_*) 1396 + - backend specific bindslots: 1397 + - HLSL: the sampler register `register(s0..15)` 1398 + - MSL: the sampler attribute `[[sampler(0..15)]]` 1399 + - WGSL: the binding in `@group(0) @binding(0..127)` 1400 + 1401 + - reflection information for each storage buffer binding used by the shader: 1402 + - the shader stage the storage buffer appears in (SG_SHADERSTAGE_*) 1403 + - whether the storage buffer is readonly 1404 + - backend specific bindslots: 1405 + - HLSL: 1406 + - for readonly storage buffer bindings: `register(t0..23)` 1407 + - for read/write storage buffer bindings: `register(u0..11)` 1408 + - MSL: the buffer attribute `[[buffer(8..15)]]` 1409 + - WGSL: the binding in `@group(1) @binding(0..127)` 1410 + - GL: the binding in `layout(binding=0..7)` 1411 + 1412 + - reflection information for each storage image binding used by the shader: 1413 + - the shader stage (*must* be SG_SHADERSTAGE_COMPUTE) 1414 + - whether the storage image is writeonly or readwrite (for readonly 1415 + access use a regular texture binding instead) 1416 + - the image type expected by the shader (SG_IMAGETYPE_*) 1417 + - the access pixel format expected by the shader (SG_PIXELFORMAT_*), 1418 + note that only a subset of pixel formats is allowed for storage image 1419 + bindings 1420 + - backend specific bindslots: 1421 + - HLSL: the UAV register `register(u0..u11)` 1422 + - MSL: the texture attribute `[[texture(0..19)]]` 1423 + - WGSL: the binding in `@group(2) @binding(0..3)` 1424 + - GLSL: the binding in `layout(binding=0..3, [access_format])` 1425 + 1426 + - reflection information for each combined image-sampler object 1427 + used by the shader: 1428 + - the shader stage (SG_SHADERSTAGE_*) 1429 + - the texture's array index in the sg_shader_desc.images[] array 1430 + - the sampler's array index in the sg_shader_desc.samplers[] array 1431 + - GLSL only: the name of the combined image-sampler object 1432 + 1433 + The number and order of items in the sg_shader_desc.attrs[] 1434 + array corresponds to the items in sg_pipeline_desc.layout.attrs. 1435 + 1436 + - sg_shader_desc.attrs[N] => sg_pipeline_desc.layout.attrs[N] 1437 + 1438 + NOTE that vertex attribute indices currently cannot have gaps. 1439 + 1440 + The items index in the sg_shader_desc.uniform_blocks[] array corresponds 1441 + to the ub_slot arg in sg_apply_uniforms(): 1442 + 1443 + - sg_shader_desc.uniform_blocks[N] => sg_apply_uniforms(N, ...) 1444 + 1445 + The items in the shader_desc images, samplers and storage_buffers 1446 + arrays correspond to the same array items in the sg_bindings struct: 1447 + 1448 + - sg_shader_desc.images[N] => sg_bindings.images[N] 1449 + - sg_shader_desc.samplers[N] => sg_bindings.samplers[N] 1450 + - sg_shader_desc.storage_buffers[N] => sg_bindings.storage_buffers[N] 1451 + 1452 + For all GL backends, shader source-code must be provided. For D3D11 and Metal, 1453 + either shader source-code or byte-code can be provided. 1454 + 1455 + NOTE that the uniform block, image, sampler, storage_buffer and 1456 + storage_image arrays may have gaps. This allows to use the same sg_bindings 1457 + struct for different related shader variants. 1458 + 1459 + For D3D11, if source code is provided, the d3dcompiler_47.dll will be loaded 1460 + on demand. If this fails, shader creation will fail. When compiling HLSL 1461 + source code, you can provide an optional target string via 1462 + sg_shader_stage_desc.d3d11_target, the default target is "vs_4_0" for the 1463 + vertex shader stage and "ps_4_0" for the pixel shader stage. 1464 +/ 1465 enum ShaderStage { 1466 None, 1467 Vertex, 1468 Fragment, 1469 Compute, 1470 } 1471 extern(C) struct ShaderFunction { 1472 const(char)* source = null; 1473 Range bytecode = {}; 1474 const(char)* entry = null; 1475 const(char)* d3d11_target = null; 1476 } 1477 enum ShaderAttrBaseType { 1478 Undefined, 1479 Float, 1480 Sint, 1481 Uint, 1482 } 1483 extern(C) struct ShaderVertexAttr { 1484 ShaderAttrBaseType base_type = ShaderAttrBaseType.Undefined; 1485 const(char)* glsl_name = null; 1486 const(char)* hlsl_sem_name = null; 1487 ubyte hlsl_sem_index = 0; 1488 } 1489 extern(C) struct GlslShaderUniform { 1490 UniformType type = UniformType.Invalid; 1491 ushort array_count = 0; 1492 const(char)* glsl_name = null; 1493 } 1494 extern(C) struct ShaderUniformBlock { 1495 ShaderStage stage = ShaderStage.None; 1496 uint size = 0; 1497 ubyte hlsl_register_b_n = 0; 1498 ubyte msl_buffer_n = 0; 1499 ubyte wgsl_group0_binding_n = 0; 1500 UniformLayout layout = UniformLayout.Default; 1501 GlslShaderUniform[16] glsl_uniforms = []; 1502 } 1503 extern(C) struct ShaderImage { 1504 ShaderStage stage = ShaderStage.None; 1505 ImageType image_type = ImageType.Default; 1506 ImageSampleType sample_type = ImageSampleType.Default; 1507 bool multisampled = false; 1508 ubyte hlsl_register_t_n = 0; 1509 ubyte msl_texture_n = 0; 1510 ubyte wgsl_group1_binding_n = 0; 1511 } 1512 extern(C) struct ShaderSampler { 1513 ShaderStage stage = ShaderStage.None; 1514 SamplerType sampler_type = SamplerType.Default; 1515 ubyte hlsl_register_s_n = 0; 1516 ubyte msl_sampler_n = 0; 1517 ubyte wgsl_group1_binding_n = 0; 1518 } 1519 extern(C) struct ShaderStorageBuffer { 1520 ShaderStage stage = ShaderStage.None; 1521 bool readonly = false; 1522 ubyte hlsl_register_t_n = 0; 1523 ubyte hlsl_register_u_n = 0; 1524 ubyte msl_buffer_n = 0; 1525 ubyte wgsl_group1_binding_n = 0; 1526 ubyte glsl_binding_n = 0; 1527 } 1528 extern(C) struct ShaderStorageImage { 1529 ShaderStage stage = ShaderStage.None; 1530 ImageType image_type = ImageType.Default; 1531 PixelFormat access_format = PixelFormat.Default; 1532 bool writeonly = false; 1533 ubyte hlsl_register_u_n = 0; 1534 ubyte msl_texture_n = 0; 1535 ubyte wgsl_group2_binding_n = 0; 1536 ubyte glsl_binding_n = 0; 1537 } 1538 extern(C) struct ShaderImageSamplerPair { 1539 ShaderStage stage = ShaderStage.None; 1540 ubyte image_slot = 0; 1541 ubyte sampler_slot = 0; 1542 const(char)* glsl_name = null; 1543 } 1544 extern(C) struct MtlShaderThreadsPerThreadgroup { 1545 int x = 0; 1546 int y = 0; 1547 int z = 0; 1548 } 1549 extern(C) struct ShaderDesc { 1550 uint _start_canary = 0; 1551 ShaderFunction vertex_func = {}; 1552 ShaderFunction fragment_func = {}; 1553 ShaderFunction compute_func = {}; 1554 ShaderVertexAttr[16] attrs = []; 1555 ShaderUniformBlock[8] uniform_blocks = []; 1556 ShaderStorageBuffer[8] storage_buffers = []; 1557 ShaderImage[16] images = []; 1558 ShaderSampler[16] samplers = []; 1559 ShaderImageSamplerPair[16] image_sampler_pairs = []; 1560 ShaderStorageImage[4] storage_images = []; 1561 MtlShaderThreadsPerThreadgroup mtl_threads_per_threadgroup = {}; 1562 const(char)* label = null; 1563 uint _end_canary = 0; 1564 } 1565 /++ 1566 + sg_pipeline_desc 1567 + 1568 + The sg_pipeline_desc struct defines all creation parameters for an 1569 + sg_pipeline object, used as argument to the sg_make_pipeline() function: 1570 + 1571 + Pipeline objects come in two flavours: 1572 + 1573 + - render pipelines for use in render passes 1574 + - compute pipelines for use in compute passes 1575 + 1576 + A compute pipeline only requires a compute shader object but no 1577 + 'render state', while a render pipeline requires a vertex/fragment shader 1578 + object and additional render state declarations: 1579 + 1580 + - the vertex layout for all input vertex buffers 1581 + - a shader object 1582 + - the 3D primitive type (points, lines, triangles, ...) 1583 + - the index type (none, 16- or 32-bit) 1584 + - all the fixed-function-pipeline state (depth-, stencil-, blend-state, etc...) 1585 + 1586 + If the vertex data has no gaps between vertex components, you can omit 1587 + the .layout.buffers[].stride and layout.attrs[].offset items (leave them 1588 + default-initialized to 0), sokol-gfx will then compute the offsets and 1589 + strides from the vertex component formats (.layout.attrs[].format). 1590 + Please note that ALL vertex attribute offsets must be 0 in order for the 1591 + automatic offset computation to kick in. 1592 + 1593 + Note that if you use vertex-pulling from storage buffers instead of 1594 + fixed-function vertex input you can simply omit the entire nested .layout 1595 + struct. 1596 + 1597 + The default configuration is as follows: 1598 + 1599 + .compute: false (must be set to true for a compute pipeline) 1600 + .shader: 0 (must be initialized with a valid sg_shader id!) 1601 + .layout: 1602 + .buffers[]: vertex buffer layouts 1603 + .stride: 0 (if no stride is given it will be computed) 1604 + .step_func SG_VERTEXSTEP_PER_VERTEX 1605 + .step_rate 1 1606 + .attrs[]: vertex attribute declarations 1607 + .buffer_index 0 the vertex buffer bind slot 1608 + .offset 0 (offsets can be omitted if the vertex layout has no gaps) 1609 + .format SG_VERTEXFORMAT_INVALID (must be initialized!) 1610 + .depth: 1611 + .pixel_format: sg_desc.context.depth_format 1612 + .compare: SG_COMPAREFUNC_ALWAYS 1613 + .write_enabled: false 1614 + .bias: 0.0f 1615 + .bias_slope_scale: 0.0f 1616 + .bias_clamp: 0.0f 1617 + .stencil: 1618 + .enabled: false 1619 + .front/back: 1620 + .compare: SG_COMPAREFUNC_ALWAYS 1621 + .fail_op: SG_STENCILOP_KEEP 1622 + .depth_fail_op: SG_STENCILOP_KEEP 1623 + .pass_op: SG_STENCILOP_KEEP 1624 + .read_mask: 0 1625 + .write_mask: 0 1626 + .ref: 0 1627 + .color_count 1 1628 + .colors[0..color_count] 1629 + .pixel_format sg_desc.context.color_format 1630 + .write_mask: SG_COLORMASK_RGBA 1631 + .blend: 1632 + .enabled: false 1633 + .src_factor_rgb: SG_BLENDFACTOR_ONE 1634 + .dst_factor_rgb: SG_BLENDFACTOR_ZERO 1635 + .op_rgb: SG_BLENDOP_ADD 1636 + .src_factor_alpha: SG_BLENDFACTOR_ONE 1637 + .dst_factor_alpha: SG_BLENDFACTOR_ZERO 1638 + .op_alpha: SG_BLENDOP_ADD 1639 + .primitive_type: SG_PRIMITIVETYPE_TRIANGLES 1640 + .index_type: SG_INDEXTYPE_NONE 1641 + .cull_mode: SG_CULLMODE_NONE 1642 + .face_winding: SG_FACEWINDING_CW 1643 + .sample_count: sg_desc.context.sample_count 1644 + .blend_color: (sg_color) { 0.0f, 0.0f, 0.0f, 0.0f } 1645 + .alpha_to_coverage_enabled: false 1646 + .label 0 (optional string label for trace hooks) 1647 +/ 1648 extern(C) struct VertexBufferLayoutState { 1649 int stride = 0; 1650 VertexStep step_func = VertexStep.Default; 1651 int step_rate = 0; 1652 } 1653 extern(C) struct VertexAttrState { 1654 int buffer_index = 0; 1655 int offset = 0; 1656 VertexFormat format = VertexFormat.Invalid; 1657 } 1658 extern(C) struct VertexLayoutState { 1659 VertexBufferLayoutState[8] buffers = []; 1660 VertexAttrState[16] attrs = []; 1661 } 1662 extern(C) struct StencilFaceState { 1663 CompareFunc compare = CompareFunc.Default; 1664 StencilOp fail_op = StencilOp.Default; 1665 StencilOp depth_fail_op = StencilOp.Default; 1666 StencilOp pass_op = StencilOp.Default; 1667 } 1668 extern(C) struct StencilState { 1669 bool enabled = false; 1670 StencilFaceState front = {}; 1671 StencilFaceState back = {}; 1672 ubyte read_mask = 0; 1673 ubyte write_mask = 0; 1674 ubyte _ref = 0; 1675 } 1676 extern(C) struct DepthState { 1677 PixelFormat pixel_format = PixelFormat.Default; 1678 CompareFunc compare = CompareFunc.Default; 1679 bool write_enabled = false; 1680 float bias = 0.0f; 1681 float bias_slope_scale = 0.0f; 1682 float bias_clamp = 0.0f; 1683 } 1684 extern(C) struct BlendState { 1685 bool enabled = false; 1686 BlendFactor src_factor_rgb = BlendFactor.Default; 1687 BlendFactor dst_factor_rgb = BlendFactor.Default; 1688 BlendOp op_rgb = BlendOp.Default; 1689 BlendFactor src_factor_alpha = BlendFactor.Default; 1690 BlendFactor dst_factor_alpha = BlendFactor.Default; 1691 BlendOp op_alpha = BlendOp.Default; 1692 } 1693 extern(C) struct ColorTargetState { 1694 PixelFormat pixel_format = PixelFormat.Default; 1695 ColorMask write_mask = ColorMask.Default; 1696 BlendState blend = {}; 1697 } 1698 extern(C) struct PipelineDesc { 1699 uint _start_canary = 0; 1700 bool compute = false; 1701 Shader shader = {}; 1702 VertexLayoutState layout = {}; 1703 DepthState depth = {}; 1704 StencilState stencil = {}; 1705 int color_count = 0; 1706 ColorTargetState[4] colors = []; 1707 PrimitiveType primitive_type = PrimitiveType.Default; 1708 IndexType index_type = IndexType.Default; 1709 CullMode cull_mode = CullMode.Default; 1710 FaceWinding face_winding = FaceWinding.Default; 1711 int sample_count = 0; 1712 Color blend_color = {}; 1713 bool alpha_to_coverage_enabled = false; 1714 const(char)* label = null; 1715 uint _end_canary = 0; 1716 } 1717 /++ 1718 + sg_attachments_desc 1719 + 1720 + Creation parameters for an sg_attachments object, used as argument to the 1721 + sg_make_attachments() function. 1722 + 1723 + An attachments object bundles either bundles 'render attachments' for 1724 + a render pass, or 'storage attachments' for a compute pass which writes 1725 + to storage images. 1726 + 1727 + Render attachments are: 1728 + 1729 + - 0..4 color attachment images 1730 + - 0..4 msaa-resolve attachment images 1731 + - 0 or one depth-stencil attachment image 1732 + 1733 + Note that all types of render attachment images must be created with 1734 + `sg_image_desc.usage.render_attachment = true`. At least one color-attachment 1735 + or depth-stencil-attachment image must be provided in a render pass 1736 + (only providing a depth-stencil-attachment is useful for depth-only passes). 1737 + 1738 + Alternatively provide 1..4 storage attachment images which must be created 1739 + with `sg_image_desc.usage.storage_attachment = true`. 1740 + 1741 + An sg_attachments object cannot have both render- and storage-attachments. 1742 + 1743 + Each attachment definition consists of an image object, and two additional indices 1744 + describing which subimage the pass will render into: one mipmap index, and if the image 1745 + is a cubemap, array-texture or 3D-texture, the face-index, array-layer or 1746 + depth-slice. 1747 + 1748 + All attachments must have the same width and height. 1749 + 1750 + All color attachments and the depth-stencil attachment must have the 1751 + same sample count. 1752 + 1753 + If a resolve attachment is set, an MSAA-resolve operation from the 1754 + associated color attachment image into the resolve attachment image will take 1755 + place in the sg_end_pass() function. In this case, the color attachment 1756 + must have a (sample_count>1), and the resolve attachment a 1757 + (sample_count==1). The resolve attachment also must have the same pixel 1758 + format as the color attachment. 1759 + 1760 + NOTE that MSAA depth-stencil attachments cannot be msaa-resolved! 1761 +/ 1762 extern(C) struct AttachmentDesc { 1763 Image image = {}; 1764 int mip_level = 0; 1765 int slice = 0; 1766 } 1767 extern(C) struct AttachmentsDesc { 1768 uint _start_canary = 0; 1769 AttachmentDesc[4] colors = []; 1770 AttachmentDesc[4] resolves = []; 1771 AttachmentDesc depth_stencil = {}; 1772 AttachmentDesc[4] storages = []; 1773 const(char)* label = null; 1774 uint _end_canary = 0; 1775 } 1776 /++ 1777 + sg_trace_hooks 1778 + 1779 + Installable callback functions to keep track of the sokol-gfx calls, 1780 + this is useful for debugging, or keeping track of resource creation 1781 + and destruction. 1782 + 1783 + Trace hooks are installed with sg_install_trace_hooks(), this returns 1784 + another sg_trace_hooks struct with the previous set of 1785 + trace hook function pointers. These should be invoked by the 1786 + new trace hooks to form a proper call chain. 1787 +/ 1788 extern(C) struct TraceHooks { 1789 void* user_data = null; 1790 extern(C) void function(void*) reset_state_cache = null; 1791 extern(C) void function(const BufferDesc*, Buffer, void*) make_buffer = null; 1792 extern(C) void function(const ImageDesc*, Image, void*) make_image = null; 1793 extern(C) void function(const SamplerDesc*, Sampler, void*) make_sampler = null; 1794 extern(C) void function(const ShaderDesc*, Shader, void*) make_shader = null; 1795 extern(C) void function(const PipelineDesc*, Pipeline, void*) make_pipeline = null; 1796 extern(C) void function(const AttachmentsDesc*, Attachments, void*) make_attachments = null; 1797 extern(C) void function(Buffer, void*) destroy_buffer = null; 1798 extern(C) void function(Image, void*) destroy_image = null; 1799 extern(C) void function(Sampler, void*) destroy_sampler = null; 1800 extern(C) void function(Shader, void*) destroy_shader = null; 1801 extern(C) void function(Pipeline, void*) destroy_pipeline = null; 1802 extern(C) void function(Attachments, void*) destroy_attachments = null; 1803 extern(C) void function(Buffer, const Range*, void*) update_buffer = null; 1804 extern(C) void function(Image, const ImageData*, void*) update_image = null; 1805 extern(C) void function(Buffer, const Range*, int, void*) append_buffer = null; 1806 extern(C) void function(const Pass*, void*) begin_pass = null; 1807 extern(C) void function(int, int, int, int, bool, void*) apply_viewport = null; 1808 extern(C) void function(int, int, int, int, bool, void*) apply_scissor_rect = null; 1809 extern(C) void function(Pipeline, void*) apply_pipeline = null; 1810 extern(C) void function(const Bindings*, void*) apply_bindings = null; 1811 extern(C) void function(int, const Range*, void*) apply_uniforms = null; 1812 extern(C) void function(int, int, int, void*) draw = null; 1813 extern(C) void function(int, int, int, void*) dispatch = null; 1814 extern(C) void function(void*) end_pass = null; 1815 extern(C) void function(void*) commit = null; 1816 extern(C) void function(Buffer, void*) alloc_buffer = null; 1817 extern(C) void function(Image, void*) alloc_image = null; 1818 extern(C) void function(Sampler, void*) alloc_sampler = null; 1819 extern(C) void function(Shader, void*) alloc_shader = null; 1820 extern(C) void function(Pipeline, void*) alloc_pipeline = null; 1821 extern(C) void function(Attachments, void*) alloc_attachments = null; 1822 extern(C) void function(Buffer, void*) dealloc_buffer = null; 1823 extern(C) void function(Image, void*) dealloc_image = null; 1824 extern(C) void function(Sampler, void*) dealloc_sampler = null; 1825 extern(C) void function(Shader, void*) dealloc_shader = null; 1826 extern(C) void function(Pipeline, void*) dealloc_pipeline = null; 1827 extern(C) void function(Attachments, void*) dealloc_attachments = null; 1828 extern(C) void function(Buffer, const BufferDesc*, void*) init_buffer = null; 1829 extern(C) void function(Image, const ImageDesc*, void*) init_image = null; 1830 extern(C) void function(Sampler, const SamplerDesc*, void*) init_sampler = null; 1831 extern(C) void function(Shader, const ShaderDesc*, void*) init_shader = null; 1832 extern(C) void function(Pipeline, const PipelineDesc*, void*) init_pipeline = null; 1833 extern(C) void function(Attachments, const AttachmentsDesc*, void*) init_attachments = null; 1834 extern(C) void function(Buffer, void*) uninit_buffer = null; 1835 extern(C) void function(Image, void*) uninit_image = null; 1836 extern(C) void function(Sampler, void*) uninit_sampler = null; 1837 extern(C) void function(Shader, void*) uninit_shader = null; 1838 extern(C) void function(Pipeline, void*) uninit_pipeline = null; 1839 extern(C) void function(Attachments, void*) uninit_attachments = null; 1840 extern(C) void function(Buffer, void*) fail_buffer = null; 1841 extern(C) void function(Image, void*) fail_image = null; 1842 extern(C) void function(Sampler, void*) fail_sampler = null; 1843 extern(C) void function(Shader, void*) fail_shader = null; 1844 extern(C) void function(Pipeline, void*) fail_pipeline = null; 1845 extern(C) void function(Attachments, void*) fail_attachments = null; 1846 extern(C) void function(const(char)*, void*) push_debug_group = null; 1847 extern(C) void function(void*) pop_debug_group = null; 1848 } 1849 /++ 1850 + sg_buffer_info 1851 + sg_image_info 1852 + sg_sampler_info 1853 + sg_shader_info 1854 + sg_pipeline_info 1855 + sg_attachments_info 1856 + 1857 + These structs contain various internal resource attributes which 1858 + might be useful for debug-inspection. Please don't rely on the 1859 + actual content of those structs too much, as they are quite closely 1860 + tied to sokol_gfx.h internals and may change more frequently than 1861 + the other public API elements. 1862 + 1863 + The *_info structs are used as the return values of the following functions: 1864 + 1865 + sg_query_buffer_info() 1866 + sg_query_image_info() 1867 + sg_query_sampler_info() 1868 + sg_query_shader_info() 1869 + sg_query_pipeline_info() 1870 + sg_query_attachments_info() 1871 +/ 1872 extern(C) struct SlotInfo { 1873 ResourceState state = ResourceState.Initial; 1874 uint res_id = 0; 1875 uint uninit_count = 0; 1876 } 1877 extern(C) struct BufferInfo { 1878 SlotInfo slot = {}; 1879 uint update_frame_index = 0; 1880 uint append_frame_index = 0; 1881 int append_pos = 0; 1882 bool append_overflow = false; 1883 int num_slots = 0; 1884 int active_slot = 0; 1885 } 1886 extern(C) struct ImageInfo { 1887 SlotInfo slot = {}; 1888 uint upd_frame_index = 0; 1889 int num_slots = 0; 1890 int active_slot = 0; 1891 } 1892 extern(C) struct SamplerInfo { 1893 SlotInfo slot = {}; 1894 } 1895 extern(C) struct ShaderInfo { 1896 SlotInfo slot = {}; 1897 } 1898 extern(C) struct PipelineInfo { 1899 SlotInfo slot = {}; 1900 } 1901 extern(C) struct AttachmentsInfo { 1902 SlotInfo slot = {}; 1903 } 1904 /++ 1905 + sg_frame_stats 1906 + 1907 + Allows to track generic and backend-specific stats about a 1908 + render frame. Obtained by calling sg_query_frame_stats(). The returned 1909 + struct contains information about the *previous* frame. 1910 +/ 1911 extern(C) struct FrameStatsGl { 1912 uint num_bind_buffer = 0; 1913 uint num_active_texture = 0; 1914 uint num_bind_texture = 0; 1915 uint num_bind_sampler = 0; 1916 uint num_use_program = 0; 1917 uint num_render_state = 0; 1918 uint num_vertex_attrib_pointer = 0; 1919 uint num_vertex_attrib_divisor = 0; 1920 uint num_enable_vertex_attrib_array = 0; 1921 uint num_disable_vertex_attrib_array = 0; 1922 uint num_uniform = 0; 1923 uint num_memory_barriers = 0; 1924 } 1925 extern(C) struct FrameStatsD3d11Pass { 1926 uint num_om_set_render_targets = 0; 1927 uint num_clear_render_target_view = 0; 1928 uint num_clear_depth_stencil_view = 0; 1929 uint num_resolve_subresource = 0; 1930 } 1931 extern(C) struct FrameStatsD3d11Pipeline { 1932 uint num_rs_set_state = 0; 1933 uint num_om_set_depth_stencil_state = 0; 1934 uint num_om_set_blend_state = 0; 1935 uint num_ia_set_primitive_topology = 0; 1936 uint num_ia_set_input_layout = 0; 1937 uint num_vs_set_shader = 0; 1938 uint num_vs_set_constant_buffers = 0; 1939 uint num_ps_set_shader = 0; 1940 uint num_ps_set_constant_buffers = 0; 1941 uint num_cs_set_shader = 0; 1942 uint num_cs_set_constant_buffers = 0; 1943 } 1944 extern(C) struct FrameStatsD3d11Bindings { 1945 uint num_ia_set_vertex_buffers = 0; 1946 uint num_ia_set_index_buffer = 0; 1947 uint num_vs_set_shader_resources = 0; 1948 uint num_vs_set_samplers = 0; 1949 uint num_ps_set_shader_resources = 0; 1950 uint num_ps_set_samplers = 0; 1951 uint num_cs_set_shader_resources = 0; 1952 uint num_cs_set_samplers = 0; 1953 uint num_cs_set_unordered_access_views = 0; 1954 } 1955 extern(C) struct FrameStatsD3d11Uniforms { 1956 uint num_update_subresource = 0; 1957 } 1958 extern(C) struct FrameStatsD3d11Draw { 1959 uint num_draw_indexed_instanced = 0; 1960 uint num_draw_indexed = 0; 1961 uint num_draw_instanced = 0; 1962 uint num_draw = 0; 1963 } 1964 extern(C) struct FrameStatsD3d11 { 1965 FrameStatsD3d11Pass pass = {}; 1966 FrameStatsD3d11Pipeline pipeline = {}; 1967 FrameStatsD3d11Bindings bindings = {}; 1968 FrameStatsD3d11Uniforms uniforms = {}; 1969 FrameStatsD3d11Draw draw = {}; 1970 uint num_map = 0; 1971 uint num_unmap = 0; 1972 } 1973 extern(C) struct FrameStatsMetalIdpool { 1974 uint num_added = 0; 1975 uint num_released = 0; 1976 uint num_garbage_collected = 0; 1977 } 1978 extern(C) struct FrameStatsMetalPipeline { 1979 uint num_set_blend_color = 0; 1980 uint num_set_cull_mode = 0; 1981 uint num_set_front_facing_winding = 0; 1982 uint num_set_stencil_reference_value = 0; 1983 uint num_set_depth_bias = 0; 1984 uint num_set_render_pipeline_state = 0; 1985 uint num_set_depth_stencil_state = 0; 1986 } 1987 extern(C) struct FrameStatsMetalBindings { 1988 uint num_set_vertex_buffer = 0; 1989 uint num_set_vertex_texture = 0; 1990 uint num_set_vertex_sampler_state = 0; 1991 uint num_set_fragment_buffer = 0; 1992 uint num_set_fragment_texture = 0; 1993 uint num_set_fragment_sampler_state = 0; 1994 uint num_set_compute_buffer = 0; 1995 uint num_set_compute_texture = 0; 1996 uint num_set_compute_sampler_state = 0; 1997 } 1998 extern(C) struct FrameStatsMetalUniforms { 1999 uint num_set_vertex_buffer_offset = 0; 2000 uint num_set_fragment_buffer_offset = 0; 2001 uint num_set_compute_buffer_offset = 0; 2002 } 2003 extern(C) struct FrameStatsMetal { 2004 FrameStatsMetalIdpool idpool = {}; 2005 FrameStatsMetalPipeline pipeline = {}; 2006 FrameStatsMetalBindings bindings = {}; 2007 FrameStatsMetalUniforms uniforms = {}; 2008 } 2009 extern(C) struct FrameStatsWgpuUniforms { 2010 uint num_set_bindgroup = 0; 2011 uint size_write_buffer = 0; 2012 } 2013 extern(C) struct FrameStatsWgpuBindings { 2014 uint num_set_vertex_buffer = 0; 2015 uint num_skip_redundant_vertex_buffer = 0; 2016 uint num_set_index_buffer = 0; 2017 uint num_skip_redundant_index_buffer = 0; 2018 uint num_create_bindgroup = 0; 2019 uint num_discard_bindgroup = 0; 2020 uint num_set_bindgroup = 0; 2021 uint num_skip_redundant_bindgroup = 0; 2022 uint num_bindgroup_cache_hits = 0; 2023 uint num_bindgroup_cache_misses = 0; 2024 uint num_bindgroup_cache_collisions = 0; 2025 uint num_bindgroup_cache_invalidates = 0; 2026 uint num_bindgroup_cache_hash_vs_key_mismatch = 0; 2027 } 2028 extern(C) struct FrameStatsWgpu { 2029 FrameStatsWgpuUniforms uniforms = {}; 2030 FrameStatsWgpuBindings bindings = {}; 2031 } 2032 extern(C) struct FrameStats { 2033 uint frame_index = 0; 2034 uint num_passes = 0; 2035 uint num_apply_viewport = 0; 2036 uint num_apply_scissor_rect = 0; 2037 uint num_apply_pipeline = 0; 2038 uint num_apply_bindings = 0; 2039 uint num_apply_uniforms = 0; 2040 uint num_draw = 0; 2041 uint num_dispatch = 0; 2042 uint num_update_buffer = 0; 2043 uint num_append_buffer = 0; 2044 uint num_update_image = 0; 2045 uint size_apply_uniforms = 0; 2046 uint size_update_buffer = 0; 2047 uint size_append_buffer = 0; 2048 uint size_update_image = 0; 2049 FrameStatsGl gl = {}; 2050 FrameStatsD3d11 d3d11 = {}; 2051 FrameStatsMetal metal = {}; 2052 FrameStatsWgpu wgpu = {}; 2053 } 2054 enum LogItem { 2055 Ok, 2056 Malloc_failed, 2057 Gl_texture_format_not_supported, 2058 Gl_3d_textures_not_supported, 2059 Gl_array_textures_not_supported, 2060 Gl_storagebuffer_glsl_binding_out_of_range, 2061 Gl_storageimage_glsl_binding_out_of_range, 2062 Gl_shader_compilation_failed, 2063 Gl_shader_linking_failed, 2064 Gl_vertex_attribute_not_found_in_shader, 2065 Gl_uniformblock_name_not_found_in_shader, 2066 Gl_image_sampler_name_not_found_in_shader, 2067 Gl_framebuffer_status_undefined, 2068 Gl_framebuffer_status_incomplete_attachment, 2069 Gl_framebuffer_status_incomplete_missing_attachment, 2070 Gl_framebuffer_status_unsupported, 2071 Gl_framebuffer_status_incomplete_multisample, 2072 Gl_framebuffer_status_unknown, 2073 D3d11_create_buffer_failed, 2074 D3d11_create_buffer_srv_failed, 2075 D3d11_create_buffer_uav_failed, 2076 D3d11_create_depth_texture_unsupported_pixel_format, 2077 D3d11_create_depth_texture_failed, 2078 D3d11_create_2d_texture_unsupported_pixel_format, 2079 D3d11_create_2d_texture_failed, 2080 D3d11_create_2d_srv_failed, 2081 D3d11_create_3d_texture_unsupported_pixel_format, 2082 D3d11_create_3d_texture_failed, 2083 D3d11_create_3d_srv_failed, 2084 D3d11_create_msaa_texture_failed, 2085 D3d11_create_sampler_state_failed, 2086 D3d11_uniformblock_hlsl_register_b_out_of_range, 2087 D3d11_storagebuffer_hlsl_register_t_out_of_range, 2088 D3d11_storagebuffer_hlsl_register_u_out_of_range, 2089 D3d11_image_hlsl_register_t_out_of_range, 2090 D3d11_sampler_hlsl_register_s_out_of_range, 2091 D3d11_storageimage_hlsl_register_u_out_of_range, 2092 D3d11_load_d3dcompiler_47_dll_failed, 2093 D3d11_shader_compilation_failed, 2094 D3d11_shader_compilation_output, 2095 D3d11_create_constant_buffer_failed, 2096 D3d11_create_input_layout_failed, 2097 D3d11_create_rasterizer_state_failed, 2098 D3d11_create_depth_stencil_state_failed, 2099 D3d11_create_blend_state_failed, 2100 D3d11_create_rtv_failed, 2101 D3d11_create_dsv_failed, 2102 D3d11_create_uav_failed, 2103 D3d11_map_for_update_buffer_failed, 2104 D3d11_map_for_append_buffer_failed, 2105 D3d11_map_for_update_image_failed, 2106 Metal_create_buffer_failed, 2107 Metal_texture_format_not_supported, 2108 Metal_create_texture_failed, 2109 Metal_create_sampler_failed, 2110 Metal_shader_compilation_failed, 2111 Metal_shader_creation_failed, 2112 Metal_shader_compilation_output, 2113 Metal_shader_entry_not_found, 2114 Metal_uniformblock_msl_buffer_slot_out_of_range, 2115 Metal_storagebuffer_msl_buffer_slot_out_of_range, 2116 Metal_storageimage_msl_texture_slot_out_of_range, 2117 Metal_image_msl_texture_slot_out_of_range, 2118 Metal_sampler_msl_sampler_slot_out_of_range, 2119 Metal_create_cps_failed, 2120 Metal_create_cps_output, 2121 Metal_create_rps_failed, 2122 Metal_create_rps_output, 2123 Metal_create_dss_failed, 2124 Wgpu_bindgroups_pool_exhausted, 2125 Wgpu_bindgroupscache_size_greater_one, 2126 Wgpu_bindgroupscache_size_pow2, 2127 Wgpu_createbindgroup_failed, 2128 Wgpu_create_buffer_failed, 2129 Wgpu_create_texture_failed, 2130 Wgpu_create_texture_view_failed, 2131 Wgpu_create_sampler_failed, 2132 Wgpu_create_shader_module_failed, 2133 Wgpu_shader_create_bindgroup_layout_failed, 2134 Wgpu_uniformblock_wgsl_group0_binding_out_of_range, 2135 Wgpu_storagebuffer_wgsl_group1_binding_out_of_range, 2136 Wgpu_image_wgsl_group1_binding_out_of_range, 2137 Wgpu_sampler_wgsl_group1_binding_out_of_range, 2138 Wgpu_storageimage_wgsl_group2_binding_out_of_range, 2139 Wgpu_create_pipeline_layout_failed, 2140 Wgpu_create_render_pipeline_failed, 2141 Wgpu_create_compute_pipeline_failed, 2142 Wgpu_attachments_create_texture_view_failed, 2143 Identical_commit_listener, 2144 Commit_listener_array_full, 2145 Trace_hooks_not_enabled, 2146 Dealloc_buffer_invalid_state, 2147 Dealloc_image_invalid_state, 2148 Dealloc_sampler_invalid_state, 2149 Dealloc_shader_invalid_state, 2150 Dealloc_pipeline_invalid_state, 2151 Dealloc_attachments_invalid_state, 2152 Init_buffer_invalid_state, 2153 Init_image_invalid_state, 2154 Init_sampler_invalid_state, 2155 Init_shader_invalid_state, 2156 Init_pipeline_invalid_state, 2157 Init_attachments_invalid_state, 2158 Uninit_buffer_invalid_state, 2159 Uninit_image_invalid_state, 2160 Uninit_sampler_invalid_state, 2161 Uninit_shader_invalid_state, 2162 Uninit_pipeline_invalid_state, 2163 Uninit_attachments_invalid_state, 2164 Fail_buffer_invalid_state, 2165 Fail_image_invalid_state, 2166 Fail_sampler_invalid_state, 2167 Fail_shader_invalid_state, 2168 Fail_pipeline_invalid_state, 2169 Fail_attachments_invalid_state, 2170 Buffer_pool_exhausted, 2171 Image_pool_exhausted, 2172 Sampler_pool_exhausted, 2173 Shader_pool_exhausted, 2174 Pipeline_pool_exhausted, 2175 Pass_pool_exhausted, 2176 Beginpass_attachment_invalid, 2177 Apply_bindings_storage_buffer_tracker_exhausted, 2178 Draw_without_bindings, 2179 Validate_bufferdesc_canary, 2180 Validate_bufferdesc_immutable_dynamic_stream, 2181 Validate_bufferdesc_separate_buffer_types, 2182 Validate_bufferdesc_expect_nonzero_size, 2183 Validate_bufferdesc_expect_matching_data_size, 2184 Validate_bufferdesc_expect_zero_data_size, 2185 Validate_bufferdesc_expect_no_data, 2186 Validate_bufferdesc_expect_data, 2187 Validate_bufferdesc_storagebuffer_supported, 2188 Validate_bufferdesc_storagebuffer_size_multiple_4, 2189 Validate_imagedata_nodata, 2190 Validate_imagedata_data_size, 2191 Validate_imagedesc_canary, 2192 Validate_imagedesc_immutable_dynamic_stream, 2193 Validate_imagedesc_render_vs_storage_attachment, 2194 Validate_imagedesc_width, 2195 Validate_imagedesc_height, 2196 Validate_imagedesc_nonrt_pixelformat, 2197 Validate_imagedesc_msaa_but_no_attachment, 2198 Validate_imagedesc_depth_3d_image, 2199 Validate_imagedesc_attachment_expect_immutable, 2200 Validate_imagedesc_attachment_expect_no_data, 2201 Validate_imagedesc_renderattachment_no_msaa_support, 2202 Validate_imagedesc_renderattachment_msaa_num_mipmaps, 2203 Validate_imagedesc_renderattachment_msaa_3d_image, 2204 Validate_imagedesc_renderattachment_msaa_cube_image, 2205 Validate_imagedesc_renderattachment_msaa_array_image, 2206 Validate_imagedesc_renderattachment_pixelformat, 2207 Validate_imagedesc_storageattachment_pixelformat, 2208 Validate_imagedesc_storageattachment_expect_no_msaa, 2209 Validate_imagedesc_injected_no_data, 2210 Validate_imagedesc_dynamic_no_data, 2211 Validate_imagedesc_compressed_immutable, 2212 Validate_samplerdesc_canary, 2213 Validate_samplerdesc_anistropic_requires_linear_filtering, 2214 Validate_shaderdesc_canary, 2215 Validate_shaderdesc_vertex_source, 2216 Validate_shaderdesc_fragment_source, 2217 Validate_shaderdesc_compute_source, 2218 Validate_shaderdesc_vertex_source_or_bytecode, 2219 Validate_shaderdesc_fragment_source_or_bytecode, 2220 Validate_shaderdesc_compute_source_or_bytecode, 2221 Validate_shaderdesc_invalid_shader_combo, 2222 Validate_shaderdesc_no_bytecode_size, 2223 Validate_shaderdesc_metal_threads_per_threadgroup, 2224 Validate_shaderdesc_uniformblock_no_cont_members, 2225 Validate_shaderdesc_uniformblock_size_is_zero, 2226 Validate_shaderdesc_uniformblock_metal_buffer_slot_out_of_range, 2227 Validate_shaderdesc_uniformblock_metal_buffer_slot_collision, 2228 Validate_shaderdesc_uniformblock_hlsl_register_b_out_of_range, 2229 Validate_shaderdesc_uniformblock_hlsl_register_b_collision, 2230 Validate_shaderdesc_uniformblock_wgsl_group0_binding_out_of_range, 2231 Validate_shaderdesc_uniformblock_wgsl_group0_binding_collision, 2232 Validate_shaderdesc_uniformblock_no_members, 2233 Validate_shaderdesc_uniformblock_uniform_glsl_name, 2234 Validate_shaderdesc_uniformblock_size_mismatch, 2235 Validate_shaderdesc_uniformblock_array_count, 2236 Validate_shaderdesc_uniformblock_std140_array_type, 2237 Validate_shaderdesc_storagebuffer_metal_buffer_slot_out_of_range, 2238 Validate_shaderdesc_storagebuffer_metal_buffer_slot_collision, 2239 Validate_shaderdesc_storagebuffer_hlsl_register_t_out_of_range, 2240 Validate_shaderdesc_storagebuffer_hlsl_register_t_collision, 2241 Validate_shaderdesc_storagebuffer_hlsl_register_u_out_of_range, 2242 Validate_shaderdesc_storagebuffer_hlsl_register_u_collision, 2243 Validate_shaderdesc_storagebuffer_glsl_binding_out_of_range, 2244 Validate_shaderdesc_storagebuffer_glsl_binding_collision, 2245 Validate_shaderdesc_storagebuffer_wgsl_group1_binding_out_of_range, 2246 Validate_shaderdesc_storagebuffer_wgsl_group1_binding_collision, 2247 Validate_shaderdesc_storageimage_expect_compute_stage, 2248 Validate_shaderdesc_storageimage_metal_texture_slot_out_of_range, 2249 Validate_shaderdesc_storageimage_metal_texture_slot_collision, 2250 Validate_shaderdesc_storageimage_hlsl_register_u_out_of_range, 2251 Validate_shaderdesc_storageimage_hlsl_register_u_collision, 2252 Validate_shaderdesc_storageimage_glsl_binding_out_of_range, 2253 Validate_shaderdesc_storageimage_glsl_binding_collision, 2254 Validate_shaderdesc_storageimage_wgsl_group2_binding_out_of_range, 2255 Validate_shaderdesc_storageimage_wgsl_group2_binding_collision, 2256 Validate_shaderdesc_image_metal_texture_slot_out_of_range, 2257 Validate_shaderdesc_image_metal_texture_slot_collision, 2258 Validate_shaderdesc_image_hlsl_register_t_out_of_range, 2259 Validate_shaderdesc_image_hlsl_register_t_collision, 2260 Validate_shaderdesc_image_wgsl_group1_binding_out_of_range, 2261 Validate_shaderdesc_image_wgsl_group1_binding_collision, 2262 Validate_shaderdesc_sampler_metal_sampler_slot_out_of_range, 2263 Validate_shaderdesc_sampler_metal_sampler_slot_collision, 2264 Validate_shaderdesc_sampler_hlsl_register_s_out_of_range, 2265 Validate_shaderdesc_sampler_hlsl_register_s_collision, 2266 Validate_shaderdesc_sampler_wgsl_group1_binding_out_of_range, 2267 Validate_shaderdesc_sampler_wgsl_group1_binding_collision, 2268 Validate_shaderdesc_image_sampler_pair_image_slot_out_of_range, 2269 Validate_shaderdesc_image_sampler_pair_sampler_slot_out_of_range, 2270 Validate_shaderdesc_image_sampler_pair_image_stage_mismatch, 2271 Validate_shaderdesc_image_sampler_pair_sampler_stage_mismatch, 2272 Validate_shaderdesc_image_sampler_pair_glsl_name, 2273 Validate_shaderdesc_nonfiltering_sampler_required, 2274 Validate_shaderdesc_comparison_sampler_required, 2275 Validate_shaderdesc_image_not_referenced_by_image_sampler_pairs, 2276 Validate_shaderdesc_sampler_not_referenced_by_image_sampler_pairs, 2277 Validate_shaderdesc_attr_string_too_long, 2278 Validate_pipelinedesc_canary, 2279 Validate_pipelinedesc_shader, 2280 Validate_pipelinedesc_compute_shader_expected, 2281 Validate_pipelinedesc_no_compute_shader_expected, 2282 Validate_pipelinedesc_no_cont_attrs, 2283 Validate_pipelinedesc_attr_basetype_mismatch, 2284 Validate_pipelinedesc_layout_stride4, 2285 Validate_pipelinedesc_attr_semantics, 2286 Validate_pipelinedesc_shader_readonly_storagebuffers, 2287 Validate_pipelinedesc_blendop_minmax_requires_blendfactor_one, 2288 Validate_attachmentsdesc_canary, 2289 Validate_attachmentsdesc_no_attachments, 2290 Validate_attachmentsdesc_no_cont_color_atts, 2291 Validate_attachmentsdesc_color_image, 2292 Validate_attachmentsdesc_color_miplevel, 2293 Validate_attachmentsdesc_color_face, 2294 Validate_attachmentsdesc_color_layer, 2295 Validate_attachmentsdesc_color_slice, 2296 Validate_attachmentsdesc_color_image_no_renderattachment, 2297 Validate_attachmentsdesc_color_inv_pixelformat, 2298 Validate_attachmentsdesc_image_sizes, 2299 Validate_attachmentsdesc_image_sample_counts, 2300 Validate_attachmentsdesc_resolve_color_image_msaa, 2301 Validate_attachmentsdesc_resolve_image, 2302 Validate_attachmentsdesc_resolve_sample_count, 2303 Validate_attachmentsdesc_resolve_miplevel, 2304 Validate_attachmentsdesc_resolve_face, 2305 Validate_attachmentsdesc_resolve_layer, 2306 Validate_attachmentsdesc_resolve_slice, 2307 Validate_attachmentsdesc_resolve_image_no_rt, 2308 Validate_attachmentsdesc_resolve_image_sizes, 2309 Validate_attachmentsdesc_resolve_image_format, 2310 Validate_attachmentsdesc_depth_inv_pixelformat, 2311 Validate_attachmentsdesc_depth_image, 2312 Validate_attachmentsdesc_depth_miplevel, 2313 Validate_attachmentsdesc_depth_face, 2314 Validate_attachmentsdesc_depth_layer, 2315 Validate_attachmentsdesc_depth_slice, 2316 Validate_attachmentsdesc_depth_image_no_renderattachment, 2317 Validate_attachmentsdesc_depth_image_sizes, 2318 Validate_attachmentsdesc_depth_image_sample_count, 2319 Validate_attachmentsdesc_storage_image, 2320 Validate_attachmentsdesc_storage_miplevel, 2321 Validate_attachmentsdesc_storage_face, 2322 Validate_attachmentsdesc_storage_layer, 2323 Validate_attachmentsdesc_storage_slice, 2324 Validate_attachmentsdesc_storage_image_no_storageattachment, 2325 Validate_attachmentsdesc_storage_inv_pixelformat, 2326 Validate_attachmentsdesc_render_vs_storage_attachments, 2327 Validate_beginpass_canary, 2328 Validate_beginpass_attachments_exists, 2329 Validate_beginpass_attachments_valid, 2330 Validate_beginpass_computepass_storage_attachments_only, 2331 Validate_beginpass_renderpass_render_attachments_only, 2332 Validate_beginpass_color_attachment_image_alive, 2333 Validate_beginpass_color_attachment_image_valid, 2334 Validate_beginpass_resolve_attachment_image_alive, 2335 Validate_beginpass_resolve_attachment_image_valid, 2336 Validate_beginpass_depthstencil_attachment_image_alive, 2337 Validate_beginpass_depthstencil_attachment_image_valid, 2338 Validate_beginpass_storage_attachment_image_alive, 2339 Validate_beginpass_storage_attachment_image_valid, 2340 Validate_beginpass_swapchain_expect_width, 2341 Validate_beginpass_swapchain_expect_width_notset, 2342 Validate_beginpass_swapchain_expect_height, 2343 Validate_beginpass_swapchain_expect_height_notset, 2344 Validate_beginpass_swapchain_expect_samplecount, 2345 Validate_beginpass_swapchain_expect_samplecount_notset, 2346 Validate_beginpass_swapchain_expect_colorformat, 2347 Validate_beginpass_swapchain_expect_colorformat_notset, 2348 Validate_beginpass_swapchain_expect_depthformat_notset, 2349 Validate_beginpass_swapchain_metal_expect_currentdrawable, 2350 Validate_beginpass_swapchain_metal_expect_currentdrawable_notset, 2351 Validate_beginpass_swapchain_metal_expect_depthstenciltexture, 2352 Validate_beginpass_swapchain_metal_expect_depthstenciltexture_notset, 2353 Validate_beginpass_swapchain_metal_expect_msaacolortexture, 2354 Validate_beginpass_swapchain_metal_expect_msaacolortexture_notset, 2355 Validate_beginpass_swapchain_d3d11_expect_renderview, 2356 Validate_beginpass_swapchain_d3d11_expect_renderview_notset, 2357 Validate_beginpass_swapchain_d3d11_expect_resolveview, 2358 Validate_beginpass_swapchain_d3d11_expect_resolveview_notset, 2359 Validate_beginpass_swapchain_d3d11_expect_depthstencilview, 2360 Validate_beginpass_swapchain_d3d11_expect_depthstencilview_notset, 2361 Validate_beginpass_swapchain_wgpu_expect_renderview, 2362 Validate_beginpass_swapchain_wgpu_expect_renderview_notset, 2363 Validate_beginpass_swapchain_wgpu_expect_resolveview, 2364 Validate_beginpass_swapchain_wgpu_expect_resolveview_notset, 2365 Validate_beginpass_swapchain_wgpu_expect_depthstencilview, 2366 Validate_beginpass_swapchain_wgpu_expect_depthstencilview_notset, 2367 Validate_beginpass_swapchain_gl_expect_framebuffer_notset, 2368 Validate_avp_renderpass_expected, 2369 Validate_asr_renderpass_expected, 2370 Validate_apip_pipeline_valid_id, 2371 Validate_apip_pipeline_exists, 2372 Validate_apip_pipeline_valid, 2373 Validate_apip_pass_expected, 2374 Validate_apip_pipeline_shader_alive, 2375 Validate_apip_pipeline_shader_valid, 2376 Validate_apip_computepass_expected, 2377 Validate_apip_renderpass_expected, 2378 Validate_apip_curpass_attachments_alive, 2379 Validate_apip_curpass_attachments_valid, 2380 Validate_apip_att_count, 2381 Validate_apip_color_attachment_image_alive, 2382 Validate_apip_color_attachment_image_valid, 2383 Validate_apip_depthstencil_attachment_image_alive, 2384 Validate_apip_depthstencil_attachment_image_valid, 2385 Validate_apip_color_format, 2386 Validate_apip_depth_format, 2387 Validate_apip_sample_count, 2388 Validate_apip_expected_storage_attachment_image, 2389 Validate_apip_storage_attachment_image_alive, 2390 Validate_apip_storage_attachment_image_valid, 2391 Validate_apip_storage_attachment_pixelformat, 2392 Validate_apip_storage_attachment_image_type, 2393 Validate_abnd_pass_expected, 2394 Validate_abnd_empty_bindings, 2395 Validate_abnd_no_pipeline, 2396 Validate_abnd_pipeline_alive, 2397 Validate_abnd_pipeline_valid, 2398 Validate_abnd_pipeline_shader_alive, 2399 Validate_abnd_pipeline_shader_valid, 2400 Validate_abnd_compute_expected_no_vbs, 2401 Validate_abnd_compute_expected_no_ib, 2402 Validate_abnd_expected_vb, 2403 Validate_abnd_vb_alive, 2404 Validate_abnd_vb_type, 2405 Validate_abnd_vb_overflow, 2406 Validate_abnd_no_ib, 2407 Validate_abnd_ib, 2408 Validate_abnd_ib_alive, 2409 Validate_abnd_ib_type, 2410 Validate_abnd_ib_overflow, 2411 Validate_abnd_expected_image_binding, 2412 Validate_abnd_img_alive, 2413 Validate_abnd_image_type_mismatch, 2414 Validate_abnd_expected_multisampled_image, 2415 Validate_abnd_image_msaa, 2416 Validate_abnd_expected_filterable_image, 2417 Validate_abnd_expected_depth_image, 2418 Validate_abnd_expected_sampler_binding, 2419 Validate_abnd_unexpected_sampler_compare_never, 2420 Validate_abnd_expected_sampler_compare_never, 2421 Validate_abnd_expected_nonfiltering_sampler, 2422 Validate_abnd_smp_alive, 2423 Validate_abnd_smp_valid, 2424 Validate_abnd_expected_storagebuffer_binding, 2425 Validate_abnd_storagebuffer_alive, 2426 Validate_abnd_storagebuffer_binding_buffertype, 2427 Validate_abnd_storagebuffer_readwrite_immutable, 2428 Validate_abnd_image_binding_vs_depthstencil_attachment, 2429 Validate_abnd_image_binding_vs_color_attachment, 2430 Validate_abnd_image_binding_vs_resolve_attachment, 2431 Validate_abnd_image_binding_vs_storage_attachment, 2432 Validate_au_pass_expected, 2433 Validate_au_no_pipeline, 2434 Validate_au_pipeline_alive, 2435 Validate_au_pipeline_valid, 2436 Validate_au_pipeline_shader_alive, 2437 Validate_au_pipeline_shader_valid, 2438 Validate_au_no_uniformblock_at_slot, 2439 Validate_au_size, 2440 Validate_draw_renderpass_expected, 2441 Validate_draw_baseelement, 2442 Validate_draw_numelements, 2443 Validate_draw_numinstances, 2444 Validate_draw_required_bindings_or_uniforms_missing, 2445 Validate_dispatch_computepass_expected, 2446 Validate_dispatch_numgroupsx, 2447 Validate_dispatch_numgroupsy, 2448 Validate_dispatch_numgroupsz, 2449 Validate_dispatch_required_bindings_or_uniforms_missing, 2450 Validate_updatebuf_usage, 2451 Validate_updatebuf_size, 2452 Validate_updatebuf_once, 2453 Validate_updatebuf_append, 2454 Validate_appendbuf_usage, 2455 Validate_appendbuf_size, 2456 Validate_appendbuf_update, 2457 Validate_updimg_usage, 2458 Validate_updimg_once, 2459 Validation_failed, 2460 } 2461 /++ 2462 + sg_desc 2463 + 2464 + The sg_desc struct contains configuration values for sokol_gfx, 2465 + it is used as parameter to the sg_setup() call. 2466 + 2467 + The default configuration is: 2468 + 2469 + .buffer_pool_size 128 2470 + .image_pool_size 128 2471 + .sampler_pool_size 64 2472 + .shader_pool_size 32 2473 + .pipeline_pool_size 64 2474 + .attachments_pool_size 16 2475 + .uniform_buffer_size 4 MB (4*1024*1024) 2476 + .max_dispatch_calls_per_pass 1024 2477 + .max_commit_listeners 1024 2478 + .disable_validation false 2479 + .mtl_force_managed_storage_mode false 2480 + .wgpu_disable_bindgroups_cache false 2481 + .wgpu_bindgroups_cache_size 1024 2482 + 2483 + .allocator.alloc_fn 0 (in this case, malloc() will be called) 2484 + .allocator.free_fn 0 (in this case, free() will be called) 2485 + .allocator.user_data 0 2486 + 2487 + .environment.defaults.color_format: default value depends on selected backend: 2488 + all GL backends: SG_PIXELFORMAT_RGBA8 2489 + Metal and D3D11: SG_PIXELFORMAT_BGRA8 2490 + WebGPU: *no default* (must be queried from WebGPU swapchain object) 2491 + .environment.defaults.depth_format: SG_PIXELFORMAT_DEPTH_STENCIL 2492 + .environment.defaults.sample_count: 1 2493 + 2494 + Metal specific: 2495 + (NOTE: All Objective-C object references are transferred through 2496 + a bridged cast (__bridge const void*) to sokol_gfx, which will use an 2497 + unretained bridged cast (__bridge id<xxx>) to retrieve the Objective-C 2498 + references back. Since the bridge cast is unretained, the caller 2499 + must hold a strong reference to the Objective-C object until sg_setup() 2500 + returns. 2501 + 2502 + .mtl_force_managed_storage_mode 2503 + when enabled, Metal buffers and texture resources are created in managed storage 2504 + mode, otherwise sokol-gfx will decide whether to create buffers and 2505 + textures in managed or shared storage mode (this is mainly a debugging option) 2506 + .mtl_use_command_buffer_with_retained_references 2507 + when true, the sokol-gfx Metal backend will use Metal command buffers which 2508 + bump the reference count of resource objects as long as they are inflight, 2509 + this is slower than the default command-buffer-with-unretained-references 2510 + method, this may be a workaround when confronted with lifetime validation 2511 + errors from the Metal validation layer until a proper fix has been implemented 2512 + .environment.metal.device 2513 + a pointer to the MTLDevice object 2514 + 2515 + D3D11 specific: 2516 + .environment.d3d11.device 2517 + a pointer to the ID3D11Device object, this must have been created 2518 + before sg_setup() is called 2519 + .environment.d3d11.device_context 2520 + a pointer to the ID3D11DeviceContext object 2521 + .d3d11_shader_debugging 2522 + set this to true to compile shaders which are provided as HLSL source 2523 + code with debug information and without optimization, this allows 2524 + shader debugging in tools like RenderDoc, to output source code 2525 + instead of byte code from sokol-shdc, omit the `--binary` cmdline 2526 + option 2527 + 2528 + WebGPU specific: 2529 + .wgpu_disable_bindgroups_cache 2530 + When this is true, the WebGPU backend will create and immediately 2531 + release a BindGroup object in the sg_apply_bindings() call, only 2532 + use this for debugging purposes. 2533 + .wgpu_bindgroups_cache_size 2534 + The size of the bindgroups cache for re-using BindGroup objects 2535 + between sg_apply_bindings() calls. The smaller the cache size, 2536 + the more likely are cache slot collisions which will cause 2537 + a BindGroups object to be destroyed and a new one created. 2538 + Use the information returned by sg_query_stats() to check 2539 + if this is a frequent occurrence, and increase the cache size as 2540 + needed (the default is 1024). 2541 + NOTE: wgpu_bindgroups_cache_size must be a power-of-2 number! 2542 + .environment.wgpu.device 2543 + a WGPUDevice handle 2544 + 2545 + When using sokol_gfx.h and sokol_app.h together, consider using the 2546 + helper function sglue_environment() in the sokol_glue.h header to 2547 + initialize the sg_desc.environment nested struct. sglue_environment() returns 2548 + a completely initialized sg_environment struct with information 2549 + provided by sokol_app.h. 2550 +/ 2551 extern(C) struct EnvironmentDefaults { 2552 PixelFormat color_format = PixelFormat.Default; 2553 PixelFormat depth_format = PixelFormat.Default; 2554 int sample_count = 0; 2555 } 2556 extern(C) struct MetalEnvironment { 2557 const(void)* device = null; 2558 } 2559 extern(C) struct D3d11Environment { 2560 const(void)* device = null; 2561 const(void)* device_context = null; 2562 } 2563 extern(C) struct WgpuEnvironment { 2564 const(void)* device = null; 2565 } 2566 extern(C) struct Environment { 2567 EnvironmentDefaults defaults = {}; 2568 MetalEnvironment metal = {}; 2569 D3d11Environment d3d11 = {}; 2570 WgpuEnvironment wgpu = {}; 2571 } 2572 /++ 2573 + sg_commit_listener 2574 + 2575 + Used with function sg_add_commit_listener() to add a callback 2576 + which will be called in sg_commit(). This is useful for libraries 2577 + building on top of sokol-gfx to be notified about when a frame 2578 + ends (instead of having to guess, or add a manual 'new-frame' 2579 + function. 2580 +/ 2581 extern(C) struct CommitListener { 2582 extern(C) void function(void*) func = null; 2583 void* user_data = null; 2584 } 2585 /++ 2586 + sg_allocator 2587 + 2588 + Used in sg_desc to provide custom memory-alloc and -free functions 2589 + to sokol_gfx.h. If memory management should be overridden, both the 2590 + alloc_fn and free_fn function must be provided (e.g. it's not valid to 2591 + override one function but not the other). 2592 +/ 2593 extern(C) struct Allocator { 2594 extern(C) void* function(size_t, void*) alloc_fn = null; 2595 extern(C) void function(void*, void*) free_fn = null; 2596 void* user_data = null; 2597 } 2598 /++ 2599 + sg_logger 2600 + 2601 + Used in sg_desc to provide a logging function. Please be aware 2602 + that without logging function, sokol-gfx will be completely 2603 + silent, e.g. it will not report errors, warnings and 2604 + validation layer messages. For maximum error verbosity, 2605 + compile in debug mode (e.g. NDEBUG *not* defined) and provide a 2606 + compatible logger function in the sg_setup() call 2607 + (for instance the standard logging function from sokol_log.h). 2608 +/ 2609 extern(C) struct Logger { 2610 extern(C) void function(const(char)*, uint, uint, const(char)*, uint, const(char)*, void*) func = null; 2611 void* user_data = null; 2612 } 2613 extern(C) struct Desc { 2614 uint _start_canary = 0; 2615 int buffer_pool_size = 0; 2616 int image_pool_size = 0; 2617 int sampler_pool_size = 0; 2618 int shader_pool_size = 0; 2619 int pipeline_pool_size = 0; 2620 int attachments_pool_size = 0; 2621 int uniform_buffer_size = 0; 2622 int max_dispatch_calls_per_pass = 0; 2623 int max_commit_listeners = 0; 2624 bool disable_validation = false; 2625 bool d3d11_shader_debugging = false; 2626 bool mtl_force_managed_storage_mode = false; 2627 bool mtl_use_command_buffer_with_retained_references = false; 2628 bool wgpu_disable_bindgroups_cache = false; 2629 int wgpu_bindgroups_cache_size = 0; 2630 Allocator allocator = {}; 2631 Logger logger = {}; 2632 Environment environment = {}; 2633 uint _end_canary = 0; 2634 } 2635 /++ 2636 + setup and misc functions 2637 +/ 2638 extern(C) void sg_setup(const Desc* desc) @system @nogc nothrow pure; 2639 void setup(scope ref Desc desc) @trusted @nogc nothrow pure { 2640 sg_setup(&desc); 2641 } 2642 extern(C) void sg_shutdown() @system @nogc nothrow pure; 2643 void shutdown() @trusted @nogc nothrow pure { 2644 sg_shutdown(); 2645 } 2646 extern(C) bool sg_isvalid() @system @nogc nothrow pure; 2647 bool isvalid() @trusted @nogc nothrow pure { 2648 return sg_isvalid(); 2649 } 2650 extern(C) void sg_reset_state_cache() @system @nogc nothrow pure; 2651 void resetStateCache() @trusted @nogc nothrow pure { 2652 sg_reset_state_cache(); 2653 } 2654 extern(C) TraceHooks sg_install_trace_hooks(const TraceHooks* trace_hooks) @system @nogc nothrow pure; 2655 TraceHooks installTraceHooks(scope ref TraceHooks trace_hooks) @trusted @nogc nothrow pure { 2656 return sg_install_trace_hooks(&trace_hooks); 2657 } 2658 extern(C) void sg_push_debug_group(const(char)* name) @system @nogc nothrow pure; 2659 void pushDebugGroup(const(char)* name) @trusted @nogc nothrow pure { 2660 sg_push_debug_group(name); 2661 } 2662 extern(C) void sg_pop_debug_group() @system @nogc nothrow pure; 2663 void popDebugGroup() @trusted @nogc nothrow pure { 2664 sg_pop_debug_group(); 2665 } 2666 extern(C) bool sg_add_commit_listener(CommitListener listener) @system @nogc nothrow pure; 2667 bool addCommitListener(CommitListener listener) @trusted @nogc nothrow pure { 2668 return sg_add_commit_listener(listener); 2669 } 2670 extern(C) bool sg_remove_commit_listener(CommitListener listener) @system @nogc nothrow pure; 2671 bool removeCommitListener(CommitListener listener) @trusted @nogc nothrow pure { 2672 return sg_remove_commit_listener(listener); 2673 } 2674 /++ 2675 + resource creation, destruction and updating 2676 +/ 2677 extern(C) Buffer sg_make_buffer(const BufferDesc* desc) @system @nogc nothrow pure; 2678 Buffer makeBuffer(scope ref BufferDesc desc) @trusted @nogc nothrow pure { 2679 return sg_make_buffer(&desc); 2680 } 2681 extern(C) Image sg_make_image(const ImageDesc* desc) @system @nogc nothrow pure; 2682 Image makeImage(scope ref ImageDesc desc) @trusted @nogc nothrow pure { 2683 return sg_make_image(&desc); 2684 } 2685 extern(C) Sampler sg_make_sampler(const SamplerDesc* desc) @system @nogc nothrow pure; 2686 Sampler makeSampler(scope ref SamplerDesc desc) @trusted @nogc nothrow pure { 2687 return sg_make_sampler(&desc); 2688 } 2689 extern(C) Shader sg_make_shader(const ShaderDesc* desc) @system @nogc nothrow pure; 2690 Shader makeShader(scope ref ShaderDesc desc) @trusted @nogc nothrow pure { 2691 return sg_make_shader(&desc); 2692 } 2693 extern(C) Pipeline sg_make_pipeline(const PipelineDesc* desc) @system @nogc nothrow pure; 2694 Pipeline makePipeline(scope ref PipelineDesc desc) @trusted @nogc nothrow pure { 2695 return sg_make_pipeline(&desc); 2696 } 2697 extern(C) Attachments sg_make_attachments(const AttachmentsDesc* desc) @system @nogc nothrow pure; 2698 Attachments makeAttachments(scope ref AttachmentsDesc desc) @trusted @nogc nothrow pure { 2699 return sg_make_attachments(&desc); 2700 } 2701 extern(C) void sg_destroy_buffer(Buffer buf) @system @nogc nothrow pure; 2702 void destroyBuffer(Buffer buf) @trusted @nogc nothrow pure { 2703 sg_destroy_buffer(buf); 2704 } 2705 extern(C) void sg_destroy_image(Image img) @system @nogc nothrow pure; 2706 void destroyImage(Image img) @trusted @nogc nothrow pure { 2707 sg_destroy_image(img); 2708 } 2709 extern(C) void sg_destroy_sampler(Sampler smp) @system @nogc nothrow pure; 2710 void destroySampler(Sampler smp) @trusted @nogc nothrow pure { 2711 sg_destroy_sampler(smp); 2712 } 2713 extern(C) void sg_destroy_shader(Shader shd) @system @nogc nothrow pure; 2714 void destroyShader(Shader shd) @trusted @nogc nothrow pure { 2715 sg_destroy_shader(shd); 2716 } 2717 extern(C) void sg_destroy_pipeline(Pipeline pip) @system @nogc nothrow pure; 2718 void destroyPipeline(Pipeline pip) @trusted @nogc nothrow pure { 2719 sg_destroy_pipeline(pip); 2720 } 2721 extern(C) void sg_destroy_attachments(Attachments atts) @system @nogc nothrow pure; 2722 void destroyAttachments(Attachments atts) @trusted @nogc nothrow pure { 2723 sg_destroy_attachments(atts); 2724 } 2725 extern(C) void sg_update_buffer(Buffer buf, const Range* data) @system @nogc nothrow pure; 2726 void updateBuffer(Buffer buf, scope ref Range data) @trusted @nogc nothrow pure { 2727 sg_update_buffer(buf, &data); 2728 } 2729 extern(C) void sg_update_image(Image img, const ImageData* data) @system @nogc nothrow pure; 2730 void updateImage(Image img, scope ref ImageData data) @trusted @nogc nothrow pure { 2731 sg_update_image(img, &data); 2732 } 2733 extern(C) int sg_append_buffer(Buffer buf, const Range* data) @system @nogc nothrow pure; 2734 int appendBuffer(Buffer buf, scope ref Range data) @trusted @nogc nothrow pure { 2735 return sg_append_buffer(buf, &data); 2736 } 2737 extern(C) bool sg_query_buffer_overflow(Buffer buf) @system @nogc nothrow pure; 2738 bool queryBufferOverflow(Buffer buf) @trusted @nogc nothrow pure { 2739 return sg_query_buffer_overflow(buf); 2740 } 2741 extern(C) bool sg_query_buffer_will_overflow(Buffer buf, size_t size) @system @nogc nothrow pure; 2742 bool queryBufferWillOverflow(Buffer buf, size_t size) @trusted @nogc nothrow pure { 2743 return sg_query_buffer_will_overflow(buf, size); 2744 } 2745 /++ 2746 + render and compute functions 2747 +/ 2748 extern(C) void sg_begin_pass(const Pass* pass) @system @nogc nothrow pure; 2749 void beginPass(scope ref Pass pass) @trusted @nogc nothrow pure { 2750 sg_begin_pass(&pass); 2751 } 2752 extern(C) void sg_apply_viewport(int x, int y, int width, int height, bool origin_top_left) @system @nogc nothrow pure; 2753 void applyViewport(int x, int y, int width, int height, bool origin_top_left) @trusted @nogc nothrow pure { 2754 sg_apply_viewport(x, y, width, height, origin_top_left); 2755 } 2756 extern(C) void sg_apply_viewportf(float x, float y, float width, float height, bool origin_top_left) @system @nogc nothrow pure; 2757 void applyViewportf(float x, float y, float width, float height, bool origin_top_left) @trusted @nogc nothrow pure { 2758 sg_apply_viewportf(x, y, width, height, origin_top_left); 2759 } 2760 extern(C) void sg_apply_scissor_rect(int x, int y, int width, int height, bool origin_top_left) @system @nogc nothrow pure; 2761 void applyScissorRect(int x, int y, int width, int height, bool origin_top_left) @trusted @nogc nothrow pure { 2762 sg_apply_scissor_rect(x, y, width, height, origin_top_left); 2763 } 2764 extern(C) void sg_apply_scissor_rectf(float x, float y, float width, float height, bool origin_top_left) @system @nogc nothrow pure; 2765 void applyScissorRectf(float x, float y, float width, float height, bool origin_top_left) @trusted @nogc nothrow pure { 2766 sg_apply_scissor_rectf(x, y, width, height, origin_top_left); 2767 } 2768 extern(C) void sg_apply_pipeline(Pipeline pip) @system @nogc nothrow pure; 2769 void applyPipeline(Pipeline pip) @trusted @nogc nothrow pure { 2770 sg_apply_pipeline(pip); 2771 } 2772 extern(C) void sg_apply_bindings(const Bindings* bindings) @system @nogc nothrow pure; 2773 void applyBindings(scope ref Bindings bindings) @trusted @nogc nothrow pure { 2774 sg_apply_bindings(&bindings); 2775 } 2776 extern(C) void sg_apply_uniforms(uint ub_slot, const Range* data) @system @nogc nothrow pure; 2777 void applyUniforms(uint ub_slot, scope ref Range data) @trusted @nogc nothrow pure { 2778 sg_apply_uniforms(ub_slot, &data); 2779 } 2780 extern(C) void sg_draw(uint base_element, uint num_elements, uint num_instances) @system @nogc nothrow pure; 2781 void draw(uint base_element, uint num_elements, uint num_instances) @trusted @nogc nothrow pure { 2782 sg_draw(base_element, num_elements, num_instances); 2783 } 2784 extern(C) void sg_dispatch(uint num_groups_x, uint num_groups_y, uint num_groups_z) @system @nogc nothrow pure; 2785 void dispatch(uint num_groups_x, uint num_groups_y, uint num_groups_z) @trusted @nogc nothrow pure { 2786 sg_dispatch(num_groups_x, num_groups_y, num_groups_z); 2787 } 2788 extern(C) void sg_end_pass() @system @nogc nothrow pure; 2789 void endPass() @trusted @nogc nothrow pure { 2790 sg_end_pass(); 2791 } 2792 extern(C) void sg_commit() @system @nogc nothrow pure; 2793 void commit() @trusted @nogc nothrow pure { 2794 sg_commit(); 2795 } 2796 /++ 2797 + getting information 2798 +/ 2799 extern(C) Desc sg_query_desc() @system @nogc nothrow pure; 2800 Desc queryDesc() @trusted @nogc nothrow pure { 2801 return sg_query_desc(); 2802 } 2803 extern(C) Backend sg_query_backend() @system @nogc nothrow pure; 2804 Backend queryBackend() @trusted @nogc nothrow pure { 2805 return sg_query_backend(); 2806 } 2807 extern(C) Features sg_query_features() @system @nogc nothrow pure; 2808 Features queryFeatures() @trusted @nogc nothrow pure { 2809 return sg_query_features(); 2810 } 2811 extern(C) Limits sg_query_limits() @system @nogc nothrow pure; 2812 Limits queryLimits() @trusted @nogc nothrow pure { 2813 return sg_query_limits(); 2814 } 2815 extern(C) PixelformatInfo sg_query_pixelformat(PixelFormat fmt) @system @nogc nothrow pure; 2816 PixelformatInfo queryPixelformat(PixelFormat fmt) @trusted @nogc nothrow pure { 2817 return sg_query_pixelformat(fmt); 2818 } 2819 extern(C) int sg_query_row_pitch(PixelFormat fmt, int width, int row_align_bytes) @system @nogc nothrow pure; 2820 int queryRowPitch(PixelFormat fmt, int width, int row_align_bytes) @trusted @nogc nothrow pure { 2821 return sg_query_row_pitch(fmt, width, row_align_bytes); 2822 } 2823 extern(C) int sg_query_surface_pitch(PixelFormat fmt, int width, int height, int row_align_bytes) @system @nogc nothrow pure; 2824 int querySurfacePitch(PixelFormat fmt, int width, int height, int row_align_bytes) @trusted @nogc nothrow pure { 2825 return sg_query_surface_pitch(fmt, width, height, row_align_bytes); 2826 } 2827 /++ 2828 + get current state of a resource (INITIAL, ALLOC, VALID, FAILED, INVALID) 2829 +/ 2830 extern(C) ResourceState sg_query_buffer_state(Buffer buf) @system @nogc nothrow pure; 2831 ResourceState queryBufferState(Buffer buf) @trusted @nogc nothrow pure { 2832 return sg_query_buffer_state(buf); 2833 } 2834 extern(C) ResourceState sg_query_image_state(Image img) @system @nogc nothrow pure; 2835 ResourceState queryImageState(Image img) @trusted @nogc nothrow pure { 2836 return sg_query_image_state(img); 2837 } 2838 extern(C) ResourceState sg_query_sampler_state(Sampler smp) @system @nogc nothrow pure; 2839 ResourceState querySamplerState(Sampler smp) @trusted @nogc nothrow pure { 2840 return sg_query_sampler_state(smp); 2841 } 2842 extern(C) ResourceState sg_query_shader_state(Shader shd) @system @nogc nothrow pure; 2843 ResourceState queryShaderState(Shader shd) @trusted @nogc nothrow pure { 2844 return sg_query_shader_state(shd); 2845 } 2846 extern(C) ResourceState sg_query_pipeline_state(Pipeline pip) @system @nogc nothrow pure; 2847 ResourceState queryPipelineState(Pipeline pip) @trusted @nogc nothrow pure { 2848 return sg_query_pipeline_state(pip); 2849 } 2850 extern(C) ResourceState sg_query_attachments_state(Attachments atts) @system @nogc nothrow pure; 2851 ResourceState queryAttachmentsState(Attachments atts) @trusted @nogc nothrow pure { 2852 return sg_query_attachments_state(atts); 2853 } 2854 /++ 2855 + get runtime information about a resource 2856 +/ 2857 extern(C) BufferInfo sg_query_buffer_info(Buffer buf) @system @nogc nothrow pure; 2858 BufferInfo queryBufferInfo(Buffer buf) @trusted @nogc nothrow pure { 2859 return sg_query_buffer_info(buf); 2860 } 2861 extern(C) ImageInfo sg_query_image_info(Image img) @system @nogc nothrow pure; 2862 ImageInfo queryImageInfo(Image img) @trusted @nogc nothrow pure { 2863 return sg_query_image_info(img); 2864 } 2865 extern(C) SamplerInfo sg_query_sampler_info(Sampler smp) @system @nogc nothrow pure; 2866 SamplerInfo querySamplerInfo(Sampler smp) @trusted @nogc nothrow pure { 2867 return sg_query_sampler_info(smp); 2868 } 2869 extern(C) ShaderInfo sg_query_shader_info(Shader shd) @system @nogc nothrow pure; 2870 ShaderInfo queryShaderInfo(Shader shd) @trusted @nogc nothrow pure { 2871 return sg_query_shader_info(shd); 2872 } 2873 extern(C) PipelineInfo sg_query_pipeline_info(Pipeline pip) @system @nogc nothrow pure; 2874 PipelineInfo queryPipelineInfo(Pipeline pip) @trusted @nogc nothrow pure { 2875 return sg_query_pipeline_info(pip); 2876 } 2877 extern(C) AttachmentsInfo sg_query_attachments_info(Attachments atts) @system @nogc nothrow pure; 2878 AttachmentsInfo queryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow pure { 2879 return sg_query_attachments_info(atts); 2880 } 2881 /++ 2882 + get desc structs matching a specific resource (NOTE that not all creation attributes may be provided) 2883 +/ 2884 extern(C) BufferDesc sg_query_buffer_desc(Buffer buf) @system @nogc nothrow pure; 2885 BufferDesc queryBufferDesc(Buffer buf) @trusted @nogc nothrow pure { 2886 return sg_query_buffer_desc(buf); 2887 } 2888 extern(C) ImageDesc sg_query_image_desc(Image img) @system @nogc nothrow pure; 2889 ImageDesc queryImageDesc(Image img) @trusted @nogc nothrow pure { 2890 return sg_query_image_desc(img); 2891 } 2892 extern(C) SamplerDesc sg_query_sampler_desc(Sampler smp) @system @nogc nothrow pure; 2893 SamplerDesc querySamplerDesc(Sampler smp) @trusted @nogc nothrow pure { 2894 return sg_query_sampler_desc(smp); 2895 } 2896 extern(C) ShaderDesc sg_query_shader_desc(Shader shd) @system @nogc nothrow pure; 2897 ShaderDesc queryShaderDesc(Shader shd) @trusted @nogc nothrow pure { 2898 return sg_query_shader_desc(shd); 2899 } 2900 extern(C) PipelineDesc sg_query_pipeline_desc(Pipeline pip) @system @nogc nothrow pure; 2901 PipelineDesc queryPipelineDesc(Pipeline pip) @trusted @nogc nothrow pure { 2902 return sg_query_pipeline_desc(pip); 2903 } 2904 extern(C) AttachmentsDesc sg_query_attachments_desc(Attachments atts) @system @nogc nothrow pure; 2905 AttachmentsDesc queryAttachmentsDesc(Attachments atts) @trusted @nogc nothrow pure { 2906 return sg_query_attachments_desc(atts); 2907 } 2908 /++ 2909 + get resource creation desc struct with their default values replaced 2910 +/ 2911 extern(C) BufferDesc sg_query_buffer_defaults(const BufferDesc* desc) @system @nogc nothrow pure; 2912 BufferDesc queryBufferDefaults(scope ref BufferDesc desc) @trusted @nogc nothrow pure { 2913 return sg_query_buffer_defaults(&desc); 2914 } 2915 extern(C) ImageDesc sg_query_image_defaults(const ImageDesc* desc) @system @nogc nothrow pure; 2916 ImageDesc queryImageDefaults(scope ref ImageDesc desc) @trusted @nogc nothrow pure { 2917 return sg_query_image_defaults(&desc); 2918 } 2919 extern(C) SamplerDesc sg_query_sampler_defaults(const SamplerDesc* desc) @system @nogc nothrow pure; 2920 SamplerDesc querySamplerDefaults(scope ref SamplerDesc desc) @trusted @nogc nothrow pure { 2921 return sg_query_sampler_defaults(&desc); 2922 } 2923 extern(C) ShaderDesc sg_query_shader_defaults(const ShaderDesc* desc) @system @nogc nothrow pure; 2924 ShaderDesc queryShaderDefaults(scope ref ShaderDesc desc) @trusted @nogc nothrow pure { 2925 return sg_query_shader_defaults(&desc); 2926 } 2927 extern(C) PipelineDesc sg_query_pipeline_defaults(const PipelineDesc* desc) @system @nogc nothrow pure; 2928 PipelineDesc queryPipelineDefaults(scope ref PipelineDesc desc) @trusted @nogc nothrow pure { 2929 return sg_query_pipeline_defaults(&desc); 2930 } 2931 extern(C) AttachmentsDesc sg_query_attachments_defaults(const AttachmentsDesc* desc) @system @nogc nothrow pure; 2932 AttachmentsDesc queryAttachmentsDefaults(scope ref AttachmentsDesc desc) @trusted @nogc nothrow pure { 2933 return sg_query_attachments_defaults(&desc); 2934 } 2935 /++ 2936 + assorted query functions 2937 +/ 2938 extern(C) size_t sg_query_buffer_size(Buffer buf) @system @nogc nothrow pure; 2939 size_t queryBufferSize(Buffer buf) @trusted @nogc nothrow pure { 2940 return sg_query_buffer_size(buf); 2941 } 2942 extern(C) BufferUsage sg_query_buffer_usage(Buffer buf) @system @nogc nothrow pure; 2943 BufferUsage queryBufferUsage(Buffer buf) @trusted @nogc nothrow pure { 2944 return sg_query_buffer_usage(buf); 2945 } 2946 extern(C) ImageType sg_query_image_type(Image img) @system @nogc nothrow pure; 2947 ImageType queryImageType(Image img) @trusted @nogc nothrow pure { 2948 return sg_query_image_type(img); 2949 } 2950 extern(C) int sg_query_image_width(Image img) @system @nogc nothrow pure; 2951 int queryImageWidth(Image img) @trusted @nogc nothrow pure { 2952 return sg_query_image_width(img); 2953 } 2954 extern(C) int sg_query_image_height(Image img) @system @nogc nothrow pure; 2955 int queryImageHeight(Image img) @trusted @nogc nothrow pure { 2956 return sg_query_image_height(img); 2957 } 2958 extern(C) int sg_query_image_num_slices(Image img) @system @nogc nothrow pure; 2959 int queryImageNumSlices(Image img) @trusted @nogc nothrow pure { 2960 return sg_query_image_num_slices(img); 2961 } 2962 extern(C) int sg_query_image_num_mipmaps(Image img) @system @nogc nothrow pure; 2963 int queryImageNumMipmaps(Image img) @trusted @nogc nothrow pure { 2964 return sg_query_image_num_mipmaps(img); 2965 } 2966 extern(C) PixelFormat sg_query_image_pixelformat(Image img) @system @nogc nothrow pure; 2967 PixelFormat queryImagePixelformat(Image img) @trusted @nogc nothrow pure { 2968 return sg_query_image_pixelformat(img); 2969 } 2970 extern(C) ImageUsage sg_query_image_usage(Image img) @system @nogc nothrow pure; 2971 ImageUsage queryImageUsage(Image img) @trusted @nogc nothrow pure { 2972 return sg_query_image_usage(img); 2973 } 2974 extern(C) int sg_query_image_sample_count(Image img) @system @nogc nothrow pure; 2975 int queryImageSampleCount(Image img) @trusted @nogc nothrow pure { 2976 return sg_query_image_sample_count(img); 2977 } 2978 /++ 2979 + separate resource allocation and initialization (for async setup) 2980 +/ 2981 extern(C) Buffer sg_alloc_buffer() @system @nogc nothrow pure; 2982 Buffer allocBuffer() @trusted @nogc nothrow pure { 2983 return sg_alloc_buffer(); 2984 } 2985 extern(C) Image sg_alloc_image() @system @nogc nothrow pure; 2986 Image allocImage() @trusted @nogc nothrow pure { 2987 return sg_alloc_image(); 2988 } 2989 extern(C) Sampler sg_alloc_sampler() @system @nogc nothrow pure; 2990 Sampler allocSampler() @trusted @nogc nothrow pure { 2991 return sg_alloc_sampler(); 2992 } 2993 extern(C) Shader sg_alloc_shader() @system @nogc nothrow pure; 2994 Shader allocShader() @trusted @nogc nothrow pure { 2995 return sg_alloc_shader(); 2996 } 2997 extern(C) Pipeline sg_alloc_pipeline() @system @nogc nothrow pure; 2998 Pipeline allocPipeline() @trusted @nogc nothrow pure { 2999 return sg_alloc_pipeline(); 3000 } 3001 extern(C) Attachments sg_alloc_attachments() @system @nogc nothrow pure; 3002 Attachments allocAttachments() @trusted @nogc nothrow pure { 3003 return sg_alloc_attachments(); 3004 } 3005 extern(C) void sg_dealloc_buffer(Buffer buf) @system @nogc nothrow pure; 3006 void deallocBuffer(Buffer buf) @trusted @nogc nothrow pure { 3007 sg_dealloc_buffer(buf); 3008 } 3009 extern(C) void sg_dealloc_image(Image img) @system @nogc nothrow pure; 3010 void deallocImage(Image img) @trusted @nogc nothrow pure { 3011 sg_dealloc_image(img); 3012 } 3013 extern(C) void sg_dealloc_sampler(Sampler smp) @system @nogc nothrow pure; 3014 void deallocSampler(Sampler smp) @trusted @nogc nothrow pure { 3015 sg_dealloc_sampler(smp); 3016 } 3017 extern(C) void sg_dealloc_shader(Shader shd) @system @nogc nothrow pure; 3018 void deallocShader(Shader shd) @trusted @nogc nothrow pure { 3019 sg_dealloc_shader(shd); 3020 } 3021 extern(C) void sg_dealloc_pipeline(Pipeline pip) @system @nogc nothrow pure; 3022 void deallocPipeline(Pipeline pip) @trusted @nogc nothrow pure { 3023 sg_dealloc_pipeline(pip); 3024 } 3025 extern(C) void sg_dealloc_attachments(Attachments attachments) @system @nogc nothrow pure; 3026 void deallocAttachments(Attachments attachments) @trusted @nogc nothrow pure { 3027 sg_dealloc_attachments(attachments); 3028 } 3029 extern(C) void sg_init_buffer(Buffer buf, const BufferDesc* desc) @system @nogc nothrow pure; 3030 void initBuffer(Buffer buf, scope ref BufferDesc desc) @trusted @nogc nothrow pure { 3031 sg_init_buffer(buf, &desc); 3032 } 3033 extern(C) void sg_init_image(Image img, const ImageDesc* desc) @system @nogc nothrow pure; 3034 void initImage(Image img, scope ref ImageDesc desc) @trusted @nogc nothrow pure { 3035 sg_init_image(img, &desc); 3036 } 3037 extern(C) void sg_init_sampler(Sampler smg, const SamplerDesc* desc) @system @nogc nothrow pure; 3038 void initSampler(Sampler smg, scope ref SamplerDesc desc) @trusted @nogc nothrow pure { 3039 sg_init_sampler(smg, &desc); 3040 } 3041 extern(C) void sg_init_shader(Shader shd, const ShaderDesc* desc) @system @nogc nothrow pure; 3042 void initShader(Shader shd, scope ref ShaderDesc desc) @trusted @nogc nothrow pure { 3043 sg_init_shader(shd, &desc); 3044 } 3045 extern(C) void sg_init_pipeline(Pipeline pip, const PipelineDesc* desc) @system @nogc nothrow pure; 3046 void initPipeline(Pipeline pip, scope ref PipelineDesc desc) @trusted @nogc nothrow pure { 3047 sg_init_pipeline(pip, &desc); 3048 } 3049 extern(C) void sg_init_attachments(Attachments attachments, const AttachmentsDesc* desc) @system @nogc nothrow pure; 3050 void initAttachments(Attachments attachments, scope ref AttachmentsDesc desc) @trusted @nogc nothrow pure { 3051 sg_init_attachments(attachments, &desc); 3052 } 3053 extern(C) void sg_uninit_buffer(Buffer buf) @system @nogc nothrow pure; 3054 void uninitBuffer(Buffer buf) @trusted @nogc nothrow pure { 3055 sg_uninit_buffer(buf); 3056 } 3057 extern(C) void sg_uninit_image(Image img) @system @nogc nothrow pure; 3058 void uninitImage(Image img) @trusted @nogc nothrow pure { 3059 sg_uninit_image(img); 3060 } 3061 extern(C) void sg_uninit_sampler(Sampler smp) @system @nogc nothrow pure; 3062 void uninitSampler(Sampler smp) @trusted @nogc nothrow pure { 3063 sg_uninit_sampler(smp); 3064 } 3065 extern(C) void sg_uninit_shader(Shader shd) @system @nogc nothrow pure; 3066 void uninitShader(Shader shd) @trusted @nogc nothrow pure { 3067 sg_uninit_shader(shd); 3068 } 3069 extern(C) void sg_uninit_pipeline(Pipeline pip) @system @nogc nothrow pure; 3070 void uninitPipeline(Pipeline pip) @trusted @nogc nothrow pure { 3071 sg_uninit_pipeline(pip); 3072 } 3073 extern(C) void sg_uninit_attachments(Attachments atts) @system @nogc nothrow pure; 3074 void uninitAttachments(Attachments atts) @trusted @nogc nothrow pure { 3075 sg_uninit_attachments(atts); 3076 } 3077 extern(C) void sg_fail_buffer(Buffer buf) @system @nogc nothrow pure; 3078 void failBuffer(Buffer buf) @trusted @nogc nothrow pure { 3079 sg_fail_buffer(buf); 3080 } 3081 extern(C) void sg_fail_image(Image img) @system @nogc nothrow pure; 3082 void failImage(Image img) @trusted @nogc nothrow pure { 3083 sg_fail_image(img); 3084 } 3085 extern(C) void sg_fail_sampler(Sampler smp) @system @nogc nothrow pure; 3086 void failSampler(Sampler smp) @trusted @nogc nothrow pure { 3087 sg_fail_sampler(smp); 3088 } 3089 extern(C) void sg_fail_shader(Shader shd) @system @nogc nothrow pure; 3090 void failShader(Shader shd) @trusted @nogc nothrow pure { 3091 sg_fail_shader(shd); 3092 } 3093 extern(C) void sg_fail_pipeline(Pipeline pip) @system @nogc nothrow pure; 3094 void failPipeline(Pipeline pip) @trusted @nogc nothrow pure { 3095 sg_fail_pipeline(pip); 3096 } 3097 extern(C) void sg_fail_attachments(Attachments atts) @system @nogc nothrow pure; 3098 void failAttachments(Attachments atts) @trusted @nogc nothrow pure { 3099 sg_fail_attachments(atts); 3100 } 3101 /++ 3102 + frame stats 3103 +/ 3104 extern(C) void sg_enable_frame_stats() @system @nogc nothrow pure; 3105 void enableFrameStats() @trusted @nogc nothrow pure { 3106 sg_enable_frame_stats(); 3107 } 3108 extern(C) void sg_disable_frame_stats() @system @nogc nothrow pure; 3109 void disableFrameStats() @trusted @nogc nothrow pure { 3110 sg_disable_frame_stats(); 3111 } 3112 extern(C) bool sg_frame_stats_enabled() @system @nogc nothrow pure; 3113 bool frameStatsEnabled() @trusted @nogc nothrow pure { 3114 return sg_frame_stats_enabled(); 3115 } 3116 extern(C) FrameStats sg_query_frame_stats() @system @nogc nothrow pure; 3117 FrameStats queryFrameStats() @trusted @nogc nothrow pure { 3118 return sg_query_frame_stats(); 3119 } 3120 /++ 3121 + Backend-specific structs and functions, these may come in handy for mixing 3122 + sokol-gfx rendering with 'native backend' rendering functions. 3123 + 3124 + This group of functions will be expanded as needed. 3125 +/ 3126 extern(C) struct D3d11BufferInfo { 3127 const(void)* buf = null; 3128 } 3129 extern(C) struct D3d11ImageInfo { 3130 const(void)* tex2d = null; 3131 const(void)* tex3d = null; 3132 const(void)* res = null; 3133 const(void)* srv = null; 3134 } 3135 extern(C) struct D3d11SamplerInfo { 3136 const(void)* smp = null; 3137 } 3138 extern(C) struct D3d11ShaderInfo { 3139 const(void)*[8] cbufs = null; 3140 const(void)* vs = null; 3141 const(void)* fs = null; 3142 } 3143 extern(C) struct D3d11PipelineInfo { 3144 const(void)* il = null; 3145 const(void)* rs = null; 3146 const(void)* dss = null; 3147 const(void)* bs = null; 3148 } 3149 extern(C) struct D3d11AttachmentsInfo { 3150 const(void)*[4] color_rtv = null; 3151 const(void)* dsv = null; 3152 } 3153 extern(C) struct MtlBufferInfo { 3154 const(void)*[2] buf = null; 3155 int active_slot = 0; 3156 } 3157 extern(C) struct MtlImageInfo { 3158 const(void)*[2] tex = null; 3159 int active_slot = 0; 3160 } 3161 extern(C) struct MtlSamplerInfo { 3162 const(void)* smp = null; 3163 } 3164 extern(C) struct MtlShaderInfo { 3165 const(void)* vertex_lib = null; 3166 const(void)* fragment_lib = null; 3167 const(void)* vertex_func = null; 3168 const(void)* fragment_func = null; 3169 } 3170 extern(C) struct MtlPipelineInfo { 3171 const(void)* rps = null; 3172 const(void)* dss = null; 3173 } 3174 extern(C) struct WgpuBufferInfo { 3175 const(void)* buf = null; 3176 } 3177 extern(C) struct WgpuImageInfo { 3178 const(void)* tex = null; 3179 const(void)* view = null; 3180 } 3181 extern(C) struct WgpuSamplerInfo { 3182 const(void)* smp = null; 3183 } 3184 extern(C) struct WgpuShaderInfo { 3185 const(void)* vs_mod = null; 3186 const(void)* fs_mod = null; 3187 const(void)* bgl = null; 3188 } 3189 extern(C) struct WgpuPipelineInfo { 3190 const(void)* render_pipeline = null; 3191 const(void)* compute_pipeline = null; 3192 } 3193 extern(C) struct WgpuAttachmentsInfo { 3194 const(void)*[4] color_view = null; 3195 const(void)*[4] resolve_view = null; 3196 const(void)* ds_view = null; 3197 } 3198 extern(C) struct GlBufferInfo { 3199 uint[2] buf = [0, 0]; 3200 int active_slot = 0; 3201 } 3202 extern(C) struct GlImageInfo { 3203 uint[2] tex = [0, 0]; 3204 uint tex_target = 0; 3205 uint msaa_render_buffer = 0; 3206 int active_slot = 0; 3207 } 3208 extern(C) struct GlSamplerInfo { 3209 uint smp = 0; 3210 } 3211 extern(C) struct GlShaderInfo { 3212 uint prog = 0; 3213 } 3214 extern(C) struct GlAttachmentsInfo { 3215 uint framebuffer = 0; 3216 uint[4] msaa_resolve_framebuffer = [0, 0, 0, 0]; 3217 } 3218 /++ 3219 + D3D11: return ID3D11Device 3220 +/ 3221 extern(C) const(void)* sg_d3d11_device() @system @nogc nothrow pure; 3222 const(void)* d3d11Device() @trusted @nogc nothrow pure { 3223 return sg_d3d11_device(); 3224 } 3225 /++ 3226 + D3D11: return ID3D11DeviceContext 3227 +/ 3228 extern(C) const(void)* sg_d3d11_device_context() @system @nogc nothrow pure; 3229 const(void)* d3d11DeviceContext() @trusted @nogc nothrow pure { 3230 return sg_d3d11_device_context(); 3231 } 3232 /++ 3233 + D3D11: get internal buffer resource objects 3234 +/ 3235 extern(C) D3d11BufferInfo sg_d3d11_query_buffer_info(Buffer buf) @system @nogc nothrow pure; 3236 D3d11BufferInfo d3d11QueryBufferInfo(Buffer buf) @trusted @nogc nothrow pure { 3237 return sg_d3d11_query_buffer_info(buf); 3238 } 3239 /++ 3240 + D3D11: get internal image resource objects 3241 +/ 3242 extern(C) D3d11ImageInfo sg_d3d11_query_image_info(Image img) @system @nogc nothrow pure; 3243 D3d11ImageInfo d3d11QueryImageInfo(Image img) @trusted @nogc nothrow pure { 3244 return sg_d3d11_query_image_info(img); 3245 } 3246 /++ 3247 + D3D11: get internal sampler resource objects 3248 +/ 3249 extern(C) D3d11SamplerInfo sg_d3d11_query_sampler_info(Sampler smp) @system @nogc nothrow pure; 3250 D3d11SamplerInfo d3d11QuerySamplerInfo(Sampler smp) @trusted @nogc nothrow pure { 3251 return sg_d3d11_query_sampler_info(smp); 3252 } 3253 /++ 3254 + D3D11: get internal shader resource objects 3255 +/ 3256 extern(C) D3d11ShaderInfo sg_d3d11_query_shader_info(Shader shd) @system @nogc nothrow pure; 3257 D3d11ShaderInfo d3d11QueryShaderInfo(Shader shd) @trusted @nogc nothrow pure { 3258 return sg_d3d11_query_shader_info(shd); 3259 } 3260 /++ 3261 + D3D11: get internal pipeline resource objects 3262 +/ 3263 extern(C) D3d11PipelineInfo sg_d3d11_query_pipeline_info(Pipeline pip) @system @nogc nothrow pure; 3264 D3d11PipelineInfo d3d11QueryPipelineInfo(Pipeline pip) @trusted @nogc nothrow pure { 3265 return sg_d3d11_query_pipeline_info(pip); 3266 } 3267 /++ 3268 + D3D11: get internal pass resource objects 3269 +/ 3270 extern(C) D3d11AttachmentsInfo sg_d3d11_query_attachments_info(Attachments atts) @system @nogc nothrow pure; 3271 D3d11AttachmentsInfo d3d11QueryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow pure { 3272 return sg_d3d11_query_attachments_info(atts); 3273 } 3274 /++ 3275 + Metal: return __bridge-casted MTLDevice 3276 +/ 3277 extern(C) const(void)* sg_mtl_device() @system @nogc nothrow pure; 3278 const(void)* mtlDevice() @trusted @nogc nothrow pure { 3279 return sg_mtl_device(); 3280 } 3281 /++ 3282 + Metal: return __bridge-casted MTLRenderCommandEncoder when inside render pass (otherwise zero) 3283 +/ 3284 extern(C) const(void)* sg_mtl_render_command_encoder() @system @nogc nothrow pure; 3285 const(void)* mtlRenderCommandEncoder() @trusted @nogc nothrow pure { 3286 return sg_mtl_render_command_encoder(); 3287 } 3288 /++ 3289 + Metal: return __bridge-casted MTLComputeCommandEncoder when inside compute pass (otherwise zero) 3290 +/ 3291 extern(C) const(void)* sg_mtl_compute_command_encoder() @system @nogc nothrow pure; 3292 const(void)* mtlComputeCommandEncoder() @trusted @nogc nothrow pure { 3293 return sg_mtl_compute_command_encoder(); 3294 } 3295 /++ 3296 + Metal: get internal __bridge-casted buffer resource objects 3297 +/ 3298 extern(C) MtlBufferInfo sg_mtl_query_buffer_info(Buffer buf) @system @nogc nothrow pure; 3299 MtlBufferInfo mtlQueryBufferInfo(Buffer buf) @trusted @nogc nothrow pure { 3300 return sg_mtl_query_buffer_info(buf); 3301 } 3302 /++ 3303 + Metal: get internal __bridge-casted image resource objects 3304 +/ 3305 extern(C) MtlImageInfo sg_mtl_query_image_info(Image img) @system @nogc nothrow pure; 3306 MtlImageInfo mtlQueryImageInfo(Image img) @trusted @nogc nothrow pure { 3307 return sg_mtl_query_image_info(img); 3308 } 3309 /++ 3310 + Metal: get internal __bridge-casted sampler resource objects 3311 +/ 3312 extern(C) MtlSamplerInfo sg_mtl_query_sampler_info(Sampler smp) @system @nogc nothrow pure; 3313 MtlSamplerInfo mtlQuerySamplerInfo(Sampler smp) @trusted @nogc nothrow pure { 3314 return sg_mtl_query_sampler_info(smp); 3315 } 3316 /++ 3317 + Metal: get internal __bridge-casted shader resource objects 3318 +/ 3319 extern(C) MtlShaderInfo sg_mtl_query_shader_info(Shader shd) @system @nogc nothrow pure; 3320 MtlShaderInfo mtlQueryShaderInfo(Shader shd) @trusted @nogc nothrow pure { 3321 return sg_mtl_query_shader_info(shd); 3322 } 3323 /++ 3324 + Metal: get internal __bridge-casted pipeline resource objects 3325 +/ 3326 extern(C) MtlPipelineInfo sg_mtl_query_pipeline_info(Pipeline pip) @system @nogc nothrow pure; 3327 MtlPipelineInfo mtlQueryPipelineInfo(Pipeline pip) @trusted @nogc nothrow pure { 3328 return sg_mtl_query_pipeline_info(pip); 3329 } 3330 /++ 3331 + WebGPU: return WGPUDevice object 3332 +/ 3333 extern(C) const(void)* sg_wgpu_device() @system @nogc nothrow pure; 3334 const(void)* wgpuDevice() @trusted @nogc nothrow pure { 3335 return sg_wgpu_device(); 3336 } 3337 /++ 3338 + WebGPU: return WGPUQueue object 3339 +/ 3340 extern(C) const(void)* sg_wgpu_queue() @system @nogc nothrow pure; 3341 const(void)* wgpuQueue() @trusted @nogc nothrow pure { 3342 return sg_wgpu_queue(); 3343 } 3344 /++ 3345 + WebGPU: return this frame's WGPUCommandEncoder 3346 +/ 3347 extern(C) const(void)* sg_wgpu_command_encoder() @system @nogc nothrow pure; 3348 const(void)* wgpuCommandEncoder() @trusted @nogc nothrow pure { 3349 return sg_wgpu_command_encoder(); 3350 } 3351 /++ 3352 + WebGPU: return WGPURenderPassEncoder of current pass (returns 0 when outside pass or in a compute pass) 3353 +/ 3354 extern(C) const(void)* sg_wgpu_render_pass_encoder() @system @nogc nothrow pure; 3355 const(void)* wgpuRenderPassEncoder() @trusted @nogc nothrow pure { 3356 return sg_wgpu_render_pass_encoder(); 3357 } 3358 /++ 3359 + WebGPU: return WGPUComputePassEncoder of current pass (returns 0 when outside pass or in a render pass) 3360 +/ 3361 extern(C) const(void)* sg_wgpu_compute_pass_encoder() @system @nogc nothrow pure; 3362 const(void)* wgpuComputePassEncoder() @trusted @nogc nothrow pure { 3363 return sg_wgpu_compute_pass_encoder(); 3364 } 3365 /++ 3366 + WebGPU: get internal buffer resource objects 3367 +/ 3368 extern(C) WgpuBufferInfo sg_wgpu_query_buffer_info(Buffer buf) @system @nogc nothrow pure; 3369 WgpuBufferInfo wgpuQueryBufferInfo(Buffer buf) @trusted @nogc nothrow pure { 3370 return sg_wgpu_query_buffer_info(buf); 3371 } 3372 /++ 3373 + WebGPU: get internal image resource objects 3374 +/ 3375 extern(C) WgpuImageInfo sg_wgpu_query_image_info(Image img) @system @nogc nothrow pure; 3376 WgpuImageInfo wgpuQueryImageInfo(Image img) @trusted @nogc nothrow pure { 3377 return sg_wgpu_query_image_info(img); 3378 } 3379 /++ 3380 + WebGPU: get internal sampler resource objects 3381 +/ 3382 extern(C) WgpuSamplerInfo sg_wgpu_query_sampler_info(Sampler smp) @system @nogc nothrow pure; 3383 WgpuSamplerInfo wgpuQuerySamplerInfo(Sampler smp) @trusted @nogc nothrow pure { 3384 return sg_wgpu_query_sampler_info(smp); 3385 } 3386 /++ 3387 + WebGPU: get internal shader resource objects 3388 +/ 3389 extern(C) WgpuShaderInfo sg_wgpu_query_shader_info(Shader shd) @system @nogc nothrow pure; 3390 WgpuShaderInfo wgpuQueryShaderInfo(Shader shd) @trusted @nogc nothrow pure { 3391 return sg_wgpu_query_shader_info(shd); 3392 } 3393 /++ 3394 + WebGPU: get internal pipeline resource objects 3395 +/ 3396 extern(C) WgpuPipelineInfo sg_wgpu_query_pipeline_info(Pipeline pip) @system @nogc nothrow pure; 3397 WgpuPipelineInfo wgpuQueryPipelineInfo(Pipeline pip) @trusted @nogc nothrow pure { 3398 return sg_wgpu_query_pipeline_info(pip); 3399 } 3400 /++ 3401 + WebGPU: get internal pass resource objects 3402 +/ 3403 extern(C) WgpuAttachmentsInfo sg_wgpu_query_attachments_info(Attachments atts) @system @nogc nothrow pure; 3404 WgpuAttachmentsInfo wgpuQueryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow pure { 3405 return sg_wgpu_query_attachments_info(atts); 3406 } 3407 /++ 3408 + GL: get internal buffer resource objects 3409 +/ 3410 extern(C) GlBufferInfo sg_gl_query_buffer_info(Buffer buf) @system @nogc nothrow pure; 3411 GlBufferInfo glQueryBufferInfo(Buffer buf) @trusted @nogc nothrow pure { 3412 return sg_gl_query_buffer_info(buf); 3413 } 3414 /++ 3415 + GL: get internal image resource objects 3416 +/ 3417 extern(C) GlImageInfo sg_gl_query_image_info(Image img) @system @nogc nothrow pure; 3418 GlImageInfo glQueryImageInfo(Image img) @trusted @nogc nothrow pure { 3419 return sg_gl_query_image_info(img); 3420 } 3421 /++ 3422 + GL: get internal sampler resource objects 3423 +/ 3424 extern(C) GlSamplerInfo sg_gl_query_sampler_info(Sampler smp) @system @nogc nothrow pure; 3425 GlSamplerInfo glQuerySamplerInfo(Sampler smp) @trusted @nogc nothrow pure { 3426 return sg_gl_query_sampler_info(smp); 3427 } 3428 /++ 3429 + GL: get internal shader resource objects 3430 +/ 3431 extern(C) GlShaderInfo sg_gl_query_shader_info(Shader shd) @system @nogc nothrow pure; 3432 GlShaderInfo glQueryShaderInfo(Shader shd) @trusted @nogc nothrow pure { 3433 return sg_gl_query_shader_info(shd); 3434 } 3435 /++ 3436 + GL: get internal pass resource objects 3437 +/ 3438 extern(C) GlAttachmentsInfo sg_gl_query_attachments_info(Attachments atts) @system @nogc nothrow pure; 3439 GlAttachmentsInfo glQueryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow pure { 3440 return sg_gl_query_attachments_info(atts); 3441 }