/*
Copyright (c) 2019-2021 Timur Gafarov.

Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
module bindbc.wgpu.types;

import core.stdc.stdint;

enum ulong WGPU_WHOLE_SIZE = 0xffffffffffffffffUL;
enum ulong WGPU_COPY_STRIDE_UNDEFINED = 0xffffffffUL;
enum ulong WGPU_LIMIT_U32_UNDEFINED = 0xffffffffUL;
enum ulong WGPU_LIMIT_U64_UNDEFINED = 0xffffffffffffffffUL;
enum ulong WGPU_ARRAY_LAYER_COUNT_UNDEFINED = 0xffffffffUL;
enum ulong WGPU_MIP_LEVEL_COUNT_UNDEFINED = 0xffffffffUL;

alias WGPUFlags = uint;

alias WGPUAdapter = void*;
alias WGPUBindGroup = void*;
alias WGPUBindGroupLayout = void*;
alias WGPUBuffer = void*;
alias WGPUCommandBuffer = void*;
alias WGPUCommandEncoder = void*;
alias WGPUComputePassEncoder = void*;
alias WGPUComputePipeline = void*;
alias WGPUDevice = void*;
alias WGPUInstance = void*;
alias WGPUPipelineLayout = void*;
alias WGPUQuerySet = void*;
alias WGPUQueue = void*;
alias WGPURenderBundle = void*;
alias WGPURenderBundleEncoder = void*;
alias WGPURenderPassEncoder = void*;
alias WGPURenderPipeline = void*;
alias WGPUSampler = void*;
alias WGPUShaderModule = void*;
alias WGPUSurface = void*;
alias WGPUSwapChain = void*;
alias WGPUTexture = void*;
alias WGPUTextureView = void*;

enum WGPUAdapterType
{
    DiscreteGPU = 0x00000000,
    IntegratedGPU = 0x00000001,
    CPU = 0x00000002,
    Unknown = 0x00000003,
    Force32 = 0x7FFFFFFF
}

enum WGPUAddressMode
{
    Repeat = 0x00000000,
    MirrorRepeat = 0x00000001,
    ClampToEdge = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUBackendType
{
    Null = 0x00000000,
    WebGPU = 0x00000001,
    D3D11 = 0x00000002,
    D3D12 = 0x00000003,
    Metal = 0x00000004,
    Vulkan = 0x00000005,
    OpenGL = 0x00000006,
    OpenGLES = 0x00000007,
    Force32 = 0x7FFFFFFF
}

enum WGPUBlendFactor
{
    Zero = 0x00000000,
    One = 0x00000001,
    Src = 0x00000002,
    OneMinusSrc = 0x00000003,
    SrcAlpha = 0x00000004,
    OneMinusSrcAlpha = 0x00000005,
    Dst = 0x00000006,
    OneMinusDst = 0x00000007,
    DstAlpha = 0x00000008,
    OneMinusDstAlpha = 0x00000009,
    SrcAlphaSaturated = 0x0000000A,
    Constant = 0x0000000B,
    OneMinusConstant = 0x0000000C,
    Force32 = 0x7FFFFFFF
}

enum WGPUBlendOperation
{
    Add = 0x00000000,
    Subtract = 0x00000001,
    ReverseSubtract = 0x00000002,
    Min = 0x00000003,
    Max = 0x00000004,
    Force32 = 0x7FFFFFFF
}

enum WGPUBufferBindingType
{
    Undefined = 0x00000000,
    Uniform = 0x00000001,
    Storage = 0x00000002,
    ReadOnlyStorage = 0x00000003,
    Force32 = 0x7FFFFFFF
}

enum WGPUBufferMapAsyncStatus
{
    Success = 0x00000000,
    Error = 0x00000001,
    Unknown = 0x00000002,
    DeviceLost = 0x00000003,
    DestroyedBeforeCallback = 0x00000004,
    UnmappedBeforeCallback = 0x00000005,
    Force32 = 0x7FFFFFFF
}

enum WGPUCompareFunction
{
    Undefined = 0x00000000,
    Never = 0x00000001,
    Less = 0x00000002,
    LessEqual = 0x00000003,
    Greater = 0x00000004,
    GreaterEqual = 0x00000005,
    Equal = 0x00000006,
    NotEqual = 0x00000007,
    Always = 0x00000008,
    Force32 = 0x7FFFFFFF
}

enum WGPUCompilationMessageType
{
    Error = 0x00000000,
    Warning = 0x00000001,
    Info = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUCreatePipelineAsyncStatus
{
    Success = 0x00000000,
    Error = 0x00000001,
    DeviceLost = 0x00000002,
    DeviceDestroyed = 0x00000003,
    Unknown = 0x00000004,
    Force32 = 0x7FFFFFFF
}

enum WGPUCullMode
{
    None = 0x00000000,
    Front = 0x00000001,
    Back = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUDeviceLostReason
{
    Undefined = 0x00000000,
    Destroyed = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUErrorFilter
{
    None = 0x00000000,
    Validation = 0x00000001,
    OutOfMemory = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUErrorType
{
    NoError = 0x00000000,
    Validation = 0x00000001,
    OutOfMemory = 0x00000002,
    Unknown = 0x00000003,
    DeviceLost = 0x00000004,
    Force32 = 0x7FFFFFFF
}

enum WGPUFeatureName
{
    Undefined = 0x00000000,
    DepthClamping = 0x00000001,
    Depth24UnormStencil8 = 0x00000002,
    Depth32FloatStencil8 = 0x00000003,
    TimestampQuery = 0x00000004,
    PipelineStatisticsQuery = 0x00000005,
    TextureCompressionBC = 0x00000006,
    Force32 = 0x7FFFFFFF
}

enum WGPUFilterMode
{
    Nearest = 0x00000000,
    Linear = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUFrontFace
{
    CCW = 0x00000000,
    CW = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUIndexFormat
{
    Undefined = 0x00000000,
    Uint16 = 0x00000001,
    Uint32 = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPULoadOp
{
    Clear = 0x00000000,
    Load = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUPipelineStatisticName
{
    VertexShaderInvocations = 0x00000000,
    ClipperInvocations = 0x00000001,
    ClipperPrimitivesOut = 0x00000002,
    FragmentShaderInvocations = 0x00000003,
    ComputeShaderInvocations = 0x00000004,
    Force32 = 0x7FFFFFFF
}

enum WGPUPowerPreference
{
    LowPower = 0x00000000,
    HighPerformance = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUPresentMode
{
    Immediate = 0x00000000,
    Mailbox = 0x00000001,
    Fifo = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUPrimitiveTopology
{
    PointList = 0x00000000,
    LineList = 0x00000001,
    LineStrip = 0x00000002,
    TriangleList = 0x00000003,
    TriangleStrip = 0x00000004,
    Force32 = 0x7FFFFFFF
}

enum WGPUQueryType
{
    Occlusion = 0x00000000,
    PipelineStatistics = 0x00000001,
    Timestamp = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUQueueWorkDoneStatus
{
    Success = 0x00000000,
    Error = 0x00000001,
    Unknown = 0x00000002,
    DeviceLost = 0x00000003,
    Force32 = 0x7FFFFFFF
}

enum WGPURequestAdapterStatus
{
    Success = 0x00000000,
    Unavailable = 0x00000001,
    Error = 0x00000002,
    Unknown = 0x00000003,
    Force32 = 0x7FFFFFFF
}

enum WGPURequestDeviceStatus
{
    Success = 0x00000000,
    Error = 0x00000001,
    Unknown = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUSType
{
    Invalid = 0x00000000,
    SurfaceDescriptorFromMetalLayer = 0x00000001,
    SurfaceDescriptorFromWindowsHWND = 0x00000002,
    SurfaceDescriptorFromXlib = 0x00000003,
    SurfaceDescriptorFromCanvasHTMLSelector = 0x00000004,
    ShaderModuleSPIRVDescriptor = 0x00000005,
    ShaderModuleWGSLDescriptor = 0x00000006,
    PrimitiveDepthClampingState = 0x00000007,
    Force32 = 0x7FFFFFFF
}

enum WGPUSamplerBindingType
{
    Undefined = 0x00000000,
    Filtering = 0x00000001,
    NonFiltering = 0x00000002,
    Comparison = 0x00000003,
    Force32 = 0x7FFFFFFF
}

enum WGPUStencilOperation
{
    Keep = 0x00000000,
    Zero = 0x00000001,
    Replace = 0x00000002,
    Invert = 0x00000003,
    IncrementClamp = 0x00000004,
    DecrementClamp = 0x00000005,
    IncrementWrap = 0x00000006,
    DecrementWrap = 0x00000007,
    Force32 = 0x7FFFFFFF
}

enum WGPUStorageTextureAccess
{
    Undefined = 0x00000000,
    WriteOnly = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUStoreOp
{
    Store = 0x00000000,
    Discard = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUTextureAspect
{
    All = 0x00000000,
    StencilOnly = 0x00000001,
    DepthOnly = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUTextureComponentType
{
    Float = 0x00000000,
    Sint = 0x00000001,
    Uint = 0x00000002,
    DepthComparison = 0x00000003,
    Force32 = 0x7FFFFFFF
}

enum WGPUTextureDimension
{
    D1 = 0x00000000,
    D2 = 0x00000001,
    D3 = 0x00000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUTextureFormat
{
    Undefined = 0x00000000,
    R8Unorm = 0x00000001,
    R8Snorm = 0x00000002,
    R8Uint = 0x00000003,
    R8Sint = 0x00000004,
    R16Uint = 0x00000005,
    R16Sint = 0x00000006,
    R16Float = 0x00000007,
    RG8Unorm = 0x00000008,
    RG8Snorm = 0x00000009,
    RG8Uint = 0x0000000A,
    RG8Sint = 0x0000000B,
    R32Float = 0x0000000C,
    R32Uint = 0x0000000D,
    R32Sint = 0x0000000E,
    RG16Uint = 0x0000000F,
    RG16Sint = 0x00000010,
    RG16Float = 0x00000011,
    RGBA8Unorm = 0x00000012,
    RGBA8UnormSrgb = 0x00000013,
    RGBA8Snorm = 0x00000014,
    RGBA8Uint = 0x00000015,
    RGBA8Sint = 0x00000016,
    BGRA8Unorm = 0x00000017,
    BGRA8UnormSrgb = 0x00000018,
    RGB10A2Unorm = 0x00000019,
    RG11B10Ufloat = 0x0000001A,
    RGB9E5Ufloat = 0x0000001B,
    RG32Float = 0x0000001C,
    RG32Uint = 0x0000001D,
    RG32Sint = 0x0000001E,
    RGBA16Uint = 0x0000001F,
    RGBA16Sint = 0x00000020,
    RGBA16Float = 0x00000021,
    RGBA32Float = 0x00000022,
    RGBA32Uint = 0x00000023,
    RGBA32Sint = 0x00000024,
    Stencil8 = 0x00000025,
    Depth16Unorm = 0x00000026,
    Depth24Plus = 0x00000027,
    Depth24PlusStencil8 = 0x00000028,
    Depth32Float = 0x00000029,
    BC1RGBAUnorm = 0x0000002A,
    BC1RGBAUnormSrgb = 0x0000002B,
    BC2RGBAUnorm = 0x0000002C,
    BC2RGBAUnormSrgb = 0x0000002D,
    BC3RGBAUnorm = 0x0000002E,
    BC3RGBAUnormSrgb = 0x0000002F,
    BC4RUnorm = 0x00000030,
    BC4RSnorm = 0x00000031,
    BC5RGUnorm = 0x00000032,
    BC5RGSnorm = 0x00000033,
    BC6HRGBUfloat = 0x00000034,
    BC6HRGBFloat = 0x00000035,
    BC7RGBAUnorm = 0x00000036,
    BC7RGBAUnormSrgb = 0x00000037,
    Force32 = 0x7FFFFFFF
}

enum WGPUTextureSampleType
{
    Undefined = 0x00000000,
    Float = 0x00000001,
    UnfilterableFloat = 0x00000002,
    Depth = 0x00000003,
    Sint = 0x00000004,
    Uint = 0x00000005,
    Force32 = 0x7FFFFFFF
}

enum WGPUTextureViewDimension
{
    Undefined = 0x00000000,
    D1 = 0x00000001,
    D2 = 0x00000002,
    D2Array = 0x00000003,
    Cube = 0x00000004,
    CubeArray = 0x00000005,
    D3 = 0x00000006,
    Force32 = 0x7FFFFFFF
}

enum WGPUVertexFormat
{
    Undefined = 0x00000000,
    Uint8x2 = 0x00000001,
    Uint8x4 = 0x00000002,
    Sint8x2 = 0x00000003,
    Sint8x4 = 0x00000004,
    Unorm8x2 = 0x00000005,
    Unorm8x4 = 0x00000006,
    Snorm8x2 = 0x00000007,
    Snorm8x4 = 0x00000008,
    Uint16x2 = 0x00000009,
    Uint16x4 = 0x0000000A,
    Sint16x2 = 0x0000000B,
    Sint16x4 = 0x0000000C,
    Unorm16x2 = 0x0000000D,
    Unorm16x4 = 0x0000000E,
    Snorm16x2 = 0x0000000F,
    Snorm16x4 = 0x00000010,
    Float16x2 = 0x00000011,
    Float16x4 = 0x00000012,
    Float32 = 0x00000013,
    Float32x2 = 0x00000014,
    Float32x3 = 0x00000015,
    Float32x4 = 0x00000016,
    Uint32 = 0x00000017,
    Uint32x2 = 0x00000018,
    Uint32x3 = 0x00000019,
    Uint32x4 = 0x0000001A,
    Sint32 = 0x0000001B,
    Sint32x2 = 0x0000001C,
    Sint32x3 = 0x0000001D,
    Sint32x4 = 0x0000001E,
    Force32 = 0x7FFFFFFF
}

enum WGPUVertexStepMode
{
    Vertex = 0x00000000,
    Instance = 0x00000001,
    Force32 = 0x7FFFFFFF
}

enum WGPUBufferUsage
{
    None = 0x00000000,
    MapRead = 0x00000001,
    MapWrite = 0x00000002,
    CopySrc = 0x00000004,
    CopyDst = 0x00000008,
    Index = 0x00000010,
    Vertex = 0x00000020,
    Uniform = 0x00000040,
    Storage = 0x00000080,
    Indirect = 0x00000100,
    QueryResolve = 0x00000200,
    Force32 = 0x7FFFFFFF
}

alias WGPUBufferUsageFlags = WGPUFlags;

enum WGPUColorWriteMask
{
    None = 0x00000000,
    Red = 0x00000001,
    Green = 0x00000002,
    Blue = 0x00000004,
    Alpha = 0x00000008,
    All = 0x0000000F,
    Force32 = 0x7FFFFFFF
}

alias WGPUColorWriteMaskFlags = WGPUFlags;

enum WGPUMapMode
{
    None = 0x00000000,
    Read = 0x00000001,
    Write = 0x00000002,
    Force32 = 0x7FFFFFFF
}

alias WGPUMapModeFlags = WGPUFlags;

enum WGPUShaderStage
{
    None = 0x00000000,
    Vertex = 0x00000001,
    Fragment = 0x00000002,
    Compute = 0x00000004,
    Force32 = 0x7FFFFFFF
}

alias WGPUShaderStageFlags = WGPUFlags;

enum WGPUTextureUsage
{
    None = 0x00000000,
    CopySrc = 0x00000001,
    CopyDst = 0x00000002,
    TextureBinding = 0x00000004,
    StorageBinding = 0x00000008,
    RenderAttachment = 0x00000010,
    Force32 = 0x7FFFFFFF
}

alias WGPUTextureUsageFlags = WGPUFlags;

struct WGPUChainedStruct
{
    const(WGPUChainedStruct)* next;
    WGPUSType sType;
}

struct WGPUChainedStructOut
{
    WGPUChainedStructOut* next;
    WGPUSType sType;
}

struct WGPUAdapterProperties
{
    WGPUChainedStructOut* nextInChain;
    uint vendorID;
    uint deviceID;
    const(char)* name;
    const(char)* driverDescription;
    WGPUAdapterType adapterType;
    WGPUBackendType backendType;
}

struct WGPUBindGroupEntry
{
    const(WGPUChainedStruct)* nextInChain;
    uint binding;
    WGPUBuffer buffer;
    ulong offset;
    ulong size;
    WGPUSampler sampler;
    WGPUTextureView textureView;
}

struct WGPUBlendComponent
{
    WGPUBlendOperation operation;
    WGPUBlendFactor srcFactor;
    WGPUBlendFactor dstFactor;
}

struct WGPUBufferBindingLayout
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUBufferBindingType type;
    bool hasDynamicOffset;
    ulong minBindingSize;
}

struct WGPUBufferDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUBufferUsageFlags usage;
    ulong size;
    bool mappedAtCreation;
}

struct WGPUColor
{
    double r;
    double g;
    double b;
    double a;
}

struct WGPUCommandBufferDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
}

struct WGPUCommandEncoderDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
}

struct WGPUCompilationMessage
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* message;
    WGPUCompilationMessageType type;
    ulong lineNum;
    ulong linePos;
    ulong offset;
    ulong length;
}

struct WGPUComputePassDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
}

struct WGPUConstantEntry
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* key;
    double value;
}

struct WGPUExtent3D
{
    uint width;
    uint height;
    uint depthOrArrayLayers;
}

struct WGPUInstanceDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
}

struct WGPULimits
{
    uint maxTextureDimension1D;
    uint maxTextureDimension2D;
    uint maxTextureDimension3D;
    uint maxTextureArrayLayers;
    uint maxBindGroups;
    uint maxDynamicUniformBuffersPerPipelineLayout;
    uint maxDynamicStorageBuffersPerPipelineLayout;
    uint maxSampledTexturesPerShaderStage;
    uint maxSamplersPerShaderStage;
    uint maxStorageBuffersPerShaderStage;
    uint maxStorageTexturesPerShaderStage;
    uint maxUniformBuffersPerShaderStage;
    ulong maxUniformBufferBindingSize;
    ulong maxStorageBufferBindingSize;
    uint minUniformBufferOffsetAlignment;
    uint minStorageBufferOffsetAlignment;
    uint maxVertexBuffers;
    uint maxVertexAttributes;
    uint maxVertexBufferArrayStride;
    uint maxInterStageShaderComponents;
    uint maxComputeWorkgroupStorageSize;
    uint maxComputeInvocationsPerWorkgroup;
    uint maxComputeWorkgroupSizeX;
    uint maxComputeWorkgroupSizeY;
    uint maxComputeWorkgroupSizeZ;
    uint maxComputeWorkgroupsPerDimension;
}

struct WGPUMultisampleState
{
    const(WGPUChainedStruct)* nextInChain;
    uint count;
    uint mask;
    bool alphaToCoverageEnabled;
}

struct WGPUOrigin3D
{
    uint x;
    uint y;
    uint z;
}

struct WGPUPipelineLayoutDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    uint bindGroupLayoutCount;
    const(WGPUBindGroupLayout)* bindGroupLayouts;
}

struct WGPUPrimitiveDepthClampingState
{
    WGPUChainedStruct chain;
    bool clampDepth;
}

struct WGPUPrimitiveState
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUPrimitiveTopology topology;
    WGPUIndexFormat stripIndexFormat;
    WGPUFrontFace frontFace;
    WGPUCullMode cullMode;
}

struct WGPUQuerySetDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUQueryType type;
    uint count;
    const(WGPUPipelineStatisticName)* pipelineStatistics;
    uint pipelineStatisticsCount;
}

struct WGPURenderBundleDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
}

struct WGPURenderBundleEncoderDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    uint colorFormatsCount;
    const(WGPUTextureFormat)* colorFormats;
    WGPUTextureFormat depthStencilFormat;
    uint sampleCount;
}

struct WGPURenderPassDepthStencilAttachment
{
    WGPUTextureView view;
    WGPULoadOp depthLoadOp;
    WGPUStoreOp depthStoreOp;
    float clearDepth;
    bool depthReadOnly;
    WGPULoadOp stencilLoadOp;
    WGPUStoreOp stencilStoreOp;
    uint clearStencil;
    bool stencilReadOnly;
}

struct WGPURequestAdapterOptions
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUSurface compatibleSurface;
    WGPUPowerPreference powerPreference;
    bool forceFallbackAdapter;
}

struct WGPUSamplerBindingLayout
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUSamplerBindingType type;
}

struct WGPUSamplerDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUAddressMode addressModeU;
    WGPUAddressMode addressModeV;
    WGPUAddressMode addressModeW;
    WGPUFilterMode magFilter;
    WGPUFilterMode minFilter;
    WGPUFilterMode mipmapFilter;
    float lodMinClamp;
    float lodMaxClamp;
    WGPUCompareFunction compare;
    ushort maxAnisotropy;
}

struct WGPUShaderModuleDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
}

struct WGPUShaderModuleSPIRVDescriptor
{
    WGPUChainedStruct chain;
    uint codeSize;
    const(uint)* code;
}

struct WGPUShaderModuleWGSLDescriptor
{
    WGPUChainedStruct chain;
    const(char)* source;
}

struct WGPUStencilFaceState
{
    WGPUCompareFunction compare;
    WGPUStencilOperation failOp;
    WGPUStencilOperation depthFailOp;
    WGPUStencilOperation passOp;
}

struct WGPUStorageTextureBindingLayout
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUStorageTextureAccess access;
    WGPUTextureFormat format;
    WGPUTextureViewDimension viewDimension;
}

struct WGPUSurfaceDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
}

struct WGPUSurfaceDescriptorFromCanvasHTMLSelector
{
    WGPUChainedStruct chain;
    const(char)* selector;
}

struct WGPUSurfaceDescriptorFromMetalLayer
{
    WGPUChainedStruct chain;
    void* layer;
}

struct WGPUSurfaceDescriptorFromWindowsHWND
{
    WGPUChainedStruct chain;
    void* hinstance;
    void* hwnd;
}

struct WGPUSurfaceDescriptorFromXlib
{
    WGPUChainedStruct chain;
    void* display;
    uint window;
}

struct WGPUSwapChainDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUTextureUsageFlags usage;
    WGPUTextureFormat format;
    uint width;
    uint height;
    WGPUPresentMode presentMode;
}

struct WGPUTextureBindingLayout
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUTextureSampleType sampleType;
    WGPUTextureViewDimension viewDimension;
    bool multisampled;
}

struct WGPUTextureDataLayout
{
    const(WGPUChainedStruct)* nextInChain;
    ulong offset;
    uint bytesPerRow;
    uint rowsPerImage;
}

struct WGPUTextureViewDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUTextureFormat format;
    WGPUTextureViewDimension dimension;
    uint baseMipLevel;
    uint mipLevelCount;
    uint baseArrayLayer;
    uint arrayLayerCount;
    WGPUTextureAspect aspect;
}

struct WGPUVertexAttribute
{
    WGPUVertexFormat format;
    ulong offset;
    uint shaderLocation;
}

struct WGPUBindGroupDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUBindGroupLayout layout;
    uint entryCount;
    const(WGPUBindGroupEntry)* entries;
}

struct WGPUBindGroupLayoutEntry
{
    const(WGPUChainedStruct)* nextInChain;
    uint binding;
    WGPUShaderStageFlags visibility;
    WGPUBufferBindingLayout buffer;
    WGPUSamplerBindingLayout sampler;
    WGPUTextureBindingLayout texture;
    WGPUStorageTextureBindingLayout storageTexture;
}

struct WGPUBlendState
{
    WGPUBlendComponent color;
    WGPUBlendComponent alpha;
}

struct WGPUCompilationInfo
{
    const(WGPUChainedStruct)* nextInChain;
    uint messageCount;
    const(WGPUCompilationMessage)* messages;
}

struct WGPUDepthStencilState
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUTextureFormat format;
    bool depthWriteEnabled;
    WGPUCompareFunction depthCompare;
    WGPUStencilFaceState stencilFront;
    WGPUStencilFaceState stencilBack;
    uint stencilReadMask;
    uint stencilWriteMask;
    int depthBias;
    float depthBiasSlopeScale;
    float depthBiasClamp;
}

struct WGPUImageCopyBuffer
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUTextureDataLayout layout;
    WGPUBuffer buffer;
}

struct WGPUImageCopyTexture
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUTexture texture;
    uint mipLevel;
    WGPUOrigin3D origin;
    WGPUTextureAspect aspect;
}

struct WGPUProgrammableStageDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUShaderModule modul;
    const(char)* entryPoint;
    uint constantCount;
    const(WGPUConstantEntry)* constants;
}

struct WGPURenderPassColorAttachment
{
    WGPUTextureView view;
    WGPUTextureView resolveTarget;
    WGPULoadOp loadOp;
    WGPUStoreOp storeOp;
    WGPUColor clearColor;
}

struct WGPURequiredLimits
{
    const(WGPUChainedStruct)* nextInChain;
    WGPULimits limits;
}

struct WGPUSupportedLimits
{
    WGPUChainedStructOut* nextInChain;
    WGPULimits limits;
}

struct WGPUTextureDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUTextureUsageFlags usage;
    WGPUTextureDimension dimension;
    WGPUExtent3D size;
    WGPUTextureFormat format;
    uint mipLevelCount;
    uint sampleCount;
}

struct WGPUVertexBufferLayout
{
    ulong arrayStride;
    WGPUVertexStepMode stepMode;
    uint attributeCount;
    const(WGPUVertexAttribute)* attributes;
}

struct WGPUBindGroupLayoutDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    uint entryCount;
    const(WGPUBindGroupLayoutEntry)* entries;
}

struct WGPUColorTargetState
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUTextureFormat format;
    const(WGPUBlendState)* blend;
    WGPUColorWriteMaskFlags writeMask;
}

struct WGPUComputePipelineDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUPipelineLayout layout;
    WGPUProgrammableStageDescriptor compute;
}

struct WGPUDeviceDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    uint requiredFeaturesCount;
    const(WGPUFeatureName)* requiredFeatures;
    const(WGPURequiredLimits)* requiredLimits;
}

struct WGPURenderPassDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    uint colorAttachmentCount;
    const(WGPURenderPassColorAttachment)* colorAttachments;
    const(WGPURenderPassDepthStencilAttachment)* depthStencilAttachment;
    WGPUQuerySet occlusionQuerySet;
}

struct WGPUVertexState
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUShaderModule modul;
    const(char)* entryPoint;
    uint constantCount;
    const(WGPUConstantEntry)* constants;
    uint bufferCount;
    const(WGPUVertexBufferLayout)* buffers;
}

struct WGPUFragmentState
{
    const(WGPUChainedStruct)* nextInChain;
    WGPUShaderModule modul;
    const(char)* entryPoint;
    uint constantCount;
    const(WGPUConstantEntry)* constants;
    uint targetCount;
    const(WGPUColorTargetState)* targets;
}

struct WGPURenderPipelineDescriptor
{
    const(WGPUChainedStruct)* nextInChain;
    const(char)* label;
    WGPUPipelineLayout layout;
    WGPUVertexState vertex;
    WGPUPrimitiveState primitive;
    const(WGPUDepthStencilState)* depthStencil;
    WGPUMultisampleState multisample;
    const(WGPUFragmentState)* fragment;
}

alias WGPUBufferMapCallback = extern(C) void function(WGPUBufferMapAsyncStatus status, void* userdata);
alias WGPUCreateComputePipelineAsyncCallback = extern(C) void function(WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline pipeline, const(char)* message, void* userdata);
alias WGPUCreateRenderPipelineAsyncCallback = extern(C) void function(WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, const(char)* message, void* userdata);
alias WGPUDeviceLostCallback = extern(C) void function(WGPUDeviceLostReason reason, const(char)* message, void* userdata);
alias WGPUErrorCallback = extern(C) void function(WGPUErrorType type, const(char)* message, void* userdata);
alias WGPUQueueWorkDoneCallback = extern(C) void function(WGPUQueueWorkDoneStatus status, void* userdata);
alias WGPURequestAdapterCallback = extern(C) void function(WGPURequestAdapterStatus status, WGPUAdapter adapter, const(char)* message, void* userdata);
alias WGPURequestDeviceCallback = extern(C) void function(WGPURequestDeviceStatus status, WGPUDevice device, const(char)* message, void* userdata);
alias WGPUProc = extern(C) void function();

enum WGPUNativeSType
{
    // Start at 6 to prevent collisions with webgpu STypes
    DeviceExtras = 0x60000001,
    AdapterExtras = 0x60000002,
    Force32 = 0x7FFFFFFF
}

enum WGPUNativeFeature
{
    TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES = 0x10000000
}

enum WGPULogLevel
{
    Off = 0x00000000,
    Error = 0x00000001,
    Warn = 0x00000002,
    Info = 0x00000003,
    Debug = 0x00000004,
    Trace = 0x00000005,
    Force32 = 0x7FFFFFFF
}

struct WGPUAdapterExtras
{
    WGPUChainedStruct chain;
    WGPUBackendType backend;
}

struct WGPUDeviceExtras
{
    WGPUChainedStruct chain;
    WGPUNativeFeature nativeFeatures;
    const(char)* label;
    const(char)* tracePath;
}

alias WGPULogCallback = extern(C) void function(WGPULogLevel level, const(char)* msg);