// machine generated, do not edit

module sokol.gfx;

/// Resource id typedefs:
/// 
/// sg_buffer:      vertex- and index-buffers
/// sg_image:       images used as textures and render-pass attachments
/// sg_sampler      sampler objects describing how a texture is sampled in a shader
/// sg_shader:      vertex- and fragment-shaders and shader interface information
/// sg_pipeline:    associated shader and vertex-layouts, and render states
/// sg_attachments: a baked collection of render pass attachment images
/// 
/// Instead of pointers, resource creation functions return a 32-bit
/// handle which uniquely identifies the resource object.
/// 
/// The 32-bit resource id is split into a 16-bit pool index in the lower bits,
/// and a 16-bit 'generation counter' in the upper bits. The index allows fast
/// pool lookups, and combined with the generation-counter it allows to detect
/// 'dangling accesses' (trying to use an object which no longer exists, and
/// its pool slot has been reused for a new object)
/// 
/// The resource ids are wrapped into a strongly-typed struct so that
/// trying to pass an incompatible resource id is a compile error
extern(C)
struct Buffer {
    uint id = 0;
}
extern(C)
struct Image {
    uint id = 0;
}
extern(C)
struct Sampler {
    uint id = 0;
}
extern(C)
struct Shader {
    uint id = 0;
}
extern(C)
struct Pipeline {
    uint id = 0;
}
extern(C)
struct Attachments {
    uint id = 0;
}
/// sg_range is a pointer-size-pair struct used to pass memory blobs into
/// sokol-gfx. When initialized from a value type (array or struct), you can
/// use the SG_RANGE() macro to build an sg_range struct. For functions which
/// take either a sg_range pointer, or a (C++) sg_range reference, use the
/// SG_RANGE_REF macro as a solution which compiles both in C and C++
extern(C)
struct Range {
    const(void)* ptr = null;
    size_t size = 0;
}
/// various compile-time constants in the public AP
/// various compile-time constants in the public AP
enum invalid_id = 0;
/// various compile-time constants in the public AP
enum num_inflight_frames = 2;
/// various compile-time constants in the public AP
enum max_color_attachments = 4;
/// various compile-time constants in the public AP
enum max_uniformblock_members = 16;
/// various compile-time constants in the public AP
enum max_vertex_attributes = 16;
/// various compile-time constants in the public AP
enum max_mipmaps = 16;
/// various compile-time constants in the public AP
enum max_texturearray_layers = 128;
/// various compile-time constants in the public AP
enum max_uniformblock_bindslots = 8;
/// various compile-time constants in the public AP
enum max_vertexbuffer_bindslots = 8;
/// various compile-time constants in the public AP
enum max_image_bindslots = 16;
/// various compile-time constants in the public AP
enum max_sampler_bindslots = 16;
/// various compile-time constants in the public AP
enum max_storagebuffer_bindslots = 8;
/// various compile-time constants in the public AP
enum max_image_sampler_pairs = 16;
/// sg_color
/// 
/// An RGBA color value
extern(C)
struct Color {
    float r = 0.0f;
    float g = 0.0f;
    float b = 0.0f;
    float a = 0.0f;
}
/// sg_backend
/// 
/// The active 3D-API backend, use the function sg_query_backend()
/// to get the currently active backend
enum Backend {
    Glcore,
    Gles3,
    D3d11,
    Metal_ios,
    Metal_macos,
    Metal_simulator,
    Wgpu,
    Dummy,
}
/// sg_pixel_format
/// 
/// sokol_gfx.h basically uses the same pixel formats as WebGPU, since these
/// are supported on most newer GPUs.
/// 
/// A pixelformat name consist of three parts:
/// 
///     - components (R, RG, RGB or RGBA)
///     - bit width per component (8, 16 or 32)
///     - component data type:
///         - unsigned normalized (no postfix)
///         - signed normalized (SN postfix)
///         - unsigned integer (UI postfix)
///         - signed integer (SI postfix)
///         - float (F postfix)
/// 
/// Not all pixel formats can be used for everything, call sg_query_pixelformat()
/// to inspect the capabilities of a given pixelformat. The function returns
/// an sg_pixelformat_info struct with the following members:
/// 
///     - sample: the pixelformat can be sampled as texture at least with
///               nearest filtering
///     - filter: the pixelformat can be sampled as texture with linear
///               filtering
///     - render: the pixelformat can be used as render-pass attachment
///     - blend:  blending is supported when used as render-pass attachment
///     - msaa:   multisample-antialiasing is supported when used
///               as render-pass attachment
///     - depth:  the pixelformat can be used for depth-stencil attachments
///     - compressed: this is a block-compressed format
///     - bytes_per_pixel: the numbers of bytes in a pixel (0 for compressed formats)
/// 
/// The default pixel format for texture images is SG_PIXELFORMAT_RGBA8.
/// 
/// The default pixel format for render target images is platform-dependent
/// and taken from the sg_environment struct passed into sg_setup(). Typically
/// the default formats are:
/// 
///     - for the Metal, D3D11 and WebGPU backends: SG_PIXELFORMAT_BGRA8
///     - for GL backends: SG_PIXELFORMAT_RGBA
enum PixelFormat {
    Default,
    None,
    R8,
    R8sn,
    R8ui,
    R8si,
    R16,
    R16sn,
    R16ui,
    R16si,
    R16f,
    Rg8,
    Rg8sn,
    Rg8ui,
    Rg8si,
    R32ui,
    R32si,
    R32f,
    Rg16,
    Rg16sn,
    Rg16ui,
    Rg16si,
    Rg16f,
    Rgba8,
    Srgb8a8,
    Rgba8sn,
    Rgba8ui,
    Rgba8si,
    Bgra8,
    Rgb10a2,
    Rg11b10f,
    Rgb9e5,
    Rg32ui,
    Rg32si,
    Rg32f,
    Rgba16,
    Rgba16sn,
    Rgba16ui,
    Rgba16si,
    Rgba16f,
    Rgba32ui,
    Rgba32si,
    Rgba32f,
    Depth,
    Depth_stencil,
    Bc1_rgba,
    Bc2_rgba,
    Bc3_rgba,
    Bc3_srgba,
    Bc4_r,
    Bc4_rsn,
    Bc5_rg,
    Bc5_rgsn,
    Bc6h_rgbf,
    Bc6h_rgbuf,
    Bc7_rgba,
    Bc7_srgba,
    Pvrtc_rgb_2bpp,
    Pvrtc_rgb_4bpp,
    Pvrtc_rgba_2bpp,
    Pvrtc_rgba_4bpp,
    Etc2_rgb8,
    Etc2_srgb8,
    Etc2_rgb8a1,
    Etc2_rgba8,
    Etc2_srgb8a8,
    Eac_r11,
    Eac_r11sn,
    Eac_rg11,
    Eac_rg11sn,
    Astc_4x4_rgba,
    Astc_4x4_srgba,
    Num,
}
/// Runtime information about a pixel format, returned by sg_query_pixelformat()
extern(C)
struct PixelformatInfo {
    bool sample = false;
    bool filter = false;
    bool render = false;
    bool blend = false;
    bool msaa = false;
    bool depth = false;
    bool compressed = false;
    int bytes_per_pixel = 0;
}
/// Runtime information about available optional features, returned by sg_query_features(
extern(C)
struct Features {
    bool origin_top_left = false;
    bool image_clamp_to_border = false;
    bool mrt_independent_blend_state = false;
    bool mrt_independent_write_mask = false;
    bool storage_buffer = false;
    bool msaa_image_bindings = false;
}
/// Runtime information about resource limits, returned by sg_query_limit(
extern(C)
struct Limits {
    int max_image_size_2d = 0;
    int max_image_size_cube = 0;
    int max_image_size_3d = 0;
    int max_image_size_array = 0;
    int max_image_array_layers = 0;
    int max_vertex_attrs = 0;
    int gl_max_vertex_uniform_components = 0;
    int gl_max_combined_texture_image_units = 0;
}
/// sg_resource_state
/// 
/// The current state of a resource in its resource pool.
/// Resources start in the INITIAL state, which means the
/// pool slot is unoccupied and can be allocated. When a resource is
/// created, first an id is allocated, and the resource pool slot
/// is set to state ALLOC. After allocation, the resource is
/// initialized, which may result in the VALID or FAILED state. The
/// reason why allocation and initialization are separate is because
/// some resource types (e.g. buffers and images) might be asynchronously
/// initialized by the user application. If a resource which is not
/// in the VALID state is attempted to be used for rendering, rendering
/// operations will silently be dropped.
/// 
/// The special INVALID state is returned in sg_query_xxx_state() if no
/// resource object exists for the provided resource id
enum ResourceState {
    Initial,
    Alloc,
    Valid,
    Failed,
    Invalid,
}
/// sg_usage
/// 
/// A resource usage hint describing the update strategy of
/// buffers and images. This is used in the sg_buffer_desc.usage
/// and sg_image_desc.usage members when creating buffers
/// and images:
/// 
/// SG_USAGE_IMMUTABLE:     the resource will never be updated with
///                         new data, instead the content of the
///                         resource must be provided on creation
/// SG_USAGE_DYNAMIC:       the resource will be updated infrequently
///                         with new data (this could range from "once
///                         after creation", to "quite often but not
///                         every frame")
/// SG_USAGE_STREAM:        the resource will be updated each frame
///                         with new content
/// 
/// The rendering backends use this hint to prevent that the
/// CPU needs to wait for the GPU when attempting to update
/// a resource that might be currently accessed by the GPU.
/// 
/// Resource content is updated with the functions sg_update_buffer() or
/// sg_append_buffer() for buffer objects, and sg_update_image() for image
/// objects. For the sg_update_*() functions, only one update is allowed per
/// frame and resource object, while sg_append_buffer() can be called
/// multiple times per frame on the same buffer. The application must update
/// all data required for rendering (this means that the update data can be
/// smaller than the resource size, if only a part of the overall resource
/// size is used for rendering, you only need to make sure that the data that
/// *is* used is valid).
/// 
/// The default usage is SG_USAGE_IMMUTABLE
enum Usage {
    Default,
    Immutable,
    Dynamic,
    Stream,
    Num,
}
/// sg_buffer_type
/// 
/// Indicates whether a buffer will be bound as vertex-,
/// index- or storage-buffer.
/// 
/// Used in the sg_buffer_desc.type member when creating a buffer.
/// 
/// The default value is SG_BUFFERTYPE_VERTEXBUFFER
enum BufferType {
    Default,
    Vertexbuffer,
    Indexbuffer,
    Storagebuffer,
    Num,
}
/// sg_index_type
/// 
/// Indicates whether indexed rendering (fetching vertex-indices from an
/// index buffer) is used, and if yes, the index data type (16- or 32-bits).
/// 
/// This is used in the sg_pipeline_desc.index_type member when creating a
/// pipeline object.
/// 
/// The default index type is SG_INDEXTYPE_NONE
enum IndexType {
    Default,
    None,
    Uint16,
    Uint32,
    Num,
}
/// sg_image_type
/// 
/// Indicates the basic type of an image object (2D-texture, cubemap,
/// 3D-texture or 2D-array-texture). Used in the sg_image_desc.type member when
/// creating an image, and in sg_shader_image_desc to describe a sampled texture
/// in the shader (both must match and will be checked in the validation layer
/// when calling sg_apply_bindings).
/// 
/// The default image type when creating an image is SG_IMAGETYPE_2D
enum ImageType {
    Default,
    _2d,
    Cube,
    _3d,
    Array,
    Num,
}
/// sg_image_sample_type
/// 
/// The basic data type of a texture sample as expected by a shader.
/// Must be provided in sg_shader_image and used by the validation
/// layer in sg_apply_bindings() to check if the provided image object
/// is compatible with what the shader expects. Apart from the sokol-gfx
/// validation layer, WebGPU is the only backend API which actually requires
/// matching texture and sampler type to be provided upfront for validation
/// (other 3D APIs treat texture/sampler type mismatches as undefined behaviour).
/// 
/// NOTE that the following texture pixel formats require the use
/// of SG_IMAGESAMPLETYPE_UNFILTERABLE_FLOAT, combined with a sampler
/// of type SG_SAMPLERTYPE_NONFILTERING:
/// 
/// - SG_PIXELFORMAT_R32F
/// - SG_PIXELFORMAT_RG32F
/// - SG_PIXELFORMAT_RGBA32F
/// 
/// (when using sokol-shdc, also check out the meta tags `@image_sample_type`
/// and `@sampler_type`
enum ImageSampleType {
    Default,
    Float,
    Depth,
    Sint,
    Uint,
    Unfilterable_float,
    Num,
}
/// sg_sampler_type
/// 
/// The basic type of a texture sampler (sampling vs comparison) as
/// defined in a shader. Must be provided in sg_shader_sampler_desc.
/// 
/// sg_image_sample_type and sg_sampler_type for a texture/sampler
/// pair must be compatible with each other, specifically only
/// the following pairs are allowed:
/// 
/// - SG_IMAGESAMPLETYPE_FLOAT => (SG_SAMPLERTYPE_FILTERING or SG_SAMPLERTYPE_NONFILTERING)
/// - SG_IMAGESAMPLETYPE_UNFILTERABLE_FLOAT => SG_SAMPLERTYPE_NONFILTERING
/// - SG_IMAGESAMPLETYPE_SINT => SG_SAMPLERTYPE_NONFILTERING
/// - SG_IMAGESAMPLETYPE_UINT => SG_SAMPLERTYPE_NONFILTERING
/// - SG_IMAGESAMPLETYPE_DEPTH => SG_SAMPLERTYPE_COMPARISO
enum SamplerType {
    Default,
    Filtering,
    Nonfiltering,
    Comparison,
    Num,
}
/// sg_cube_face
/// 
/// The cubemap faces. Use these as indices in the sg_image_desc.content
/// array
enum CubeFace {
    Pos_x,
    Neg_x,
    Pos_y,
    Neg_y,
    Pos_z,
    Neg_z,
    Num,
}
/// sg_primitive_type
/// 
/// This is the common subset of 3D primitive types supported across all 3D
/// APIs. This is used in the sg_pipeline_desc.primitive_type member when
/// creating a pipeline object.
/// 
/// The default primitive type is SG_PRIMITIVETYPE_TRIANGLES
enum PrimitiveType {
    Default,
    Points,
    Lines,
    Line_strip,
    Triangles,
    Triangle_strip,
    Num,
}
/// sg_filter
/// 
/// The filtering mode when sampling a texture image. This is
/// used in the sg_sampler_desc.min_filter, sg_sampler_desc.mag_filter
/// and sg_sampler_desc.mipmap_filter members when creating a sampler object.
/// 
/// For the default is SG_FILTER_NEAREST
enum Filter {
    Default,
    Nearest,
    Linear,
    Num,
}
/// sg_wrap
/// 
/// The texture coordinates wrapping mode when sampling a texture
/// image. This is used in the sg_image_desc.wrap_u, .wrap_v
/// and .wrap_w members when creating an image.
/// 
/// The default wrap mode is SG_WRAP_REPEAT.
/// 
/// NOTE: SG_WRAP_CLAMP_TO_BORDER is not supported on all backends
/// and platforms. To check for support, call sg_query_features()
/// and check the "clamp_to_border" boolean in the returned
/// sg_features struct.
/// 
/// Platforms which don't support SG_WRAP_CLAMP_TO_BORDER will silently fall back
/// to SG_WRAP_CLAMP_TO_EDGE without a validation error
enum Wrap {
    Default,
    Repeat,
    Clamp_to_edge,
    Clamp_to_border,
    Mirrored_repeat,
    Num,
}
/// sg_border_color
/// 
/// The border color to use when sampling a texture, and the UV wrap
/// mode is SG_WRAP_CLAMP_TO_BORDER.
/// 
/// The default border color is SG_BORDERCOLOR_OPAQUE_BLAC
enum BorderColor {
    Default,
    Transparent_black,
    Opaque_black,
    Opaque_white,
    Num,
}
/// sg_vertex_format
/// 
/// The data type of a vertex component. This is used to describe
/// the layout of vertex data when creating a pipeline object
enum VertexFormat {
    Invalid,
    Float,
    Float2,
    Float3,
    Float4,
    Byte4,
    Byte4n,
    Ubyte4,
    Ubyte4n,
    Short2,
    Short2n,
    Ushort2n,
    Short4,
    Short4n,
    Ushort4n,
    Uint10_n2,
    Half2,
    Half4,
    Num,
}
/// sg_vertex_step
/// 
/// Defines whether the input pointer of a vertex input stream is advanced
/// 'per vertex' or 'per instance'. The default step-func is
/// SG_VERTEXSTEP_PER_VERTEX. SG_VERTEXSTEP_PER_INSTANCE is used with
/// instanced-rendering.
/// 
/// The vertex-step is part of the vertex-layout definition
/// when creating pipeline objects
enum VertexStep {
    Default,
    Per_vertex,
    Per_instance,
    Num,
}
/// sg_uniform_type
/// 
/// The data type of a uniform block member. This is used to
/// describe the internal layout of uniform blocks when creating
/// a shader object. This is only required for the GL backend, all
/// other backends will ignore the interior layout of uniform blocks
enum UniformType {
    Invalid,
    Float,
    Float2,
    Float3,
    Float4,
    Int,
    Int2,
    Int3,
    Int4,
    Mat4,
    Num,
}
/// sg_uniform_layout
/// 
/// A hint for the interior memory layout of uniform blocks. This is
/// only relevant for the GL backend where the internal layout
/// of uniform blocks must be known to sokol-gfx. For all other backends the
/// internal memory layout of uniform blocks doesn't matter, sokol-gfx
/// will just pass uniform data as a single memory blob to the
/// 3D backend.
/// 
/// SG_UNIFORMLAYOUT_NATIVE (default)
///     Native layout means that a 'backend-native' memory layout
///     is used. For the GL backend this means that uniforms
///     are packed tightly in memory (e.g. there are no padding
///     bytes).
/// 
/// SG_UNIFORMLAYOUT_STD140
///     The memory layout is a subset of std140. Arrays are only
///     allowed for the FLOAT4, INT4 and MAT4. Alignment is as
///     is as follows:
/// 
///         FLOAT, INT:         4 byte alignment
///         FLOAT2, INT2:       8 byte alignment
///         FLOAT3, INT3:       16 byte alignment(!)
///         FLOAT4, INT4:       16 byte alignment
///         MAT4:               16 byte alignment
///         FLOAT4[], INT4[]:   16 byte alignment
/// 
///     The overall size of the uniform block must be a multiple
///     of 16.
/// 
/// For more information search for 'UNIFORM DATA LAYOUT' in the documentation block
/// at the start of the header
enum UniformLayout {
    Default,
    Native,
    Std140,
    Num,
}
/// sg_cull_mode
/// 
/// The face-culling mode, this is used in the
/// sg_pipeline_desc.cull_mode member when creating a
/// pipeline object.
/// 
/// The default cull mode is SG_CULLMODE_NON
enum CullMode {
    Default,
    None,
    Front,
    Back,
    Num,
}
/// sg_face_winding
/// 
/// The vertex-winding rule that determines a front-facing primitive. This
/// is used in the member sg_pipeline_desc.face_winding
/// when creating a pipeline object.
/// 
/// The default winding is SG_FACEWINDING_CW (clockwise
enum FaceWinding {
    Default,
    Ccw,
    Cw,
    Num,
}
/// sg_compare_func
/// 
/// The compare-function for configuring depth- and stencil-ref tests
/// in pipeline objects, and for texture samplers which perform a comparison
/// instead of regular sampling operation.
/// 
/// Used in the following structs:
/// 
/// sg_pipeline_desc
///     .depth
///         .compare
///     .stencil
///         .front.compare
///         .back.compar
/// 
/// sg_sampler_desc
///     .compare
/// 
/// The default compare func for depth- and stencil-tests is
/// SG_COMPAREFUNC_ALWAYS.
/// 
/// The default compare func for samplers is SG_COMPAREFUNC_NEVER
enum CompareFunc {
    Default,
    Never,
    Less,
    Equal,
    Less_equal,
    Greater,
    Not_equal,
    Greater_equal,
    Always,
    Num,
}
/// sg_stencil_op
/// 
/// The operation performed on a currently stored stencil-value when a
/// comparison test passes or fails. This is used when creating a pipeline
/// object in the following sg_pipeline_desc struct items:
/// 
/// sg_pipeline_desc
///     .stencil
///         .front
///             .fail_op
///             .depth_fail_op
///             .pass_op
///         .back
///             .fail_op
///             .depth_fail_op
///             .pass_op
/// 
/// The default value is SG_STENCILOP_KEEP
enum StencilOp {
    Default,
    Keep,
    Zero,
    Replace,
    Incr_clamp,
    Decr_clamp,
    Invert,
    Incr_wrap,
    Decr_wrap,
    Num,
}
/// sg_blend_factor
/// 
/// The source and destination factors in blending operations.
/// This is used in the following members when creating a pipeline object:
/// 
/// sg_pipeline_desc
///     .colors[i]
///         .blend
///             .src_factor_rgb
///             .dst_factor_rgb
///             .src_factor_alpha
///             .dst_factor_alpha
/// 
/// The default value is SG_BLENDFACTOR_ONE for source
/// factors, and SG_BLENDFACTOR_ZERO for destination factors
enum BlendFactor {
    Default,
    Zero,
    One,
    Src_color,
    One_minus_src_color,
    Src_alpha,
    One_minus_src_alpha,
    Dst_color,
    One_minus_dst_color,
    Dst_alpha,
    One_minus_dst_alpha,
    Src_alpha_saturated,
    Blend_color,
    One_minus_blend_color,
    Blend_alpha,
    One_minus_blend_alpha,
    Num,
}
/// sg_blend_op
/// 
/// Describes how the source and destination values are combined in the
/// fragment blending operation. It is used in the following struct items
/// when creating a pipeline object:
/// 
/// sg_pipeline_desc
///     .colors[i]
///         .blend
///             .op_rgb
///             .op_alpha
/// 
/// The default value is SG_BLENDOP_ADD
enum BlendOp {
    Default,
    Add,
    Subtract,
    Reverse_subtract,
    Num,
}
/// sg_color_mask
/// 
/// Selects the active color channels when writing a fragment color to the
/// framebuffer. This is used in the members
/// sg_pipeline_desc.colors[i].write_mask when creating a pipeline object.
/// 
/// The default colormask is SG_COLORMASK_RGBA (write all colors channels)
/// 
/// NOTE: since the color mask value 0 is reserved for the default value
/// (SG_COLORMASK_RGBA), use SG_COLORMASK_NONE if all color channels
/// should be disabled
enum ColorMask {
    Default = 0,
    None = 16,
    R = 1,
    G = 2,
    Rg = 3,
    B = 4,
    Rb = 5,
    Gb = 6,
    Rgb = 7,
    A = 8,
    Ra = 9,
    Ga = 10,
    Rga = 11,
    Ba = 12,
    Rba = 13,
    Gba = 14,
    Rgba = 15,
}
/// sg_load_action
/// 
/// Defines the load action that should be performed at the start of a render pass:
/// 
/// SG_LOADACTION_CLEAR:        clear the render target
/// SG_LOADACTION_LOAD:         load the previous content of the render target
/// SG_LOADACTION_DONTCARE:     leave the render target in an undefined state
/// 
/// This is used in the sg_pass_action structure.
/// 
/// The default load action for all pass attachments is SG_LOADACTION_CLEAR,
/// with the values rgba = { 0.5f, 0.5f, 0.5f, 1.0f }, depth=1.0f and stencil=0.
/// 
/// If you want to override the default behaviour, it is important to not
/// only set the clear color, but the 'action' field as well (as long as this
/// is _SG_LOADACTION_DEFAULT, the value fields will be ignored)
enum LoadAction {
    Default,
    Clear,
    Load,
    Dontcare,
}
/// sg_store_action
/// 
/// Defines the store action that should be performed at the end of a render pass:
/// 
/// SG_STOREACTION_STORE:       store the rendered content to the color attachment image
/// SG_STOREACTION_DONTCARE:    allows the GPU to discard the rendered conten
enum StoreAction {
    Default,
    Store,
    Dontcare,
}
/// sg_pass_action
/// 
/// The sg_pass_action struct defines the actions to be performed
/// at the start and end of a render pass.
/// 
/// - at the start of the pass: whether the render attachments should be cleared,
///   loaded with their previous content, or start in an undefined state
/// - for clear operations: the clear value (color, depth, or stencil values)
/// - at the end of the pass: whether the rendering result should be
///   stored back into the render attachment or discarde
extern(C)
struct ColorAttachmentAction {
    LoadAction load_action;
    StoreAction store_action;
    Color clear_value;
}
extern(C)
struct DepthAttachmentAction {
    LoadAction load_action;
    StoreAction store_action;
    float clear_value = 0.0f;
}
extern(C)
struct StencilAttachmentAction {
    LoadAction load_action;
    StoreAction store_action;
    ubyte clear_value = 0;
}
extern(C)
struct PassAction {
    ColorAttachmentAction[4] colors;
    DepthAttachmentAction depth;
    StencilAttachmentAction stencil;
}
/// sg_swapchain
/// 
/// Used in sg_begin_pass() to provide details about an external swapchain
/// (pixel formats, sample count and backend-API specific render surface objects).
/// 
/// The following information must be provided:
/// 
/// - the width and height of the swapchain surfaces in number of pixels,
/// - the pixel format of the render- and optional msaa-resolve-surface
/// - the pixel format of the optional depth- or depth-stencil-surface
/// - the MSAA sample count for the render and depth-stencil surface
/// 
/// If the pixel formats and MSAA sample counts are left zero-initialized,
/// their defaults are taken from the sg_environment struct provided in the
/// sg_setup() call.
/// 
/// The width and height *must* be > 0.
/// 
/// Additionally the following backend API specific objects must be passed in
/// as 'type erased' void pointers:
/// 
/// GL:
///     - on all GL backends, a GL framebuffer object must be provided. This
///       can be zero for the default framebuffer.
/// 
/// D3D11:
///     - an ID3D11RenderTargetView for the rendering surface, without
///       MSAA rendering this surface will also be displayed
///     - an optional ID3D11DepthStencilView for the depth- or depth/stencil
///       buffer surface
///     - when MSAA rendering is used, another ID3D11RenderTargetView
///       which serves as MSAA resolve target and will be displayed
/// 
/// WebGPU (same as D3D11, except different types)
///     - a WGPUTextureView for the rendering surface, without
///       MSAA rendering this surface will also be displayed
///     - an optional WGPUTextureView for the depth- or depth/stencil
///       buffer surface
///     - when MSAA rendering is used, another WGPUTextureView
///       which serves as MSAA resolve target and will be displayed
/// 
/// Metal (NOTE that the roles of provided surfaces is slightly different
/// than on D3D11 or WebGPU in case of MSAA vs non-MSAA rendering):
/// 
///     - A current CAMetalDrawable (NOT an MTLDrawable!) which will be presented.
///       This will either be rendered to directly (if no MSAA is used), or serve
///       as MSAA-resolve target.
///     - an optional MTLTexture for the depth- or depth-stencil buffer
///     - an optional multisampled MTLTexture which serves as intermediate
///       rendering surface which will then be resolved into the
///       CAMetalDrawable.
/// 
/// NOTE that for Metal you must use an ObjC __bridge cast to
/// properly tunnel the ObjC object id through a C void*, e.g.:
/// 
///     swapchain.metal.current_drawable = (__bridge const void*) [mtkView currentDrawable];
/// 
/// On all other backends you shouldn't need to mess with the reference count.
/// 
/// It's a good practice to write a helper function which returns an initialized
/// sg_swapchain structs, which can then be plugged directly into
/// sg_pass.swapchain. Look at the function sglue_swapchain() in the sokol_glue.h
/// as an example
extern(C)
struct MetalSwapchain {
    const(void)* current_drawable = null;
    const(void)* depth_stencil_texture = null;
    const(void)* msaa_color_texture = null;
}
extern(C)
struct D3d11Swapchain {
    const(void)* render_view = null;
    const(void)* resolve_view = null;
    const(void)* depth_stencil_view = null;
}
extern(C)
struct WgpuSwapchain {
    const(void)* render_view = null;
    const(void)* resolve_view = null;
    const(void)* depth_stencil_view = null;
}
extern(C)
struct GlSwapchain {
    uint framebuffer = 0;
}
extern(C)
struct Swapchain {
    int width = 0;
    int height = 0;
    int sample_count = 0;
    PixelFormat color_format;
    PixelFormat depth_format;
    MetalSwapchain metal;
    D3d11Swapchain d3d11;
    WgpuSwapchain wgpu;
    GlSwapchain gl;
}
/// sg_pass
/// 
/// The sg_pass structure is passed as argument into the sg_begin_pass()
/// function.
/// 
/// For an offscreen rendering pass, an sg_pass_action struct and sg_attachments
/// object must be provided, and for swapchain passes, an sg_pass_action and
/// an sg_swapchain struct. It is an error to provide both an sg_attachments
/// handle and an initialized sg_swapchain struct in the same sg_begin_pass().
/// 
/// An sg_begin_pass() call for an offscreen pass would look like this (where
/// `attachments` is an sg_attachments handle):
/// 
///     sg_begin_pass(&(sg_pass){
///         .action = { ... },
///         .attachments = attachments,
///     });
/// 
/// ...and a swapchain render pass would look like this (using the sokol_glue.h
/// helper function sglue_swapchain() which gets the swapchain properties from
/// sokol_app.h):
/// 
///     sg_begin_pass(&(sg_pass){
///         .action = { ... },
///         .swapchain = sglue_swapchain(),
///     });
/// 
/// You can also omit the .action object to get default pass action behaviour
/// (clear to color=grey, depth=1 and stencil=0)
extern(C)
struct Pass {
    uint _start_canary = 0;
    PassAction action;
    Attachments attachments;
    Swapchain swapchain;
    const(char)* label = null;
    uint _end_canary = 0;
}
/// sg_bindings
/// 
/// The sg_bindings structure defines the buffers, images and
/// samplers resource bindings for the next draw call.
/// 
/// To update the resource bindings, call sg_apply_bindings() with
/// a pointer to a populated sg_bindings struct. Note that
/// sg_apply_bindings() must be called after sg_apply_pipeline()
/// and that bindings are not preserved across sg_apply_pipeline()
/// calls, even when the new pipeline uses the same 'bindings layout'.
/// 
/// A resource binding struct contains:
/// 
/// - 1..N vertex buffers
/// - 0..N vertex buffer offsets
/// - 0..1 index buffers
/// - 0..1 index buffer offsets
/// - 0..N images
/// - 0..N samplers
/// - 0..N storage buffers
/// 
/// Where 'N' is defined in the following constants:
/// 
/// - SG_MAX_VERTEXBUFFER_BINDSLOTS
/// - SG_MAX_IMAGE_BINDLOTS
/// - SG_MAX_SAMPLER_BINDSLOTS
/// - SG_MAX_STORAGEBUFFER_BINDGLOTS
/// 
/// When using sokol-shdc for shader authoring, the `layout(binding=N)`
/// annotation in the shader code directly maps to the slot index for that
/// resource type in the bindings struct, for instance the following vertex-
/// and fragment-shader interface for sokol-shdc:
/// 
///     @vs vs
///     layout(binding=0) uniform vs_params { ... };
///     layout(binding=0) readonly buffer ssbo { ... };
///     layout(binding=0) uniform texture2D vs_tex;
///     layout(binding=0) uniform sampler vs_smp;
///     ...
///     @end
/// 
///     @fs fs
///     layout(binding=1) uniform fs_params { ... };
///     layout(binding=1) uniform texture2D fs_tex;
///     layout(binding=1) uniform sampler fs_smp;
///     ...
///     @end
/// 
/// ...would map to the following sg_bindings struct:
/// 
///     const sg_bindings bnd = {
///         .vertex_buffers[0] = ...,
///         .images[0] = vs_tex,
///         .images[1] = fs_tex,
///         .samplers[0] = vs_smp,
///         .samplers[1] = fs_smp,
///         .storage_buffers[0] = ssbo,
///     };
/// 
/// ...alternatively you can use code-generated slot indices:
/// 
///     const sg_bindings bnd = {
///         .vertex_buffers[0] = ...,
///         .images[IMG_vs_tex] = vs_tex,
///         .images[IMG_fs_tex] = fs_tex,
///         .samplers[SMP_vs_smp] = vs_smp,
///         .samplers[SMP_fs_smp] = fs_smp,
///         .storage_buffers[SBUF_ssbo] = ssbo,
///     };
/// 
/// Resource bindslots for a specific shader/pipeline may have gaps, and an
/// sg_bindings struct may have populated bind slots which are not used by a
/// specific shader. This allows to use the same sg_bindings struct across
/// different shader variants.
/// 
/// When not using sokol-shdc, the bindslot indices in the sg_bindings
/// struct need to match the per-resource reflection info slot indices
/// in the sg_shader_desc struct (for details about that see the
/// sg_shader_desc struct documentation).
/// 
/// The optional buffer offsets can be used to put different unrelated
/// chunks of vertex- and/or index-data into the same buffer objects
extern(C)
struct Bindings {
    uint _start_canary = 0;
    Buffer[8] vertex_buffers;
    int[8] vertex_buffer_offsets = 0;
    Buffer index_buffer;
    int index_buffer_offset = 0;
    Image[16] images;
    Sampler[16] samplers;
    Buffer[8] storage_buffers;
    uint _end_canary = 0;
}
/// sg_buffer_desc
/// 
/// Creation parameters for sg_buffer objects, used in the
/// sg_make_buffer() call.
/// 
/// The default configuration is:
/// 
/// .size:      0       (*must* be >0 for buffers without data)
/// .type:      SG_BUFFERTYPE_VERTEXBUFFER
/// .usage:     SG_USAGE_IMMUTABLE
/// .data.ptr   0       (*must* be valid for immutable buffers)
/// .data.size  0       (*must* be > 0 for immutable buffers)
/// .label      0       (optional string label)
/// 
/// For immutable buffers which are initialized with initial data,
/// keep the .size item zero-initialized, and set the size together with the
/// pointer to the initial data in the .data item.
/// 
/// For mutable buffers without initial data, keep the .data item
/// zero-initialized, and set the buffer size in the .size item instead.
/// 
/// You can also set both size values, but currently both size values must
/// be identical (this may change in the future when the dynamic resource
/// management may become more flexible).
/// 
/// ADVANCED TOPIC: Injecting native 3D-API buffers:
/// 
/// The following struct members allow to inject your own GL, Metal
/// or D3D11 buffers into sokol_gfx:
/// 
/// .gl_buffers[SG_NUM_INFLIGHT_FRAMES]
/// .mtl_buffers[SG_NUM_INFLIGHT_FRAMES]
/// .d3d11_buffer
/// 
/// You must still provide all other struct items except the .data item, and
/// these must match the creation parameters of the native buffers you
/// provide. For SG_USAGE_IMMUTABLE, only provide a single native 3D-API
/// buffer, otherwise you need to provide SG_NUM_INFLIGHT_FRAMES buffers
/// (only for GL and Metal, not D3D11). Providing multiple buffers for GL and
/// Metal is necessary because sokol_gfx will rotate through them when
/// calling sg_update_buffer() to prevent lock-stalls.
/// 
/// Note that it is expected that immutable injected buffer have already been
/// initialized with content, and the .content member must be 0!
/// 
/// Also you need to call sg_reset_state_cache() after calling native 3D-API
/// functions, and before calling any sokol_gfx function
extern(C)
struct BufferDesc {
    uint _start_canary = 0;
    size_t size = 0;
    BufferType type;
    Usage usage;
    Range data;
    const(char)* label = null;
    uint[2] gl_buffers = 0;
    const(void)*[2] mtl_buffers = null;
    const(void)* d3d11_buffer = null;
    const(void)* wgpu_buffer = null;
    uint _end_canary = 0;
}
/// sg_image_data
/// 
/// Defines the content of an image through a 2D array of sg_range structs.
/// The first array dimension is the cubemap face, and the second array
/// dimension the mipmap level
extern(C)
struct ImageData {
    Range[6][16] subimage;
}
/// sg_image_desc
/// 
/// Creation parameters for sg_image objects, used in the sg_make_image() call.
/// 
/// The default configuration is:
/// 
/// .type:              SG_IMAGETYPE_2D
/// .render_target:     false
/// .width              0 (must be set to >0)
/// .height             0 (must be set to >0)
/// .num_slices         1 (3D textures: depth; array textures: number of layers)
/// .num_mipmaps:       1
/// .usage:             SG_USAGE_IMMUTABLE
/// .pixel_format:      SG_PIXELFORMAT_RGBA8 for textures, or sg_desc.environment.defaults.color_format for render targets
/// .sample_count:      1 for textures, or sg_desc.environment.defaults.sample_count for render targets
/// .data               an sg_image_data struct to define the initial content
/// .label              0 (optional string label for trace hooks)
/// 
/// Q: Why is the default sample_count for render targets identical with the
/// "default sample count" from sg_desc.environment.defaults.sample_count?
/// 
/// A: So that it matches the default sample count in pipeline objects. Even
/// though it is a bit strange/confusing that offscreen render targets by default
/// get the same sample count as 'default swapchains', but it's better that
/// an offscreen render target created with default parameters matches
/// a pipeline object created with default parameters.
/// 
/// NOTE:
/// 
/// Images with usage SG_USAGE_IMMUTABLE must be fully initialized by
/// providing a valid .data member which points to initialization data.
/// 
/// ADVANCED TOPIC: Injecting native 3D-API textures:
/// 
/// The following struct members allow to inject your own GL, Metal or D3D11
/// textures into sokol_gfx:
/// 
/// .gl_textures[SG_NUM_INFLIGHT_FRAMES]
/// .mtl_textures[SG_NUM_INFLIGHT_FRAMES]
/// .d3d11_texture
/// .d3d11_shader_resource_view
/// .wgpu_texture
/// .wgpu_texture_view
/// 
/// For GL, you can also specify the texture target or leave it empty to use
/// the default texture target for the image type (GL_TEXTURE_2D for
/// SG_IMAGETYPE_2D etc)
/// 
/// For D3D11 and WebGPU, either only provide a texture, or both a texture and
/// shader-resource-view / texture-view object. If you want to use access the
/// injected texture in a shader you *must* provide a shader-resource-view.
/// 
/// The same rules apply as for injecting native buffers (see sg_buffer_desc
/// documentation for more details)
extern(C)
struct ImageDesc {
    uint _start_canary = 0;
    ImageType type;
    bool render_target = false;
    int width = 0;
    int height = 0;
    int num_slices = 0;
    int num_mipmaps = 0;
    Usage usage;
    PixelFormat pixel_format;
    int sample_count = 0;
    ImageData data;
    const(char)* label = null;
    uint[2] gl_textures = 0;
    uint gl_texture_target = 0;
    const(void)*[2] mtl_textures = null;
    const(void)* d3d11_texture = null;
    const(void)* d3d11_shader_resource_view = null;
    const(void)* wgpu_texture = null;
    const(void)* wgpu_texture_view = null;
    uint _end_canary = 0;
}
/// sg_sampler_desc
/// 
/// Creation parameters for sg_sampler objects, used in the sg_make_sampler() call
/// 
/// .min_filter:        SG_FILTER_NEAREST
/// .mag_filter:        SG_FILTER_NEAREST
/// .mipmap_filter      SG_FILTER_NEAREST
/// .wrap_u:            SG_WRAP_REPEAT
/// .wrap_v:            SG_WRAP_REPEAT
/// .wrap_w:            SG_WRAP_REPEAT (only SG_IMAGETYPE_3D)
/// .min_lod            0.0f
/// .max_lod            FLT_MAX
/// .border_color       SG_BORDERCOLOR_OPAQUE_BLACK
/// .compare            SG_COMPAREFUNC_NEVER
/// .max_anisotropy     1 (must be 1..16
extern(C)
struct SamplerDesc {
    uint _start_canary = 0;
    Filter min_filter;
    Filter mag_filter;
    Filter mipmap_filter;
    Wrap wrap_u;
    Wrap wrap_v;
    Wrap wrap_w;
    float min_lod = 0.0f;
    float max_lod = 0.0f;
    BorderColor border_color;
    CompareFunc compare;
    uint max_anisotropy = 0;
    const(char)* label = null;
    uint gl_sampler = 0;
    const(void)* mtl_sampler = null;
    const(void)* d3d11_sampler = null;
    const(void)* wgpu_sampler = null;
    uint _end_canary = 0;
}
/// sg_shader_desc
/// 
/// Used as parameter of sg_make_shader() to create a shader object which
/// communicates shader source or bytecode and shader interface
/// reflection information to sokol-gfx.
/// 
/// If you use sokol-shdc you can ignore the following information since
/// the sg_shader_desc struct will be code generated.
/// 
/// Otherwise you need to provide the following information to the
/// sg_make_shader() call:
/// 
/// - a vertex- and fragment-shader function:
///     - the shader source or bytecode
///     - an optional entry point name
///     - for D3D11: an optional compile target when source code is provided
///       (the defaults are "vs_4_0" and "ps_4_0")
/// 
/// - vertex attributes required by some backends:
///     - for the GL backend: optional vertex attribute names
///       used for name lookup
///     - for the D3D11 backend: semantic names and indices
/// 
/// - reflection information for each uniform block used by the shader:
///     - the shader stage the uniform block appears in (SG_SHADERSTAGE_*)
///     - the size in bytes of the uniform block
///     - backend-specific bindslots:
///         - HLSL: the constant buffer register `register(b0..7)`
///         - MSL: the buffer attribute `[[buffer(0..7)]]`
///         - WGSL: the binding in `@group(0) @binding(0..15)`
///     - GLSL only: a description of the uniform block interior
///         - the memory layout standard (SG_UNIFORMLAYOUT_*)
///         - for each member in the uniform block:
///             - the member type (SG_UNIFORM_*)
///             - if the member is an array, the array count
///             - the member name
/// 
/// - reflection information for each texture used by the shader:
///     - the shader stage the texture appears in (SG_SHADERSTAGE_*)
///     - the image type (SG_IMAGETYPE_*)
///     - the image-sample type (SG_IMAGESAMPLETYPE_*)
///     - whether the texture is multisampled
///     - backend specific bindslots:
///         - HLSL: the texture register `register(t0..23)`
///         - MSL: the texture attribute `[[texture(0..15)]]`
///         - WGSL: the binding in `@group(1) @binding(0..127)`
/// 
/// - reflection information for each sampler used by the shader:
///     - the shader stage the sampler appears in (SG_SHADERSTAGE_*)
///     - the sampler type (SG_SAMPLERTYPE_*)
///     - backend specific bindslots:
///         - HLSL: the sampler register `register(s0..15)`
///         - MSL: the sampler attribute `[[sampler(0..15)]]`
///         - WGSL: the binding in `@group(0) @binding(0..127)`
/// 
/// - reflection information for each storage buffer used by the shader:
///     - the shader stage the storage buffer appears in (SG_SHADERSTAGE_*)
///     - whether the storage buffer is readonly (currently this must
///       always be true)
///     - backend specific bindslots:
///         - HLSL: the texture(sic) register `register(t0..23)`
///         - MSL: the buffer attribute `[[buffer(8..15)]]`
///         - WGSL: the binding in `@group(1) @binding(0..127)`
///         - GL: the binding in `layout(binding=0..16)`
/// 
/// - reflection information for each combined image-sampler object
///   used by the shader:
///     - the shader stage (SG_SHADERSTAGE_*)
///     - the texture's array index in the sg_shader_desc.images[] array
///     - the sampler's array index in the sg_shader_desc.samplers[] array
///     - GLSL only: the name of the combined image-sampler object
/// 
/// The number and order of items in the sg_shader_desc.attrs[]
/// array corresponds to the items in sg_pipeline_desc.layout.attrs.
/// 
///     - sg_shader_desc.attrs[N] => sg_pipeline_desc.layout.attrs[N]
/// 
/// NOTE that vertex attribute indices currently cannot have gaps.
/// 
/// The items index in the sg_shader_desc.uniform_blocks[] array corresponds
/// to the ub_slot arg in sg_apply_uniforms():
/// 
///     - sg_shader_desc.uniform_blocks[N] => sg_apply_uniforms(N, ...)
/// 
/// The items in the shader_desc images, samplers and storage_buffers
/// arrays correspond to the same array items in the sg_bindings struct:
/// 
///     - sg_shader_desc.images[N] => sg_bindings.images[N]
///     - sg_shader_desc.samplers[N] => sg_bindings.samplers[N]
///     - sg_shader_desc.storage_buffers[N] => sg_bindings.storage_buffers[N]
/// 
/// For all GL backends, shader source-code must be provided. For D3D11 and Metal,
/// either shader source-code or byte-code can be provided.
/// 
/// NOTE that the uniform block, image, sampler and storage_buffer arrays
/// can have gaps. This allows to use the same sg_bindings struct for
/// different related shader variants.
/// 
/// For D3D11, if source code is provided, the d3dcompiler_47.dll will be loaded
/// on demand. If this fails, shader creation will fail. When compiling HLSL
/// source code, you can provide an optional target string via
/// sg_shader_stage_desc.d3d11_target, the default target is "vs_4_0" for the
/// vertex shader stage and "ps_4_0" for the pixel shader stage
enum ShaderStage {
    None,
    Vertex,
    Fragment,
}
extern(C)
struct ShaderFunction {
    const(char)* source = null;
    Range bytecode;
    const(char)* entry = null;
    const(char)* d3d11_target = null;
}
extern(C)
struct ShaderVertexAttr {
    const(char)* glsl_name = null;
    const(char)* hlsl_sem_name = null;
    ubyte hlsl_sem_index = 0;
}
extern(C)
struct GlslShaderUniform {
    UniformType type;
    ushort array_count = 0;
    const(char)* glsl_name = null;
}
extern(C)
struct ShaderUniformBlock {
    ShaderStage stage;
    uint size = 0;
    ubyte hlsl_register_b_n = 0;
    ubyte msl_buffer_n = 0;
    ubyte wgsl_group0_binding_n = 0;
    UniformLayout layout;
    GlslShaderUniform[16] glsl_uniforms;
}
extern(C)
struct ShaderImage {
    ShaderStage stage;
    ImageType image_type;
    ImageSampleType sample_type;
    bool multisampled = false;
    ubyte hlsl_register_t_n = 0;
    ubyte msl_texture_n = 0;
    ubyte wgsl_group1_binding_n = 0;
}
extern(C)
struct ShaderSampler {
    ShaderStage stage;
    SamplerType sampler_type;
    ubyte hlsl_register_s_n = 0;
    ubyte msl_sampler_n = 0;
    ubyte wgsl_group1_binding_n = 0;
}
extern(C)
struct ShaderStorageBuffer {
    ShaderStage stage;
    bool readonly = false;
    ubyte hlsl_register_t_n = 0;
    ubyte msl_buffer_n = 0;
    ubyte wgsl_group1_binding_n = 0;
    ubyte glsl_binding_n = 0;
}
extern(C)
struct ShaderImageSamplerPair {
    ShaderStage stage;
    ubyte image_slot = 0;
    ubyte sampler_slot = 0;
    const(char)* glsl_name = null;
}
extern(C)
struct ShaderDesc {
    uint _start_canary = 0;
    ShaderFunction vertex_func;
    ShaderFunction fragment_func;
    ShaderVertexAttr[16] attrs;
    ShaderUniformBlock[8] uniform_blocks;
    ShaderStorageBuffer[8] storage_buffers;
    ShaderImage[16] images;
    ShaderSampler[16] samplers;
    ShaderImageSamplerPair[16] image_sampler_pairs;
    const(char)* label = null;
    uint _end_canary = 0;
}
/// sg_pipeline_desc
/// 
/// The sg_pipeline_desc struct defines all creation parameters for an
/// sg_pipeline object, used as argument to the sg_make_pipeline() function:
/// 
/// - the vertex layout for all input vertex buffers
/// - a shader object
/// - the 3D primitive type (points, lines, triangles, ...)
/// - the index type (none, 16- or 32-bit)
/// - all the fixed-function-pipeline state (depth-, stencil-, blend-state, etc...)
/// 
/// If the vertex data has no gaps between vertex components, you can omit
/// the .layout.buffers[].stride and layout.attrs[].offset items (leave them
/// default-initialized to 0), sokol-gfx will then compute the offsets and
/// strides from the vertex component formats (.layout.attrs[].format).
/// Please note that ALL vertex attribute offsets must be 0 in order for the
/// automatic offset computation to kick in.
/// 
/// The default configuration is as follows:
/// 
/// .shader:                0 (must be initialized with a valid sg_shader id!)
/// .layout:
///     .buffers[]:         vertex buffer layouts
///         .stride:        0 (if no stride is given it will be computed)
///         .step_func      SG_VERTEXSTEP_PER_VERTEX
///         .step_rate      1
///     .attrs[]:           vertex attribute declarations
///         .buffer_index   0 the vertex buffer bind slot
///         .offset         0 (offsets can be omitted if the vertex layout has no gaps)
///         .format         SG_VERTEXFORMAT_INVALID (must be initialized!)
/// .depth:
///     .pixel_format:      sg_desc.context.depth_format
///     .compare:           SG_COMPAREFUNC_ALWAYS
///     .write_enabled:     false
///     .bias:              0.0f
///     .bias_slope_scale:  0.0f
///     .bias_clamp:        0.0f
/// .stencil:
///     .enabled:           false
///     .front/back:
///         .compare:       SG_COMPAREFUNC_ALWAYS
///         .fail_op:       SG_STENCILOP_KEEP
///         .depth_fail_op: SG_STENCILOP_KEEP
///         .pass_op:       SG_STENCILOP_KEEP
///     .read_mask:         0
///     .write_mask:        0
///     .ref:               0
/// .color_count            1
/// .colors[0..color_count]
///     .pixel_format       sg_desc.context.color_format
///     .write_mask:        SG_COLORMASK_RGBA
///     .blend:
///         .enabled:           false
///         .src_factor_rgb:    SG_BLENDFACTOR_ONE
///         .dst_factor_rgb:    SG_BLENDFACTOR_ZERO
///         .op_rgb:            SG_BLENDOP_ADD
///         .src_factor_alpha:  SG_BLENDFACTOR_ONE
///         .dst_factor_alpha:  SG_BLENDFACTOR_ZERO
///         .op_alpha:          SG_BLENDOP_ADD
/// .primitive_type:            SG_PRIMITIVETYPE_TRIANGLES
/// .index_type:                SG_INDEXTYPE_NONE
/// .cull_mode:                 SG_CULLMODE_NONE
/// .face_winding:              SG_FACEWINDING_CW
/// .sample_count:              sg_desc.context.sample_count
/// .blend_color:               (sg_color) { 0.0f, 0.0f, 0.0f, 0.0f }
/// .alpha_to_coverage_enabled: false
/// .label  0       (optional string label for trace hooks
extern(C)
struct VertexBufferLayoutState {
    int stride = 0;
    VertexStep step_func;
    int step_rate = 0;
}
extern(C)
struct VertexAttrState {
    int buffer_index = 0;
    int offset = 0;
    VertexFormat format;
}
extern(C)
struct VertexLayoutState {
    VertexBufferLayoutState[8] buffers;
    VertexAttrState[16] attrs;
}
extern(C)
struct StencilFaceState {
    CompareFunc compare;
    StencilOp fail_op;
    StencilOp depth_fail_op;
    StencilOp pass_op;
}
extern(C)
struct StencilState {
    bool enabled = false;
    StencilFaceState front;
    StencilFaceState back;
    ubyte read_mask = 0;
    ubyte write_mask = 0;
    ubyte _ref = 0;
}
extern(C)
struct DepthState {
    PixelFormat pixel_format;
    CompareFunc compare;
    bool write_enabled = false;
    float bias = 0.0f;
    float bias_slope_scale = 0.0f;
    float bias_clamp = 0.0f;
}
extern(C)
struct BlendState {
    bool enabled = false;
    BlendFactor src_factor_rgb;
    BlendFactor dst_factor_rgb;
    BlendOp op_rgb;
    BlendFactor src_factor_alpha;
    BlendFactor dst_factor_alpha;
    BlendOp op_alpha;
}
extern(C)
struct ColorTargetState {
    PixelFormat pixel_format;
    ColorMask write_mask;
    BlendState blend;
}
extern(C)
struct PipelineDesc {
    uint _start_canary = 0;
    Shader shader;
    VertexLayoutState layout;
    DepthState depth;
    StencilState stencil;
    int color_count = 0;
    ColorTargetState[4] colors;
    PrimitiveType primitive_type;
    IndexType index_type;
    CullMode cull_mode;
    FaceWinding face_winding;
    int sample_count = 0;
    Color blend_color;
    bool alpha_to_coverage_enabled = false;
    const(char)* label = null;
    uint _end_canary = 0;
}
/// sg_attachments_desc
/// 
/// Creation parameters for an sg_attachments object, used as argument to the
/// sg_make_attachments() function.
/// 
/// An attachments object bundles 0..4 color attachments, 0..4 msaa-resolve
/// attachments, and none or one depth-stencil attachmente for use
/// in a render pass. At least one color attachment or one depth-stencil
/// attachment must be provided (no color attachment and a depth-stencil
/// attachment is useful for a depth-only render pass).
/// 
/// Each attachment definition consists of an image object, and two additional indices
/// describing which subimage the pass will render into: one mipmap index, and if the image
/// is a cubemap, array-texture or 3D-texture, the face-index, array-layer or
/// depth-slice.
/// 
/// All attachments must have the same width and height.
/// 
/// All color attachments and the depth-stencil attachment must have the
/// same sample count.
/// 
/// If a resolve attachment is set, an MSAA-resolve operation from the
/// associated color attachment image into the resolve attachment image will take
/// place in the sg_end_pass() function. In this case, the color attachment
/// must have a (sample_count>1), and the resolve attachment a
/// (sample_count==1). The resolve attachment also must have the same pixel
/// format as the color attachment.
/// 
/// NOTE that MSAA depth-stencil attachments cannot be msaa-resolved
extern(C)
struct AttachmentDesc {
    Image image;
    int mip_level = 0;
    int slice = 0;
}
extern(C)
struct AttachmentsDesc {
    uint _start_canary = 0;
    AttachmentDesc[4] colors;
    AttachmentDesc[4] resolves;
    AttachmentDesc depth_stencil;
    const(char)* label = null;
    uint _end_canary = 0;
}
/// sg_trace_hooks
/// 
/// Installable callback functions to keep track of the sokol-gfx calls,
/// this is useful for debugging, or keeping track of resource creation
/// and destruction.
/// 
/// Trace hooks are installed with sg_install_trace_hooks(), this returns
/// another sg_trace_hooks struct with the previous set of
/// trace hook function pointers. These should be invoked by the
/// new trace hooks to form a proper call chain
extern(C)
struct TraceHooks {
    void* user_data = null;
    extern(C) void function(void*) reset_state_cache = null;
    extern(C) void function(const BufferDesc *, Buffer, void*) make_buffer = null;
    extern(C) void function(const ImageDesc *, Image, void*) make_image = null;
    extern(C) void function(const SamplerDesc *, Sampler, void*) make_sampler = null;
    extern(C) void function(const ShaderDesc *, Shader, void*) make_shader = null;
    extern(C) void function(const PipelineDesc *, Pipeline, void*) make_pipeline = null;
    extern(C) void function(const AttachmentsDesc *, Attachments, void*) make_attachments = null;
    extern(C) void function(Buffer, void*) destroy_buffer = null;
    extern(C) void function(Image, void*) destroy_image = null;
    extern(C) void function(Sampler, void*) destroy_sampler = null;
    extern(C) void function(Shader, void*) destroy_shader = null;
    extern(C) void function(Pipeline, void*) destroy_pipeline = null;
    extern(C) void function(Attachments, void*) destroy_attachments = null;
    extern(C) void function(Buffer, const Range *, void*) update_buffer = null;
    extern(C) void function(Image, const ImageData *, void*) update_image = null;
    extern(C) void function(Buffer, const Range *, int, void*) append_buffer = null;
    extern(C) void function(const Pass *, void*) begin_pass = null;
    extern(C) void function(int, int, int, int, bool, void*) apply_viewport = null;
    extern(C) void function(int, int, int, int, bool, void*) apply_scissor_rect = null;
    extern(C) void function(Pipeline, void*) apply_pipeline = null;
    extern(C) void function(const Bindings *, void*) apply_bindings = null;
    extern(C) void function(int, const Range *, void*) apply_uniforms = null;
    extern(C) void function(int, int, int, void*) draw = null;
    extern(C) void function(void*) end_pass = null;
    extern(C) void function(void*) commit = null;
    extern(C) void function(Buffer, void*) alloc_buffer = null;
    extern(C) void function(Image, void*) alloc_image = null;
    extern(C) void function(Sampler, void*) alloc_sampler = null;
    extern(C) void function(Shader, void*) alloc_shader = null;
    extern(C) void function(Pipeline, void*) alloc_pipeline = null;
    extern(C) void function(Attachments, void*) alloc_attachments = null;
    extern(C) void function(Buffer, void*) dealloc_buffer = null;
    extern(C) void function(Image, void*) dealloc_image = null;
    extern(C) void function(Sampler, void*) dealloc_sampler = null;
    extern(C) void function(Shader, void*) dealloc_shader = null;
    extern(C) void function(Pipeline, void*) dealloc_pipeline = null;
    extern(C) void function(Attachments, void*) dealloc_attachments = null;
    extern(C) void function(Buffer, const BufferDesc *, void*) init_buffer = null;
    extern(C) void function(Image, const ImageDesc *, void*) init_image = null;
    extern(C) void function(Sampler, const SamplerDesc *, void*) init_sampler = null;
    extern(C) void function(Shader, const ShaderDesc *, void*) init_shader = null;
    extern(C) void function(Pipeline, const PipelineDesc *, void*) init_pipeline = null;
    extern(C) void function(Attachments, const AttachmentsDesc *, void*) init_attachments = null;
    extern(C) void function(Buffer, void*) uninit_buffer = null;
    extern(C) void function(Image, void*) uninit_image = null;
    extern(C) void function(Sampler, void*) uninit_sampler = null;
    extern(C) void function(Shader, void*) uninit_shader = null;
    extern(C) void function(Pipeline, void*) uninit_pipeline = null;
    extern(C) void function(Attachments, void*) uninit_attachments = null;
    extern(C) void function(Buffer, void*) fail_buffer = null;
    extern(C) void function(Image, void*) fail_image = null;
    extern(C) void function(Sampler, void*) fail_sampler = null;
    extern(C) void function(Shader, void*) fail_shader = null;
    extern(C) void function(Pipeline, void*) fail_pipeline = null;
    extern(C) void function(Attachments, void*) fail_attachments = null;
    extern(C) void function(const(char)*, void*) push_debug_group = null;
    extern(C) void function(void*) pop_debug_group = null;
}
/// sg_buffer_info
/// sg_image_info
/// sg_sampler_info
/// sg_shader_info
/// sg_pipeline_info
/// sg_attachments_info
/// 
/// These structs contain various internal resource attributes which
/// might be useful for debug-inspection. Please don't rely on the
/// actual content of those structs too much, as they are quite closely
/// tied to sokol_gfx.h internals and may change more frequently than
/// the other public API elements.
/// 
/// The *_info structs are used as the return values of the following functions:
/// 
/// sg_query_buffer_info()
/// sg_query_image_info()
/// sg_query_sampler_info()
/// sg_query_shader_info()
/// sg_query_pipeline_info()
/// sg_query_pass_info(
extern(C)
struct SlotInfo {
    ResourceState state;
    uint res_id = 0;
}
extern(C)
struct BufferInfo {
    SlotInfo slot;
    uint update_frame_index = 0;
    uint append_frame_index = 0;
    int append_pos = 0;
    bool append_overflow = false;
    int num_slots = 0;
    int active_slot = 0;
}
extern(C)
struct ImageInfo {
    SlotInfo slot;
    uint upd_frame_index = 0;
    int num_slots = 0;
    int active_slot = 0;
}
extern(C)
struct SamplerInfo {
    SlotInfo slot;
}
extern(C)
struct ShaderInfo {
    SlotInfo slot;
}
extern(C)
struct PipelineInfo {
    SlotInfo slot;
}
extern(C)
struct AttachmentsInfo {
    SlotInfo slot;
}
/// sg_frame_stats
/// 
/// Allows to track generic and backend-specific stats about a
/// render frame. Obtained by calling sg_query_frame_stats(). The returned
/// struct contains information about the *previous* frame
extern(C)
struct FrameStatsGl {
    uint num_bind_buffer = 0;
    uint num_active_texture = 0;
    uint num_bind_texture = 0;
    uint num_bind_sampler = 0;
    uint num_use_program = 0;
    uint num_render_state = 0;
    uint num_vertex_attrib_pointer = 0;
    uint num_vertex_attrib_divisor = 0;
    uint num_enable_vertex_attrib_array = 0;
    uint num_disable_vertex_attrib_array = 0;
    uint num_uniform = 0;
}
extern(C)
struct FrameStatsD3d11Pass {
    uint num_om_set_render_targets = 0;
    uint num_clear_render_target_view = 0;
    uint num_clear_depth_stencil_view = 0;
    uint num_resolve_subresource = 0;
}
extern(C)
struct FrameStatsD3d11Pipeline {
    uint num_rs_set_state = 0;
    uint num_om_set_depth_stencil_state = 0;
    uint num_om_set_blend_state = 0;
    uint num_ia_set_primitive_topology = 0;
    uint num_ia_set_input_layout = 0;
    uint num_vs_set_shader = 0;
    uint num_vs_set_constant_buffers = 0;
    uint num_ps_set_shader = 0;
    uint num_ps_set_constant_buffers = 0;
}
extern(C)
struct FrameStatsD3d11Bindings {
    uint num_ia_set_vertex_buffers = 0;
    uint num_ia_set_index_buffer = 0;
    uint num_vs_set_shader_resources = 0;
    uint num_ps_set_shader_resources = 0;
    uint num_vs_set_samplers = 0;
    uint num_ps_set_samplers = 0;
}
extern(C)
struct FrameStatsD3d11Uniforms {
    uint num_update_subresource = 0;
}
extern(C)
struct FrameStatsD3d11Draw {
    uint num_draw_indexed_instanced = 0;
    uint num_draw_indexed = 0;
    uint num_draw_instanced = 0;
    uint num_draw = 0;
}
extern(C)
struct FrameStatsD3d11 {
    FrameStatsD3d11Pass pass;
    FrameStatsD3d11Pipeline pipeline;
    FrameStatsD3d11Bindings bindings;
    FrameStatsD3d11Uniforms uniforms;
    FrameStatsD3d11Draw draw;
    uint num_map = 0;
    uint num_unmap = 0;
}
extern(C)
struct FrameStatsMetalIdpool {
    uint num_added = 0;
    uint num_released = 0;
    uint num_garbage_collected = 0;
}
extern(C)
struct FrameStatsMetalPipeline {
    uint num_set_blend_color = 0;
    uint num_set_cull_mode = 0;
    uint num_set_front_facing_winding = 0;
    uint num_set_stencil_reference_value = 0;
    uint num_set_depth_bias = 0;
    uint num_set_render_pipeline_state = 0;
    uint num_set_depth_stencil_state = 0;
}
extern(C)
struct FrameStatsMetalBindings {
    uint num_set_vertex_buffer = 0;
    uint num_set_vertex_texture = 0;
    uint num_set_vertex_sampler_state = 0;
    uint num_set_fragment_buffer = 0;
    uint num_set_fragment_texture = 0;
    uint num_set_fragment_sampler_state = 0;
}
extern(C)
struct FrameStatsMetalUniforms {
    uint num_set_vertex_buffer_offset = 0;
    uint num_set_fragment_buffer_offset = 0;
}
extern(C)
struct FrameStatsMetal {
    FrameStatsMetalIdpool idpool;
    FrameStatsMetalPipeline pipeline;
    FrameStatsMetalBindings bindings;
    FrameStatsMetalUniforms uniforms;
}
extern(C)
struct FrameStatsWgpuUniforms {
    uint num_set_bindgroup = 0;
    uint size_write_buffer = 0;
}
extern(C)
struct FrameStatsWgpuBindings {
    uint num_set_vertex_buffer = 0;
    uint num_skip_redundant_vertex_buffer = 0;
    uint num_set_index_buffer = 0;
    uint num_skip_redundant_index_buffer = 0;
    uint num_create_bindgroup = 0;
    uint num_discard_bindgroup = 0;
    uint num_set_bindgroup = 0;
    uint num_skip_redundant_bindgroup = 0;
    uint num_bindgroup_cache_hits = 0;
    uint num_bindgroup_cache_misses = 0;
    uint num_bindgroup_cache_collisions = 0;
    uint num_bindgroup_cache_invalidates = 0;
    uint num_bindgroup_cache_hash_vs_key_mismatch = 0;
}
extern(C)
struct FrameStatsWgpu {
    FrameStatsWgpuUniforms uniforms;
    FrameStatsWgpuBindings bindings;
}
extern(C)
struct FrameStats {
    uint frame_index = 0;
    uint num_passes = 0;
    uint num_apply_viewport = 0;
    uint num_apply_scissor_rect = 0;
    uint num_apply_pipeline = 0;
    uint num_apply_bindings = 0;
    uint num_apply_uniforms = 0;
    uint num_draw = 0;
    uint num_update_buffer = 0;
    uint num_append_buffer = 0;
    uint num_update_image = 0;
    uint size_apply_uniforms = 0;
    uint size_update_buffer = 0;
    uint size_append_buffer = 0;
    uint size_update_image = 0;
    FrameStatsGl gl;
    FrameStatsD3d11 d3d11;
    FrameStatsMetal metal;
    FrameStatsWgpu wgpu;
}
enum LogItem {
    Ok,
    Malloc_failed,
    Gl_texture_format_not_supported,
    Gl_3d_textures_not_supported,
    Gl_array_textures_not_supported,
    Gl_shader_compilation_failed,
    Gl_shader_linking_failed,
    Gl_vertex_attribute_not_found_in_shader,
    Gl_uniformblock_name_not_found_in_shader,
    Gl_image_sampler_name_not_found_in_shader,
    Gl_framebuffer_status_undefined,
    Gl_framebuffer_status_incomplete_attachment,
    Gl_framebuffer_status_incomplete_missing_attachment,
    Gl_framebuffer_status_unsupported,
    Gl_framebuffer_status_incomplete_multisample,
    Gl_framebuffer_status_unknown,
    D3d11_create_buffer_failed,
    D3d11_create_buffer_srv_failed,
    D3d11_create_depth_texture_unsupported_pixel_format,
    D3d11_create_depth_texture_failed,
    D3d11_create_2d_texture_unsupported_pixel_format,
    D3d11_create_2d_texture_failed,
    D3d11_create_2d_srv_failed,
    D3d11_create_3d_texture_unsupported_pixel_format,
    D3d11_create_3d_texture_failed,
    D3d11_create_3d_srv_failed,
    D3d11_create_msaa_texture_failed,
    D3d11_create_sampler_state_failed,
    D3d11_load_d3dcompiler_47_dll_failed,
    D3d11_shader_compilation_failed,
    D3d11_shader_compilation_output,
    D3d11_create_constant_buffer_failed,
    D3d11_create_input_layout_failed,
    D3d11_create_rasterizer_state_failed,
    D3d11_create_depth_stencil_state_failed,
    D3d11_create_blend_state_failed,
    D3d11_create_rtv_failed,
    D3d11_create_dsv_failed,
    D3d11_map_for_update_buffer_failed,
    D3d11_map_for_append_buffer_failed,
    D3d11_map_for_update_image_failed,
    Metal_create_buffer_failed,
    Metal_texture_format_not_supported,
    Metal_create_texture_failed,
    Metal_create_sampler_failed,
    Metal_shader_compilation_failed,
    Metal_shader_creation_failed,
    Metal_shader_compilation_output,
    Metal_shader_entry_not_found,
    Metal_create_rps_failed,
    Metal_create_rps_output,
    Metal_create_dss_failed,
    Wgpu_bindgroups_pool_exhausted,
    Wgpu_bindgroupscache_size_greater_one,
    Wgpu_bindgroupscache_size_pow2,
    Wgpu_createbindgroup_failed,
    Wgpu_create_buffer_failed,
    Wgpu_create_texture_failed,
    Wgpu_create_texture_view_failed,
    Wgpu_create_sampler_failed,
    Wgpu_create_shader_module_failed,
    Wgpu_shader_create_bindgroup_layout_failed,
    Wgpu_create_pipeline_layout_failed,
    Wgpu_create_render_pipeline_failed,
    Wgpu_attachments_create_texture_view_failed,
    Draw_required_bindings_or_uniforms_missing,
    Identical_commit_listener,
    Commit_listener_array_full,
    Trace_hooks_not_enabled,
    Dealloc_buffer_invalid_state,
    Dealloc_image_invalid_state,
    Dealloc_sampler_invalid_state,
    Dealloc_shader_invalid_state,
    Dealloc_pipeline_invalid_state,
    Dealloc_attachments_invalid_state,
    Init_buffer_invalid_state,
    Init_image_invalid_state,
    Init_sampler_invalid_state,
    Init_shader_invalid_state,
    Init_pipeline_invalid_state,
    Init_attachments_invalid_state,
    Uninit_buffer_invalid_state,
    Uninit_image_invalid_state,
    Uninit_sampler_invalid_state,
    Uninit_shader_invalid_state,
    Uninit_pipeline_invalid_state,
    Uninit_attachments_invalid_state,
    Fail_buffer_invalid_state,
    Fail_image_invalid_state,
    Fail_sampler_invalid_state,
    Fail_shader_invalid_state,
    Fail_pipeline_invalid_state,
    Fail_attachments_invalid_state,
    Buffer_pool_exhausted,
    Image_pool_exhausted,
    Sampler_pool_exhausted,
    Shader_pool_exhausted,
    Pipeline_pool_exhausted,
    Pass_pool_exhausted,
    Beginpass_attachment_invalid,
    Draw_without_bindings,
    Validate_bufferdesc_canary,
    Validate_bufferdesc_size,
    Validate_bufferdesc_data,
    Validate_bufferdesc_data_size,
    Validate_bufferdesc_no_data,
    Validate_bufferdesc_storagebuffer_supported,
    Validate_bufferdesc_storagebuffer_size_multiple_4,
    Validate_imagedata_nodata,
    Validate_imagedata_data_size,
    Validate_imagedesc_canary,
    Validate_imagedesc_width,
    Validate_imagedesc_height,
    Validate_imagedesc_rt_pixelformat,
    Validate_imagedesc_nonrt_pixelformat,
    Validate_imagedesc_msaa_but_no_rt,
    Validate_imagedesc_no_msaa_rt_support,
    Validate_imagedesc_msaa_num_mipmaps,
    Validate_imagedesc_msaa_3d_image,
    Validate_imagedesc_msaa_cube_image,
    Validate_imagedesc_depth_3d_image,
    Validate_imagedesc_rt_immutable,
    Validate_imagedesc_rt_no_data,
    Validate_imagedesc_injected_no_data,
    Validate_imagedesc_dynamic_no_data,
    Validate_imagedesc_compressed_immutable,
    Validate_samplerdesc_canary,
    Validate_samplerdesc_anistropic_requires_linear_filtering,
    Validate_shaderdesc_canary,
    Validate_shaderdesc_source,
    Validate_shaderdesc_bytecode,
    Validate_shaderdesc_source_or_bytecode,
    Validate_shaderdesc_no_bytecode_size,
    Validate_shaderdesc_no_cont_ub_members,
    Validate_shaderdesc_ub_size_is_zero,
    Validate_shaderdesc_ub_metal_buffer_slot_out_of_range,
    Validate_shaderdesc_ub_metal_buffer_slot_collision,
    Validate_shaderdesc_ub_hlsl_register_b_out_of_range,
    Validate_shaderdesc_ub_hlsl_register_b_collision,
    Validate_shaderdesc_ub_wgsl_group0_binding_out_of_range,
    Validate_shaderdesc_ub_wgsl_group0_binding_collision,
    Validate_shaderdesc_no_ub_members,
    Validate_shaderdesc_ub_uniform_glsl_name,
    Validate_shaderdesc_ub_size_mismatch,
    Validate_shaderdesc_ub_array_count,
    Validate_shaderdesc_ub_std140_array_type,
    Validate_shaderdesc_storagebuffer_metal_buffer_slot_out_of_range,
    Validate_shaderdesc_storagebuffer_metal_buffer_slot_collision,
    Validate_shaderdesc_storagebuffer_hlsl_register_t_out_of_range,
    Validate_shaderdesc_storagebuffer_hlsl_register_t_collision,
    Validate_shaderdesc_storagebuffer_glsl_binding_out_of_range,
    Validate_shaderdesc_storagebuffer_glsl_binding_collision,
    Validate_shaderdesc_storagebuffer_wgsl_group1_binding_out_of_range,
    Validate_shaderdesc_storagebuffer_wgsl_group1_binding_collision,
    Validate_shaderdesc_storagebuffer_readonly,
    Validate_shaderdesc_image_metal_texture_slot_out_of_range,
    Validate_shaderdesc_image_metal_texture_slot_collision,
    Validate_shaderdesc_image_hlsl_register_t_out_of_range,
    Validate_shaderdesc_image_hlsl_register_t_collision,
    Validate_shaderdesc_image_wgsl_group1_binding_out_of_range,
    Validate_shaderdesc_image_wgsl_group1_binding_collision,
    Validate_shaderdesc_sampler_metal_sampler_slot_out_of_range,
    Validate_shaderdesc_sampler_metal_sampler_slot_collision,
    Validate_shaderdesc_sampler_hlsl_register_s_out_of_range,
    Validate_shaderdesc_sampler_hlsl_register_s_collision,
    Validate_shaderdesc_sampler_wgsl_group1_binding_out_of_range,
    Validate_shaderdesc_sampler_wgsl_group1_binding_collision,
    Validate_shaderdesc_image_sampler_pair_image_slot_out_of_range,
    Validate_shaderdesc_image_sampler_pair_sampler_slot_out_of_range,
    Validate_shaderdesc_image_sampler_pair_image_stage_mismatch,
    Validate_shaderdesc_image_sampler_pair_sampler_stage_mismatch,
    Validate_shaderdesc_image_sampler_pair_glsl_name,
    Validate_shaderdesc_nonfiltering_sampler_required,
    Validate_shaderdesc_comparison_sampler_required,
    Validate_shaderdesc_image_not_referenced_by_image_sampler_pairs,
    Validate_shaderdesc_sampler_not_referenced_by_image_sampler_pairs,
    Validate_shaderdesc_attr_string_too_long,
    Validate_pipelinedesc_canary,
    Validate_pipelinedesc_shader,
    Validate_pipelinedesc_no_cont_attrs,
    Validate_pipelinedesc_layout_stride4,
    Validate_pipelinedesc_attr_semantics,
    Validate_attachmentsdesc_canary,
    Validate_attachmentsdesc_no_attachments,
    Validate_attachmentsdesc_no_cont_color_atts,
    Validate_attachmentsdesc_image,
    Validate_attachmentsdesc_miplevel,
    Validate_attachmentsdesc_face,
    Validate_attachmentsdesc_layer,
    Validate_attachmentsdesc_slice,
    Validate_attachmentsdesc_image_no_rt,
    Validate_attachmentsdesc_color_inv_pixelformat,
    Validate_attachmentsdesc_depth_inv_pixelformat,
    Validate_attachmentsdesc_image_sizes,
    Validate_attachmentsdesc_image_sample_counts,
    Validate_attachmentsdesc_resolve_color_image_msaa,
    Validate_attachmentsdesc_resolve_image,
    Validate_attachmentsdesc_resolve_sample_count,
    Validate_attachmentsdesc_resolve_miplevel,
    Validate_attachmentsdesc_resolve_face,
    Validate_attachmentsdesc_resolve_layer,
    Validate_attachmentsdesc_resolve_slice,
    Validate_attachmentsdesc_resolve_image_no_rt,
    Validate_attachmentsdesc_resolve_image_sizes,
    Validate_attachmentsdesc_resolve_image_format,
    Validate_attachmentsdesc_depth_image,
    Validate_attachmentsdesc_depth_miplevel,
    Validate_attachmentsdesc_depth_face,
    Validate_attachmentsdesc_depth_layer,
    Validate_attachmentsdesc_depth_slice,
    Validate_attachmentsdesc_depth_image_no_rt,
    Validate_attachmentsdesc_depth_image_sizes,
    Validate_attachmentsdesc_depth_image_sample_count,
    Validate_beginpass_canary,
    Validate_beginpass_attachments_exists,
    Validate_beginpass_attachments_valid,
    Validate_beginpass_color_attachment_image,
    Validate_beginpass_resolve_attachment_image,
    Validate_beginpass_depthstencil_attachment_image,
    Validate_beginpass_swapchain_expect_width,
    Validate_beginpass_swapchain_expect_width_notset,
    Validate_beginpass_swapchain_expect_height,
    Validate_beginpass_swapchain_expect_height_notset,
    Validate_beginpass_swapchain_expect_samplecount,
    Validate_beginpass_swapchain_expect_samplecount_notset,
    Validate_beginpass_swapchain_expect_colorformat,
    Validate_beginpass_swapchain_expect_colorformat_notset,
    Validate_beginpass_swapchain_expect_depthformat_notset,
    Validate_beginpass_swapchain_metal_expect_currentdrawable,
    Validate_beginpass_swapchain_metal_expect_currentdrawable_notset,
    Validate_beginpass_swapchain_metal_expect_depthstenciltexture,
    Validate_beginpass_swapchain_metal_expect_depthstenciltexture_notset,
    Validate_beginpass_swapchain_metal_expect_msaacolortexture,
    Validate_beginpass_swapchain_metal_expect_msaacolortexture_notset,
    Validate_beginpass_swapchain_d3d11_expect_renderview,
    Validate_beginpass_swapchain_d3d11_expect_renderview_notset,
    Validate_beginpass_swapchain_d3d11_expect_resolveview,
    Validate_beginpass_swapchain_d3d11_expect_resolveview_notset,
    Validate_beginpass_swapchain_d3d11_expect_depthstencilview,
    Validate_beginpass_swapchain_d3d11_expect_depthstencilview_notset,
    Validate_beginpass_swapchain_wgpu_expect_renderview,
    Validate_beginpass_swapchain_wgpu_expect_renderview_notset,
    Validate_beginpass_swapchain_wgpu_expect_resolveview,
    Validate_beginpass_swapchain_wgpu_expect_resolveview_notset,
    Validate_beginpass_swapchain_wgpu_expect_depthstencilview,
    Validate_beginpass_swapchain_wgpu_expect_depthstencilview_notset,
    Validate_beginpass_swapchain_gl_expect_framebuffer_notset,
    Validate_apip_pipeline_valid_id,
    Validate_apip_pipeline_exists,
    Validate_apip_pipeline_valid,
    Validate_apip_shader_exists,
    Validate_apip_shader_valid,
    Validate_apip_curpass_attachments_exists,
    Validate_apip_curpass_attachments_valid,
    Validate_apip_att_count,
    Validate_apip_color_format,
    Validate_apip_depth_format,
    Validate_apip_sample_count,
    Validate_abnd_pipeline,
    Validate_abnd_pipeline_exists,
    Validate_abnd_pipeline_valid,
    Validate_abnd_expected_vb,
    Validate_abnd_vb_exists,
    Validate_abnd_vb_type,
    Validate_abnd_vb_overflow,
    Validate_abnd_no_ib,
    Validate_abnd_ib,
    Validate_abnd_ib_exists,
    Validate_abnd_ib_type,
    Validate_abnd_ib_overflow,
    Validate_abnd_expected_image_binding,
    Validate_abnd_img_exists,
    Validate_abnd_image_type_mismatch,
    Validate_abnd_expected_multisampled_image,
    Validate_abnd_image_msaa,
    Validate_abnd_expected_filterable_image,
    Validate_abnd_expected_depth_image,
    Validate_abnd_expected_sampler_binding,
    Validate_abnd_unexpected_sampler_compare_never,
    Validate_abnd_expected_sampler_compare_never,
    Validate_abnd_expected_nonfiltering_sampler,
    Validate_abnd_smp_exists,
    Validate_abnd_expected_storagebuffer_binding,
    Validate_abnd_storagebuffer_exists,
    Validate_abnd_storagebuffer_binding_buffertype,
    Validate_aub_no_pipeline,
    Validate_aub_no_ub_at_slot,
    Validate_aub_size,
    Validate_updatebuf_usage,
    Validate_updatebuf_size,
    Validate_updatebuf_once,
    Validate_updatebuf_append,
    Validate_appendbuf_usage,
    Validate_appendbuf_size,
    Validate_appendbuf_update,
    Validate_updimg_usage,
    Validate_updimg_once,
    Validation_failed,
}
/// sg_desc
/// 
/// The sg_desc struct contains configuration values for sokol_gfx,
/// it is used as parameter to the sg_setup() call.
/// 
/// The default configuration is:
/// 
/// .buffer_pool_size       128
/// .image_pool_size        128
/// .sampler_pool_size      64
/// .shader_pool_size       32
/// .pipeline_pool_size     64
/// .pass_pool_size         16
/// .uniform_buffer_size    4 MB (4*1024*1024)
/// .max_commit_listeners   1024
/// .disable_validation     false
/// .mtl_force_managed_storage_mode false
/// .wgpu_disable_bindgroups_cache  false
/// .wgpu_bindgroups_cache_size     1024
/// 
/// .allocator.alloc_fn     0 (in this case, malloc() will be called)
/// .allocator.free_fn      0 (in this case, free() will be called)
/// .allocator.user_data    0
/// 
/// .environment.defaults.color_format: default value depends on selected backend:
///     all GL backends:    SG_PIXELFORMAT_RGBA8
///     Metal and D3D11:    SG_PIXELFORMAT_BGRA8
///     WebGPU:             *no default* (must be queried from WebGPU swapchain object)
/// .environment.defaults.depth_format: SG_PIXELFORMAT_DEPTH_STENCIL
/// .environment.defaults.sample_count: 1
/// 
/// Metal specific:
///     (NOTE: All Objective-C object references are transferred through
///     a bridged cast (__bridge const void*) to sokol_gfx, which will use an
///     unretained bridged cast (__bridge id<xxx>) to retrieve the Objective-C
///     references back. Since the bridge cast is unretained, the caller
///     must hold a strong reference to the Objective-C object until sg_setup()
///     returns.
/// 
///     .mtl_force_managed_storage_mode
///         when enabled, Metal buffers and texture resources are created in managed storage
///         mode, otherwise sokol-gfx will decide whether to create buffers and
///         textures in managed or shared storage mode (this is mainly a debugging option)
///     .mtl_use_command_buffer_with_retained_references
///         when true, the sokol-gfx Metal backend will use Metal command buffers which
///         bump the reference count of resource objects as long as they are inflight,
///         this is slower than the default command-buffer-with-unretained-references
///         method, this may be a workaround when confronted with lifetime validation
///         errors from the Metal validation layer until a proper fix has been implemented
///     .environment.metal.device
///         a pointer to the MTLDevice object
/// 
/// D3D11 specific:
///     .environment.d3d11.device
///         a pointer to the ID3D11Device object, this must have been created
///         before sg_setup() is called
///     .environment.d3d11.device_context
///         a pointer to the ID3D11DeviceContext object
///     .d3d11_shader_debugging
///         set this to true to compile shaders which are provided as HLSL source
///         code with debug information and without optimization, this allows
///         shader debugging in tools like RenderDoc, to output source code
///         instead of byte code from sokol-shdc, omit the `--binary` cmdline
///         option
/// 
/// WebGPU specific:
///     .wgpu_disable_bindgroups_cache
///         When this is true, the WebGPU backend will create and immediately
///         release a BindGroup object in the sg_apply_bindings() call, only
///         use this for debugging purposes.
///     .wgpu_bindgroups_cache_size
///         The size of the bindgroups cache for re-using BindGroup objects
///         between sg_apply_bindings() calls. The smaller the cache size,
///         the more likely are cache slot collisions which will cause
///         a BindGroups object to be destroyed and a new one created.
///         Use the information returned by sg_query_stats() to check
///         if this is a frequent occurrence, and increase the cache size as
///         needed (the default is 1024).
///         NOTE: wgpu_bindgroups_cache_size must be a power-of-2 number!
///     .environment.wgpu.device
///         a WGPUDevice handle
/// 
/// When using sokol_gfx.h and sokol_app.h together, consider using the
/// helper function sglue_environment() in the sokol_glue.h header to
/// initialize the sg_desc.environment nested struct. sglue_environment() returns
/// a completely initialized sg_environment struct with information
/// provided by sokol_app.h
extern(C)
struct EnvironmentDefaults {
    PixelFormat color_format;
    PixelFormat depth_format;
    int sample_count = 0;
}
extern(C)
struct MetalEnvironment {
    const(void)* device = null;
}
extern(C)
struct D3d11Environment {
    const(void)* device = null;
    const(void)* device_context = null;
}
extern(C)
struct WgpuEnvironment {
    const(void)* device = null;
}
extern(C)
struct Environment {
    EnvironmentDefaults defaults;
    MetalEnvironment metal;
    D3d11Environment d3d11;
    WgpuEnvironment wgpu;
}
/// sg_commit_listener
/// 
/// Used with function sg_add_commit_listener() to add a callback
/// which will be called in sg_commit(). This is useful for libraries
/// building on top of sokol-gfx to be notified about when a frame
/// ends (instead of having to guess, or add a manual 'new-frame'
/// function
extern(C)
struct CommitListener {
    extern(C) void function(void*) func = null;
    void* user_data = null;
}
/// sg_allocator
/// 
/// Used in sg_desc to provide custom memory-alloc and -free functions
/// to sokol_gfx.h. If memory management should be overridden, both the
/// alloc_fn and free_fn function must be provided (e.g. it's not valid to
/// override one function but not the other)
extern(C)
struct Allocator {
    extern(C) void* function(size_t, void*) alloc_fn = null;
    extern(C) void function(void*, void*) free_fn = null;
    void* user_data = null;
}
/// sg_logger
/// 
/// Used in sg_desc to provide a logging function. Please be aware
/// that without logging function, sokol-gfx will be completely
/// silent, e.g. it will not report errors, warnings and
/// validation layer messages. For maximum error verbosity,
/// compile in debug mode (e.g. NDEBUG *not* defined) and provide a
/// compatible logger function in the sg_setup() call
/// (for instance the standard logging function from sokol_log.h)
extern(C)
struct Logger {
    extern(C) void function(const(char)*, uint, uint, const(char)*, uint, const(char)*, void*) func = null;
    void* user_data = null;
}
extern(C)
struct Desc {
    uint _start_canary = 0;
    int buffer_pool_size = 0;
    int image_pool_size = 0;
    int sampler_pool_size = 0;
    int shader_pool_size = 0;
    int pipeline_pool_size = 0;
    int attachments_pool_size = 0;
    int uniform_buffer_size = 0;
    int max_commit_listeners = 0;
    bool disable_validation = false;
    bool d3d11_shader_debugging = false;
    bool mtl_force_managed_storage_mode = false;
    bool mtl_use_command_buffer_with_retained_references = false;
    bool wgpu_disable_bindgroups_cache = false;
    int wgpu_bindgroups_cache_size = 0;
    Allocator allocator;
    Logger logger;
    Environment environment;
    uint _end_canary = 0;
}
/// setup and misc function
extern(C) void sg_setup(const Desc *) @system @nogc nothrow;
/// setup and misc function
void setup(scope ref Desc desc) @trusted @nogc nothrow {
    sg_setup(&desc);
}
extern(C) void sg_shutdown() @system @nogc nothrow;
void shutdown() @trusted @nogc nothrow {
    sg_shutdown();
}
extern(C) bool sg_isvalid() @system @nogc nothrow;
bool isvalid() @trusted @nogc nothrow {
    return sg_isvalid();
}
extern(C) void sg_reset_state_cache() @system @nogc nothrow;
void resetStateCache() @trusted @nogc nothrow {
    sg_reset_state_cache();
}
extern(C) TraceHooks sg_install_trace_hooks(const TraceHooks *) @system @nogc nothrow;
TraceHooks installTraceHooks(scope ref TraceHooks trace_hooks) @trusted @nogc nothrow {
    return sg_install_trace_hooks(&trace_hooks);
}
extern(C) void sg_push_debug_group(const(char)*) @system @nogc nothrow;
void pushDebugGroup(scope const(char)* name) @trusted @nogc nothrow {
    sg_push_debug_group(name);
}
extern(C) void sg_pop_debug_group() @system @nogc nothrow;
void popDebugGroup() @trusted @nogc nothrow {
    sg_pop_debug_group();
}
extern(C) bool sg_add_commit_listener(CommitListener) @system @nogc nothrow;
bool addCommitListener(CommitListener listener) @trusted @nogc nothrow {
    return sg_add_commit_listener(listener);
}
extern(C) bool sg_remove_commit_listener(CommitListener) @system @nogc nothrow;
bool removeCommitListener(CommitListener listener) @trusted @nogc nothrow {
    return sg_remove_commit_listener(listener);
}
/// resource creation, destruction and updatin
extern(C) Buffer sg_make_buffer(const BufferDesc *) @system @nogc nothrow;
/// resource creation, destruction and updatin
Buffer makeBuffer(scope ref BufferDesc desc) @trusted @nogc nothrow {
    return sg_make_buffer(&desc);
}
extern(C) Image sg_make_image(const ImageDesc *) @system @nogc nothrow;
Image makeImage(scope ref ImageDesc desc) @trusted @nogc nothrow {
    return sg_make_image(&desc);
}
extern(C) Sampler sg_make_sampler(const SamplerDesc *) @system @nogc nothrow;
Sampler makeSampler(scope ref SamplerDesc desc) @trusted @nogc nothrow {
    return sg_make_sampler(&desc);
}
extern(C) Shader sg_make_shader(const ShaderDesc *) @system @nogc nothrow;
Shader makeShader(scope ref ShaderDesc desc) @trusted @nogc nothrow {
    return sg_make_shader(&desc);
}
extern(C) Pipeline sg_make_pipeline(const PipelineDesc *) @system @nogc nothrow;
Pipeline makePipeline(scope ref PipelineDesc desc) @trusted @nogc nothrow {
    return sg_make_pipeline(&desc);
}
extern(C) Attachments sg_make_attachments(const AttachmentsDesc *) @system @nogc nothrow;
Attachments makeAttachments(scope ref AttachmentsDesc desc) @trusted @nogc nothrow {
    return sg_make_attachments(&desc);
}
extern(C) void sg_destroy_buffer(Buffer) @system @nogc nothrow;
void destroyBuffer(Buffer buf) @trusted @nogc nothrow {
    sg_destroy_buffer(buf);
}
extern(C) void sg_destroy_image(Image) @system @nogc nothrow;
void destroyImage(Image img) @trusted @nogc nothrow {
    sg_destroy_image(img);
}
extern(C) void sg_destroy_sampler(Sampler) @system @nogc nothrow;
void destroySampler(Sampler smp) @trusted @nogc nothrow {
    sg_destroy_sampler(smp);
}
extern(C) void sg_destroy_shader(Shader) @system @nogc nothrow;
void destroyShader(Shader shd) @trusted @nogc nothrow {
    sg_destroy_shader(shd);
}
extern(C) void sg_destroy_pipeline(Pipeline) @system @nogc nothrow;
void destroyPipeline(Pipeline pip) @trusted @nogc nothrow {
    sg_destroy_pipeline(pip);
}
extern(C) void sg_destroy_attachments(Attachments) @system @nogc nothrow;
void destroyAttachments(Attachments atts) @trusted @nogc nothrow {
    sg_destroy_attachments(atts);
}
extern(C) void sg_update_buffer(Buffer, const Range *) @system @nogc nothrow;
void updateBuffer(Buffer buf, scope ref Range data) @trusted @nogc nothrow {
    sg_update_buffer(buf, &data);
}
extern(C) void sg_update_image(Image, const ImageData *) @system @nogc nothrow;
void updateImage(Image img, scope ref ImageData data) @trusted @nogc nothrow {
    sg_update_image(img, &data);
}
extern(C) int sg_append_buffer(Buffer, const Range *) @system @nogc nothrow;
int appendBuffer(Buffer buf, scope ref Range data) @trusted @nogc nothrow {
    return sg_append_buffer(buf, &data);
}
extern(C) bool sg_query_buffer_overflow(Buffer) @system @nogc nothrow;
bool queryBufferOverflow(Buffer buf) @trusted @nogc nothrow {
    return sg_query_buffer_overflow(buf);
}
extern(C) bool sg_query_buffer_will_overflow(Buffer, size_t) @system @nogc nothrow;
bool queryBufferWillOverflow(Buffer buf, size_t size) @trusted @nogc nothrow {
    return sg_query_buffer_will_overflow(buf, size);
}
/// rendering function
extern(C) void sg_begin_pass(const Pass *) @system @nogc nothrow;
/// rendering function
void beginPass(scope ref Pass pass) @trusted @nogc nothrow {
    sg_begin_pass(&pass);
}
extern(C) void sg_apply_viewport(int, int, int, int, bool) @system @nogc nothrow;
void applyViewport(int x, int y, int width, int height, bool origin_top_left) @trusted @nogc nothrow {
    sg_apply_viewport(x, y, width, height, origin_top_left);
}
extern(C) void sg_apply_viewportf(float, float, float, float, bool) @system @nogc nothrow;
void applyViewportf(float x, float y, float width, float height, bool origin_top_left) @trusted @nogc nothrow {
    sg_apply_viewportf(x, y, width, height, origin_top_left);
}
extern(C) void sg_apply_scissor_rect(int, int, int, int, bool) @system @nogc nothrow;
void applyScissorRect(int x, int y, int width, int height, bool origin_top_left) @trusted @nogc nothrow {
    sg_apply_scissor_rect(x, y, width, height, origin_top_left);
}
extern(C) void sg_apply_scissor_rectf(float, float, float, float, bool) @system @nogc nothrow;
void applyScissorRectf(float x, float y, float width, float height, bool origin_top_left) @trusted @nogc nothrow {
    sg_apply_scissor_rectf(x, y, width, height, origin_top_left);
}
extern(C) void sg_apply_pipeline(Pipeline) @system @nogc nothrow;
void applyPipeline(Pipeline pip) @trusted @nogc nothrow {
    sg_apply_pipeline(pip);
}
extern(C) void sg_apply_bindings(const Bindings *) @system @nogc nothrow;
void applyBindings(scope ref Bindings bindings) @trusted @nogc nothrow {
    sg_apply_bindings(&bindings);
}
extern(C) void sg_apply_uniforms(uint, const Range *) @system @nogc nothrow;
void applyUniforms(uint ub_slot, scope ref Range data) @trusted @nogc nothrow {
    sg_apply_uniforms(ub_slot, &data);
}
extern(C) void sg_draw(uint, uint, uint) @system @nogc nothrow;
void draw(uint base_element, uint num_elements, uint num_instances) @trusted @nogc nothrow {
    sg_draw(base_element, num_elements, num_instances);
}
extern(C) void sg_end_pass() @system @nogc nothrow;
void endPass() @trusted @nogc nothrow {
    sg_end_pass();
}
extern(C) void sg_commit() @system @nogc nothrow;
void commit() @trusted @nogc nothrow {
    sg_commit();
}
/// getting informatio
extern(C) Desc sg_query_desc() @system @nogc nothrow;
/// getting informatio
Desc queryDesc() @trusted @nogc nothrow {
    return sg_query_desc();
}
extern(C) Backend sg_query_backend() @system @nogc nothrow;
Backend queryBackend() @trusted @nogc nothrow {
    return sg_query_backend();
}
extern(C) Features sg_query_features() @system @nogc nothrow;
Features queryFeatures() @trusted @nogc nothrow {
    return sg_query_features();
}
extern(C) Limits sg_query_limits() @system @nogc nothrow;
Limits queryLimits() @trusted @nogc nothrow {
    return sg_query_limits();
}
extern(C) PixelformatInfo sg_query_pixelformat(PixelFormat) @system @nogc nothrow;
PixelformatInfo queryPixelformat(PixelFormat fmt) @trusted @nogc nothrow {
    return sg_query_pixelformat(fmt);
}
extern(C) int sg_query_row_pitch(PixelFormat, int, int) @system @nogc nothrow;
int queryRowPitch(PixelFormat fmt, int width, int row_align_bytes) @trusted @nogc nothrow {
    return sg_query_row_pitch(fmt, width, row_align_bytes);
}
extern(C) int sg_query_surface_pitch(PixelFormat, int, int, int) @system @nogc nothrow;
int querySurfacePitch(PixelFormat fmt, int width, int height, int row_align_bytes) @trusted @nogc nothrow {
    return sg_query_surface_pitch(fmt, width, height, row_align_bytes);
}
/// get current state of a resource (INITIAL, ALLOC, VALID, FAILED, INVALID
extern(C) ResourceState sg_query_buffer_state(Buffer) @system @nogc nothrow;
/// get current state of a resource (INITIAL, ALLOC, VALID, FAILED, INVALID
ResourceState queryBufferState(Buffer buf) @trusted @nogc nothrow {
    return sg_query_buffer_state(buf);
}
extern(C) ResourceState sg_query_image_state(Image) @system @nogc nothrow;
ResourceState queryImageState(Image img) @trusted @nogc nothrow {
    return sg_query_image_state(img);
}
extern(C) ResourceState sg_query_sampler_state(Sampler) @system @nogc nothrow;
ResourceState querySamplerState(Sampler smp) @trusted @nogc nothrow {
    return sg_query_sampler_state(smp);
}
extern(C) ResourceState sg_query_shader_state(Shader) @system @nogc nothrow;
ResourceState queryShaderState(Shader shd) @trusted @nogc nothrow {
    return sg_query_shader_state(shd);
}
extern(C) ResourceState sg_query_pipeline_state(Pipeline) @system @nogc nothrow;
ResourceState queryPipelineState(Pipeline pip) @trusted @nogc nothrow {
    return sg_query_pipeline_state(pip);
}
extern(C) ResourceState sg_query_attachments_state(Attachments) @system @nogc nothrow;
ResourceState queryAttachmentsState(Attachments atts) @trusted @nogc nothrow {
    return sg_query_attachments_state(atts);
}
/// get runtime information about a resourc
extern(C) BufferInfo sg_query_buffer_info(Buffer) @system @nogc nothrow;
/// get runtime information about a resourc
BufferInfo queryBufferInfo(Buffer buf) @trusted @nogc nothrow {
    return sg_query_buffer_info(buf);
}
extern(C) ImageInfo sg_query_image_info(Image) @system @nogc nothrow;
ImageInfo queryImageInfo(Image img) @trusted @nogc nothrow {
    return sg_query_image_info(img);
}
extern(C) SamplerInfo sg_query_sampler_info(Sampler) @system @nogc nothrow;
SamplerInfo querySamplerInfo(Sampler smp) @trusted @nogc nothrow {
    return sg_query_sampler_info(smp);
}
extern(C) ShaderInfo sg_query_shader_info(Shader) @system @nogc nothrow;
ShaderInfo queryShaderInfo(Shader shd) @trusted @nogc nothrow {
    return sg_query_shader_info(shd);
}
extern(C) PipelineInfo sg_query_pipeline_info(Pipeline) @system @nogc nothrow;
PipelineInfo queryPipelineInfo(Pipeline pip) @trusted @nogc nothrow {
    return sg_query_pipeline_info(pip);
}
extern(C) AttachmentsInfo sg_query_attachments_info(Attachments) @system @nogc nothrow;
AttachmentsInfo queryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow {
    return sg_query_attachments_info(atts);
}
/// get desc structs matching a specific resource (NOTE that not all creation attributes may be provided
extern(C) BufferDesc sg_query_buffer_desc(Buffer) @system @nogc nothrow;
/// get desc structs matching a specific resource (NOTE that not all creation attributes may be provided
BufferDesc queryBufferDesc(Buffer buf) @trusted @nogc nothrow {
    return sg_query_buffer_desc(buf);
}
extern(C) ImageDesc sg_query_image_desc(Image) @system @nogc nothrow;
ImageDesc queryImageDesc(Image img) @trusted @nogc nothrow {
    return sg_query_image_desc(img);
}
extern(C) SamplerDesc sg_query_sampler_desc(Sampler) @system @nogc nothrow;
SamplerDesc querySamplerDesc(Sampler smp) @trusted @nogc nothrow {
    return sg_query_sampler_desc(smp);
}
extern(C) ShaderDesc sg_query_shader_desc(Shader) @system @nogc nothrow;
ShaderDesc queryShaderDesc(Shader shd) @trusted @nogc nothrow {
    return sg_query_shader_desc(shd);
}
extern(C) PipelineDesc sg_query_pipeline_desc(Pipeline) @system @nogc nothrow;
PipelineDesc queryPipelineDesc(Pipeline pip) @trusted @nogc nothrow {
    return sg_query_pipeline_desc(pip);
}
extern(C) AttachmentsDesc sg_query_attachments_desc(Attachments) @system @nogc nothrow;
AttachmentsDesc queryAttachmentsDesc(Attachments atts) @trusted @nogc nothrow {
    return sg_query_attachments_desc(atts);
}
/// get resource creation desc struct with their default values replace
extern(C) BufferDesc sg_query_buffer_defaults(const BufferDesc *) @system @nogc nothrow;
/// get resource creation desc struct with their default values replace
BufferDesc queryBufferDefaults(scope ref BufferDesc desc) @trusted @nogc nothrow {
    return sg_query_buffer_defaults(&desc);
}
extern(C) ImageDesc sg_query_image_defaults(const ImageDesc *) @system @nogc nothrow;
ImageDesc queryImageDefaults(scope ref ImageDesc desc) @trusted @nogc nothrow {
    return sg_query_image_defaults(&desc);
}
extern(C) SamplerDesc sg_query_sampler_defaults(const SamplerDesc *) @system @nogc nothrow;
SamplerDesc querySamplerDefaults(scope ref SamplerDesc desc) @trusted @nogc nothrow {
    return sg_query_sampler_defaults(&desc);
}
extern(C) ShaderDesc sg_query_shader_defaults(const ShaderDesc *) @system @nogc nothrow;
ShaderDesc queryShaderDefaults(scope ref ShaderDesc desc) @trusted @nogc nothrow {
    return sg_query_shader_defaults(&desc);
}
extern(C) PipelineDesc sg_query_pipeline_defaults(const PipelineDesc *) @system @nogc nothrow;
PipelineDesc queryPipelineDefaults(scope ref PipelineDesc desc) @trusted @nogc nothrow {
    return sg_query_pipeline_defaults(&desc);
}
extern(C) AttachmentsDesc sg_query_attachments_defaults(const AttachmentsDesc *) @system @nogc nothrow;
AttachmentsDesc queryAttachmentsDefaults(scope ref AttachmentsDesc desc) @trusted @nogc nothrow {
    return sg_query_attachments_defaults(&desc);
}
/// assorted query function
extern(C) size_t sg_query_buffer_size(Buffer) @system @nogc nothrow;
/// assorted query function
size_t queryBufferSize(Buffer buf) @trusted @nogc nothrow {
    return sg_query_buffer_size(buf);
}
extern(C) BufferType sg_query_buffer_type(Buffer) @system @nogc nothrow;
BufferType queryBufferType(Buffer buf) @trusted @nogc nothrow {
    return sg_query_buffer_type(buf);
}
extern(C) Usage sg_query_buffer_usage(Buffer) @system @nogc nothrow;
Usage queryBufferUsage(Buffer buf) @trusted @nogc nothrow {
    return sg_query_buffer_usage(buf);
}
extern(C) ImageType sg_query_image_type(Image) @system @nogc nothrow;
ImageType queryImageType(Image img) @trusted @nogc nothrow {
    return sg_query_image_type(img);
}
extern(C) int sg_query_image_width(Image) @system @nogc nothrow;
int queryImageWidth(Image img) @trusted @nogc nothrow {
    return sg_query_image_width(img);
}
extern(C) int sg_query_image_height(Image) @system @nogc nothrow;
int queryImageHeight(Image img) @trusted @nogc nothrow {
    return sg_query_image_height(img);
}
extern(C) int sg_query_image_num_slices(Image) @system @nogc nothrow;
int queryImageNumSlices(Image img) @trusted @nogc nothrow {
    return sg_query_image_num_slices(img);
}
extern(C) int sg_query_image_num_mipmaps(Image) @system @nogc nothrow;
int queryImageNumMipmaps(Image img) @trusted @nogc nothrow {
    return sg_query_image_num_mipmaps(img);
}
extern(C) PixelFormat sg_query_image_pixelformat(Image) @system @nogc nothrow;
PixelFormat queryImagePixelformat(Image img) @trusted @nogc nothrow {
    return sg_query_image_pixelformat(img);
}
extern(C) Usage sg_query_image_usage(Image) @system @nogc nothrow;
Usage queryImageUsage(Image img) @trusted @nogc nothrow {
    return sg_query_image_usage(img);
}
extern(C) int sg_query_image_sample_count(Image) @system @nogc nothrow;
int queryImageSampleCount(Image img) @trusted @nogc nothrow {
    return sg_query_image_sample_count(img);
}
/// separate resource allocation and initialization (for async setup
extern(C) Buffer sg_alloc_buffer() @system @nogc nothrow;
/// separate resource allocation and initialization (for async setup
Buffer allocBuffer() @trusted @nogc nothrow {
    return sg_alloc_buffer();
}
extern(C) Image sg_alloc_image() @system @nogc nothrow;
Image allocImage() @trusted @nogc nothrow {
    return sg_alloc_image();
}
extern(C) Sampler sg_alloc_sampler() @system @nogc nothrow;
Sampler allocSampler() @trusted @nogc nothrow {
    return sg_alloc_sampler();
}
extern(C) Shader sg_alloc_shader() @system @nogc nothrow;
Shader allocShader() @trusted @nogc nothrow {
    return sg_alloc_shader();
}
extern(C) Pipeline sg_alloc_pipeline() @system @nogc nothrow;
Pipeline allocPipeline() @trusted @nogc nothrow {
    return sg_alloc_pipeline();
}
extern(C) Attachments sg_alloc_attachments() @system @nogc nothrow;
Attachments allocAttachments() @trusted @nogc nothrow {
    return sg_alloc_attachments();
}
extern(C) void sg_dealloc_buffer(Buffer) @system @nogc nothrow;
void deallocBuffer(Buffer buf) @trusted @nogc nothrow {
    sg_dealloc_buffer(buf);
}
extern(C) void sg_dealloc_image(Image) @system @nogc nothrow;
void deallocImage(Image img) @trusted @nogc nothrow {
    sg_dealloc_image(img);
}
extern(C) void sg_dealloc_sampler(Sampler) @system @nogc nothrow;
void deallocSampler(Sampler smp) @trusted @nogc nothrow {
    sg_dealloc_sampler(smp);
}
extern(C) void sg_dealloc_shader(Shader) @system @nogc nothrow;
void deallocShader(Shader shd) @trusted @nogc nothrow {
    sg_dealloc_shader(shd);
}
extern(C) void sg_dealloc_pipeline(Pipeline) @system @nogc nothrow;
void deallocPipeline(Pipeline pip) @trusted @nogc nothrow {
    sg_dealloc_pipeline(pip);
}
extern(C) void sg_dealloc_attachments(Attachments) @system @nogc nothrow;
void deallocAttachments(Attachments attachments) @trusted @nogc nothrow {
    sg_dealloc_attachments(attachments);
}
extern(C) void sg_init_buffer(Buffer, const BufferDesc *) @system @nogc nothrow;
void initBuffer(Buffer buf, scope ref BufferDesc desc) @trusted @nogc nothrow {
    sg_init_buffer(buf, &desc);
}
extern(C) void sg_init_image(Image, const ImageDesc *) @system @nogc nothrow;
void initImage(Image img, scope ref ImageDesc desc) @trusted @nogc nothrow {
    sg_init_image(img, &desc);
}
extern(C) void sg_init_sampler(Sampler, const SamplerDesc *) @system @nogc nothrow;
void initSampler(Sampler smg, scope ref SamplerDesc desc) @trusted @nogc nothrow {
    sg_init_sampler(smg, &desc);
}
extern(C) void sg_init_shader(Shader, const ShaderDesc *) @system @nogc nothrow;
void initShader(Shader shd, scope ref ShaderDesc desc) @trusted @nogc nothrow {
    sg_init_shader(shd, &desc);
}
extern(C) void sg_init_pipeline(Pipeline, const PipelineDesc *) @system @nogc nothrow;
void initPipeline(Pipeline pip, scope ref PipelineDesc desc) @trusted @nogc nothrow {
    sg_init_pipeline(pip, &desc);
}
extern(C) void sg_init_attachments(Attachments, const AttachmentsDesc *) @system @nogc nothrow;
void initAttachments(Attachments attachments, scope ref AttachmentsDesc desc) @trusted @nogc nothrow {
    sg_init_attachments(attachments, &desc);
}
extern(C) void sg_uninit_buffer(Buffer) @system @nogc nothrow;
void uninitBuffer(Buffer buf) @trusted @nogc nothrow {
    sg_uninit_buffer(buf);
}
extern(C) void sg_uninit_image(Image) @system @nogc nothrow;
void uninitImage(Image img) @trusted @nogc nothrow {
    sg_uninit_image(img);
}
extern(C) void sg_uninit_sampler(Sampler) @system @nogc nothrow;
void uninitSampler(Sampler smp) @trusted @nogc nothrow {
    sg_uninit_sampler(smp);
}
extern(C) void sg_uninit_shader(Shader) @system @nogc nothrow;
void uninitShader(Shader shd) @trusted @nogc nothrow {
    sg_uninit_shader(shd);
}
extern(C) void sg_uninit_pipeline(Pipeline) @system @nogc nothrow;
void uninitPipeline(Pipeline pip) @trusted @nogc nothrow {
    sg_uninit_pipeline(pip);
}
extern(C) void sg_uninit_attachments(Attachments) @system @nogc nothrow;
void uninitAttachments(Attachments atts) @trusted @nogc nothrow {
    sg_uninit_attachments(atts);
}
extern(C) void sg_fail_buffer(Buffer) @system @nogc nothrow;
void failBuffer(Buffer buf) @trusted @nogc nothrow {
    sg_fail_buffer(buf);
}
extern(C) void sg_fail_image(Image) @system @nogc nothrow;
void failImage(Image img) @trusted @nogc nothrow {
    sg_fail_image(img);
}
extern(C) void sg_fail_sampler(Sampler) @system @nogc nothrow;
void failSampler(Sampler smp) @trusted @nogc nothrow {
    sg_fail_sampler(smp);
}
extern(C) void sg_fail_shader(Shader) @system @nogc nothrow;
void failShader(Shader shd) @trusted @nogc nothrow {
    sg_fail_shader(shd);
}
extern(C) void sg_fail_pipeline(Pipeline) @system @nogc nothrow;
void failPipeline(Pipeline pip) @trusted @nogc nothrow {
    sg_fail_pipeline(pip);
}
extern(C) void sg_fail_attachments(Attachments) @system @nogc nothrow;
void failAttachments(Attachments atts) @trusted @nogc nothrow {
    sg_fail_attachments(atts);
}
/// frame stat
extern(C) void sg_enable_frame_stats() @system @nogc nothrow;
/// frame stat
void enableFrameStats() @trusted @nogc nothrow {
    sg_enable_frame_stats();
}
extern(C) void sg_disable_frame_stats() @system @nogc nothrow;
void disableFrameStats() @trusted @nogc nothrow {
    sg_disable_frame_stats();
}
extern(C) bool sg_frame_stats_enabled() @system @nogc nothrow;
bool frameStatsEnabled() @trusted @nogc nothrow {
    return sg_frame_stats_enabled();
}
extern(C) FrameStats sg_query_frame_stats() @system @nogc nothrow;
FrameStats queryFrameStats() @trusted @nogc nothrow {
    return sg_query_frame_stats();
}
/// Backend-specific structs and functions, these may come in handy for mixing
///   sokol-gfx rendering with 'native backend' rendering functions.
/// 
///   This group of functions will be expanded as needed
extern(C)
struct D3d11BufferInfo {
    const(void)* buf = null;
}
extern(C)
struct D3d11ImageInfo {
    const(void)* tex2d = null;
    const(void)* tex3d = null;
    const(void)* res = null;
    const(void)* srv = null;
}
extern(C)
struct D3d11SamplerInfo {
    const(void)* smp = null;
}
extern(C)
struct D3d11ShaderInfo {
    const(void)*[8] cbufs = null;
    const(void)* vs = null;
    const(void)* fs = null;
}
extern(C)
struct D3d11PipelineInfo {
    const(void)* il = null;
    const(void)* rs = null;
    const(void)* dss = null;
    const(void)* bs = null;
}
extern(C)
struct D3d11AttachmentsInfo {
    const(void)*[4] color_rtv = null;
    const(void)*[4] resolve_rtv = null;
    const(void)* dsv = null;
}
extern(C)
struct MtlBufferInfo {
    const(void)*[2] buf = null;
    int active_slot = 0;
}
extern(C)
struct MtlImageInfo {
    const(void)*[2] tex = null;
    int active_slot = 0;
}
extern(C)
struct MtlSamplerInfo {
    const(void)* smp = null;
}
extern(C)
struct MtlShaderInfo {
    const(void)* vertex_lib = null;
    const(void)* fragment_lib = null;
    const(void)* vertex_func = null;
    const(void)* fragment_func = null;
}
extern(C)
struct MtlPipelineInfo {
    const(void)* rps = null;
    const(void)* dss = null;
}
extern(C)
struct WgpuBufferInfo {
    const(void)* buf = null;
}
extern(C)
struct WgpuImageInfo {
    const(void)* tex = null;
    const(void)* view = null;
}
extern(C)
struct WgpuSamplerInfo {
    const(void)* smp = null;
}
extern(C)
struct WgpuShaderInfo {
    const(void)* vs_mod = null;
    const(void)* fs_mod = null;
    const(void)* bgl = null;
}
extern(C)
struct WgpuPipelineInfo {
    const(void)* pip = null;
}
extern(C)
struct WgpuAttachmentsInfo {
    const(void)*[4] color_view = null;
    const(void)*[4] resolve_view = null;
    const(void)* ds_view = null;
}
extern(C)
struct GlBufferInfo {
    uint[2] buf = 0;
    int active_slot = 0;
}
extern(C)
struct GlImageInfo {
    uint[2] tex = 0;
    uint tex_target = 0;
    uint msaa_render_buffer = 0;
    int active_slot = 0;
}
extern(C)
struct GlSamplerInfo {
    uint smp = 0;
}
extern(C)
struct GlShaderInfo {
    uint prog = 0;
}
extern(C)
struct GlAttachmentsInfo {
    uint framebuffer = 0;
    uint[4] msaa_resolve_framebuffer = 0;
}
/// D3D11: return ID3D11Devic
extern(C) const(void)* sg_d3d11_device() @system @nogc nothrow;
/// D3D11: return ID3D11Devic
scope const(void)* d3d11Device() @trusted @nogc nothrow {
    return sg_d3d11_device();
}
/// D3D11: return ID3D11DeviceContex
extern(C) const(void)* sg_d3d11_device_context() @system @nogc nothrow;
/// D3D11: return ID3D11DeviceContex
scope const(void)* d3d11DeviceContext() @trusted @nogc nothrow {
    return sg_d3d11_device_context();
}
/// D3D11: get internal buffer resource object
extern(C) D3d11BufferInfo sg_d3d11_query_buffer_info(Buffer) @system @nogc nothrow;
/// D3D11: get internal buffer resource object
D3d11BufferInfo d3d11QueryBufferInfo(Buffer buf) @trusted @nogc nothrow {
    return sg_d3d11_query_buffer_info(buf);
}
/// D3D11: get internal image resource object
extern(C) D3d11ImageInfo sg_d3d11_query_image_info(Image) @system @nogc nothrow;
/// D3D11: get internal image resource object
D3d11ImageInfo d3d11QueryImageInfo(Image img) @trusted @nogc nothrow {
    return sg_d3d11_query_image_info(img);
}
/// D3D11: get internal sampler resource object
extern(C) D3d11SamplerInfo sg_d3d11_query_sampler_info(Sampler) @system @nogc nothrow;
/// D3D11: get internal sampler resource object
D3d11SamplerInfo d3d11QuerySamplerInfo(Sampler smp) @trusted @nogc nothrow {
    return sg_d3d11_query_sampler_info(smp);
}
/// D3D11: get internal shader resource object
extern(C) D3d11ShaderInfo sg_d3d11_query_shader_info(Shader) @system @nogc nothrow;
/// D3D11: get internal shader resource object
D3d11ShaderInfo d3d11QueryShaderInfo(Shader shd) @trusted @nogc nothrow {
    return sg_d3d11_query_shader_info(shd);
}
/// D3D11: get internal pipeline resource object
extern(C) D3d11PipelineInfo sg_d3d11_query_pipeline_info(Pipeline) @system @nogc nothrow;
/// D3D11: get internal pipeline resource object
D3d11PipelineInfo d3d11QueryPipelineInfo(Pipeline pip) @trusted @nogc nothrow {
    return sg_d3d11_query_pipeline_info(pip);
}
/// D3D11: get internal pass resource object
extern(C) D3d11AttachmentsInfo sg_d3d11_query_attachments_info(Attachments) @system @nogc nothrow;
/// D3D11: get internal pass resource object
D3d11AttachmentsInfo d3d11QueryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow {
    return sg_d3d11_query_attachments_info(atts);
}
/// Metal: return __bridge-casted MTLDevic
extern(C) const(void)* sg_mtl_device() @system @nogc nothrow;
/// Metal: return __bridge-casted MTLDevic
scope const(void)* mtlDevice() @trusted @nogc nothrow {
    return sg_mtl_device();
}
/// Metal: return __bridge-casted MTLRenderCommandEncoder in current pass (or zero if outside pass
extern(C) const(void)* sg_mtl_render_command_encoder() @system @nogc nothrow;
/// Metal: return __bridge-casted MTLRenderCommandEncoder in current pass (or zero if outside pass
scope const(void)* mtlRenderCommandEncoder() @trusted @nogc nothrow {
    return sg_mtl_render_command_encoder();
}
/// Metal: get internal __bridge-casted buffer resource object
extern(C) MtlBufferInfo sg_mtl_query_buffer_info(Buffer) @system @nogc nothrow;
/// Metal: get internal __bridge-casted buffer resource object
MtlBufferInfo mtlQueryBufferInfo(Buffer buf) @trusted @nogc nothrow {
    return sg_mtl_query_buffer_info(buf);
}
/// Metal: get internal __bridge-casted image resource object
extern(C) MtlImageInfo sg_mtl_query_image_info(Image) @system @nogc nothrow;
/// Metal: get internal __bridge-casted image resource object
MtlImageInfo mtlQueryImageInfo(Image img) @trusted @nogc nothrow {
    return sg_mtl_query_image_info(img);
}
/// Metal: get internal __bridge-casted sampler resource object
extern(C) MtlSamplerInfo sg_mtl_query_sampler_info(Sampler) @system @nogc nothrow;
/// Metal: get internal __bridge-casted sampler resource object
MtlSamplerInfo mtlQuerySamplerInfo(Sampler smp) @trusted @nogc nothrow {
    return sg_mtl_query_sampler_info(smp);
}
/// Metal: get internal __bridge-casted shader resource object
extern(C) MtlShaderInfo sg_mtl_query_shader_info(Shader) @system @nogc nothrow;
/// Metal: get internal __bridge-casted shader resource object
MtlShaderInfo mtlQueryShaderInfo(Shader shd) @trusted @nogc nothrow {
    return sg_mtl_query_shader_info(shd);
}
/// Metal: get internal __bridge-casted pipeline resource object
extern(C) MtlPipelineInfo sg_mtl_query_pipeline_info(Pipeline) @system @nogc nothrow;
/// Metal: get internal __bridge-casted pipeline resource object
MtlPipelineInfo mtlQueryPipelineInfo(Pipeline pip) @trusted @nogc nothrow {
    return sg_mtl_query_pipeline_info(pip);
}
/// WebGPU: return WGPUDevice objec
extern(C) const(void)* sg_wgpu_device() @system @nogc nothrow;
/// WebGPU: return WGPUDevice objec
scope const(void)* wgpuDevice() @trusted @nogc nothrow {
    return sg_wgpu_device();
}
/// WebGPU: return WGPUQueue objec
extern(C) const(void)* sg_wgpu_queue() @system @nogc nothrow;
/// WebGPU: return WGPUQueue objec
scope const(void)* wgpuQueue() @trusted @nogc nothrow {
    return sg_wgpu_queue();
}
/// WebGPU: return this frame's WGPUCommandEncode
extern(C) const(void)* sg_wgpu_command_encoder() @system @nogc nothrow;
/// WebGPU: return this frame's WGPUCommandEncode
scope const(void)* wgpuCommandEncoder() @trusted @nogc nothrow {
    return sg_wgpu_command_encoder();
}
/// WebGPU: return WGPURenderPassEncoder of current pas
extern(C) const(void)* sg_wgpu_render_pass_encoder() @system @nogc nothrow;
/// WebGPU: return WGPURenderPassEncoder of current pas
scope const(void)* wgpuRenderPassEncoder() @trusted @nogc nothrow {
    return sg_wgpu_render_pass_encoder();
}
/// WebGPU: get internal buffer resource object
extern(C) WgpuBufferInfo sg_wgpu_query_buffer_info(Buffer) @system @nogc nothrow;
/// WebGPU: get internal buffer resource object
WgpuBufferInfo wgpuQueryBufferInfo(Buffer buf) @trusted @nogc nothrow {
    return sg_wgpu_query_buffer_info(buf);
}
/// WebGPU: get internal image resource object
extern(C) WgpuImageInfo sg_wgpu_query_image_info(Image) @system @nogc nothrow;
/// WebGPU: get internal image resource object
WgpuImageInfo wgpuQueryImageInfo(Image img) @trusted @nogc nothrow {
    return sg_wgpu_query_image_info(img);
}
/// WebGPU: get internal sampler resource object
extern(C) WgpuSamplerInfo sg_wgpu_query_sampler_info(Sampler) @system @nogc nothrow;
/// WebGPU: get internal sampler resource object
WgpuSamplerInfo wgpuQuerySamplerInfo(Sampler smp) @trusted @nogc nothrow {
    return sg_wgpu_query_sampler_info(smp);
}
/// WebGPU: get internal shader resource object
extern(C) WgpuShaderInfo sg_wgpu_query_shader_info(Shader) @system @nogc nothrow;
/// WebGPU: get internal shader resource object
WgpuShaderInfo wgpuQueryShaderInfo(Shader shd) @trusted @nogc nothrow {
    return sg_wgpu_query_shader_info(shd);
}
/// WebGPU: get internal pipeline resource object
extern(C) WgpuPipelineInfo sg_wgpu_query_pipeline_info(Pipeline) @system @nogc nothrow;
/// WebGPU: get internal pipeline resource object
WgpuPipelineInfo wgpuQueryPipelineInfo(Pipeline pip) @trusted @nogc nothrow {
    return sg_wgpu_query_pipeline_info(pip);
}
/// WebGPU: get internal pass resource object
extern(C) WgpuAttachmentsInfo sg_wgpu_query_attachments_info(Attachments) @system @nogc nothrow;
/// WebGPU: get internal pass resource object
WgpuAttachmentsInfo wgpuQueryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow {
    return sg_wgpu_query_attachments_info(atts);
}
/// GL: get internal buffer resource object
extern(C) GlBufferInfo sg_gl_query_buffer_info(Buffer) @system @nogc nothrow;
/// GL: get internal buffer resource object
GlBufferInfo glQueryBufferInfo(Buffer buf) @trusted @nogc nothrow {
    return sg_gl_query_buffer_info(buf);
}
/// GL: get internal image resource object
extern(C) GlImageInfo sg_gl_query_image_info(Image) @system @nogc nothrow;
/// GL: get internal image resource object
GlImageInfo glQueryImageInfo(Image img) @trusted @nogc nothrow {
    return sg_gl_query_image_info(img);
}
/// GL: get internal sampler resource object
extern(C) GlSamplerInfo sg_gl_query_sampler_info(Sampler) @system @nogc nothrow;
/// GL: get internal sampler resource object
GlSamplerInfo glQuerySamplerInfo(Sampler smp) @trusted @nogc nothrow {
    return sg_gl_query_sampler_info(smp);
}
/// GL: get internal shader resource object
extern(C) GlShaderInfo sg_gl_query_shader_info(Shader) @system @nogc nothrow;
/// GL: get internal shader resource object
GlShaderInfo glQueryShaderInfo(Shader shd) @trusted @nogc nothrow {
    return sg_gl_query_shader_info(shd);
}
/// GL: get internal pass resource object
extern(C) GlAttachmentsInfo sg_gl_query_attachments_info(Attachments) @system @nogc nothrow;
/// GL: get internal pass resource object
GlAttachmentsInfo glQueryAttachmentsInfo(Attachments atts) @trusted @nogc nothrow {
    return sg_gl_query_attachments_info(atts);
}