api.hpp

// GENERATED
#pragma once
#ifndef WISDOM_MODULE_DECL
#include <array>
#include <cstdint>
#include <functional>
#define WISDOM_EXPORT
#else
#define WISDOM_EXPORT export
#endif
 
WISDOM_EXPORT
namespace wis {
struct Result;
struct Size2D;
struct Size3D;
struct BufferRegion;
struct AdapterDesc;
struct InputSlotDesc;
struct InputAttribute;
struct InputLayout;
struct RasterizerDesc;
struct SampleDesc;
struct StencilDesc;
struct DepthStencilDesc;
struct BlendAttachmentDesc;
struct BlendStateDesc;
struct RenderAttachmentsDesc;
struct PushConstant;
struct SwapchainDesc;
struct TextureDesc;
struct AllocationInfo;
struct TextureRegion;
struct BufferTextureCopyRegion;
struct PushDescriptor;
struct SubresourceRange;
struct RenderTargetDesc;
struct Viewport;
struct Scissor;
struct BufferBarrier;
struct TextureBarrier;
struct DescriptorTableEntry;
struct DescriptorTable;
struct SamplerDesc;
struct ComponentMapping;
struct ShaderResourceDesc;
struct UnorderedAccessDesc;
struct FactoryExtQuery;
struct DeviceExtQuery;
struct TopLevelASBuildDesc;
struct AcceleratedGeometryInput;
struct ASAllocationInfo;
struct DescriptorBindingDesc;
struct ShaderExport;
struct HitGroupDesc;
struct ShaderBindingTableInfo;
struct RaytracingDispatchDesc;
struct TextureCopyRegion;
struct DeviceConstants;
struct RaytracingConstants;
 
enum class ShaderStages : uint32_t {
    All = 0, 
    Vertex = 1, 
    Hull = 2, 
    Domain = 3, 
    Geometry = 4, 
    Pixel = 5, 
    Amplification = 6, 
    Mesh = 7, 
    Count = 8, 
};
 
enum class Status : int32_t {
    Ok = 0, 
    Timeout = 1,
    Partial = 2,
    Error = -1, 
    InvalidArgument = -2,
    OutOfMemory = -3,
    DeviceLost = -4,
    Occluded = -5,
};
 
enum class QueueType : uint32_t {
    Graphics = 0, 
    Compute = 2, 
    Copy = 3, 
    VideoDecode = 4, 
};
 
enum class DescriptorType : uint32_t {
    Sampler = 0,
    ConstantBuffer = 1, 
    Texture = 2, 
    RWTexture = 3,
    RWBuffer = 4,
    Buffer = 5,
    AccelerationStructure = 6, 
};
 
enum class MutiWaitFlags : uint32_t {
    All = 0, 
    Any = 1, 
};
 
enum class ASGeometryType : uint32_t {
    Triangles = 0, 
    AABBs = 1, 
};
 
enum class AdapterPreference {
    None = 0, 
    MinConsumption = 1,
    Performance = 2,
};
 
enum class RaytracingShaderType : uint32_t {
    Raygen = 0, 
    Miss = 1, 
    ClosestHit = 2, 
    AnyHit = 3, 
    Intersection = 4, 
    Callable = 5, 
};
 
enum class Severity {
    Debug = 0, 
    Trace = 1, 
    Info = 2, 
    Warning = 3,
    Error = 4,
    Critical = 5,
};
 
enum class ASLevel : uint32_t {
    Bottom = 0, 
    Top = 1, 
};
 
enum class HitGroupType : uint32_t {
    Triangles = 0, 
    Procedural = 1, 
};
 
enum class InputClass : uint32_t {
    PerVertex = 0, 
    PerInstance = 1, 
};
 
enum class CullMode : uint32_t {
    None = 1, 
    Front = 2, 
    Back = 3, 
};
 
enum class DataFormat : uint32_t {
    Unknown = 0, 
    RGBA32Float = 2,
    RGBA32Uint = 3,
    RGBA32Sint = 4,
    RGB32Float = 6,
    RGB32Uint = 7,
    RGB32Sint = 8,
    RGBA16Float = 10,
    RGBA16Unorm = 11,
    RGBA16Uint = 12,
    RGBA16Snorm = 13,
    RGBA16Sint = 14,
    RG32Float = 16,
    RG32Uint = 17,
    RG32Sint = 18,
    D32FloatS8Uint = 20,
    RGB10A2Unorm = 24,
    RGB10A2Uint = 25,
    RG11B10Float = 26,
    RGBA8Unorm = 28,
    RGBA8UnormSrgb = 29,
    RGBA8Uint = 30,
    RGBA8Snorm = 31,
    RGBA8Sint = 32,
    RG16Float = 34,
    RG16Unorm = 35,
    RG16Uint = 36,
    RG16Snorm = 37,
    RG16Sint = 38,
    D32Float = 40,
    R32Float = 41,
    R32Uint = 42,
    R32Sint = 43,
    D24UnormS8Uint = 45,
    RG8Unorm = 49,
    RG8Uint = 50,
    RG8Snorm = 51,
    RG8Sint = 52,
    R16Float = 54,
    D16Unorm = 55,
    R16Unorm = 56,
    R16Uint = 57,
    R16Snorm = 58,
    R16Sint = 59,
    R8Unorm = 61,
    R8Uint = 62,
    R8Snorm = 63,
    R8Sint = 64,
    RGB9E5UFloat = 67,
    BC1RGBAUnorm = 71,
    BC1RGBAUnormSrgb = 72,
    BC2RGBAUnorm = 74,
    BC2RGBAUnormSrgb = 75,
    BC3RGBAUnorm = 77,
    BC3RGBAUnormSrgb = 78,
    BC4RUnorm = 80,
    BC4RSnorm = 81,
    BC5RGUnorm = 83,
    BC5RGSnorm = 84,
    B5G6R5Unorm = 85,
    B5G5R5A1Unorm = 86,
    BGRA8Unorm = 87,
    BGRA8UnormSrgb = 91,
    BC6HUfloat16 = 95,
    BC6HSfloat16 = 96,
    BC7RGBAUnorm = 98,
    BC7RGBAUnormSrgb = 99,
    BGRA4Unorm = 115,
};
 
enum class FillMode : uint32_t {
    Lines = 2, 
    Solid = 3, 
};
 
enum class DescriptorMemory : uint32_t {
    CpuOnly = 0,
    ShaderVisible = 1,
};
 
enum class WindingOrder : uint32_t {
    Clockwise = 0, 
    CounterClockwise = 1, 
};
 
enum class SampleRate : uint32_t {
    S1 = 1, 
    S2 = 2, 
    S4 = 4, 
    S8 = 8, 
    S16 = 16, 
};
 
enum class SwapchainScaling : uint32_t {
    None = 0, 
    Stretch = 1, 
    Aspect = 2, 
};
 
enum class Compare : uint32_t {
    None = 0, 
    Never = 1, 
    Less = 2, 
    Equal = 3, 
    LessEqual = 4, 
    Greater = 5, 
    NotEqual = 6, 
    GreaterEqual = 7, 
    Always = 8, 
};
 
enum class StencilOp : uint32_t {
    Keep = 1, 
    Zero = 2, 
    Replace = 3, 
    IncClamp = 4, 
    DecClamp = 5, 
    Invert = 6, 
    IncWrap = 7, 
    DecWrap = 8, 
};
 
enum class BlendFactor : uint32_t {
    Zero = 1, 
    One = 2, 
    SrcColor = 3, 
    InvSrcColor = 4, 
    SrcAlpha = 5, 
    InvSrcAlpha = 6, 
    DestAlpha = 7, 
    InvDestAlpha = 8, 
    DestColor = 9, 
    InvDestColor = 10, 
    SrcAlphaSat = 11, 
    ConstantColor = 14, 
    InvBlendFactor = 15, 
    Src1Color = 16, 
    InvSrc1Color = 17, 
    Src1Alpha = 18, 
    InvSrc1Alpha = 19, 
};
 
enum class BlendOp : uint32_t {
    Add = 1, 
    Subtract = 2, 
    RevSubtract = 3, 
    Min = 4, 
    Max = 5, 
};
 
enum class LogicOp : uint32_t {
    Clear = 0, 
    Set = 1, 
    Copy = 2, 
    CopyInverted = 3, 
    Noop = 4, 
    Invert = 5, 
    And = 6, 
    Nand = 7, 
    Or = 8, 
    Nor = 9, 
    Xor = 10, 
    Equiv = 11, 
    AndReverse = 12, 
    AndInverted = 13, 
    OrReverse = 14, 
    OrInverted = 15, 
};
 
enum class MemoryType : uint32_t {
    Default = 0, 
    DeviceLocal = 0,
    Upload = 1,
    Readback = 2,
    GPUUpload = 3,
};
 
enum class ShaderIntermediate : uint32_t {
    DXIL = 0, 
    SPIRV = 1, 
};
 
enum class TextureState : uint32_t {
    Undefined = 4294967295, 
    Common = 0, 
    Read = 1, 
    RenderTarget = 2, 
    UnorderedAccess = 3, 
    DepthStencilWrite = 4, 
    DepthStencilRead = 5, 
    ShaderResource = 6, 
    CopySource = 7, 
    CopyDest = 8, 
    Present = 9, 
    ShadingRate = 10, 
    VideoDecodeRead = 11, 
    VideoDecodeWrite = 12, 
};
 
enum class LoadOperation : uint32_t {
    Load = 0, 
    Clear = 1, 
    DontCare = 2, 
};
 
enum class TextureLayout : uint32_t {
    Texture1D = 2, 
    Texture1DArray = 3, 
    Texture2D = 4, 
    Texture2DArray = 5, 
    Texture2DMS = 6, 
    Texture2DMSArray = 7, 
    Texture3D = 8, 
};
 
enum class DescriptorHeapType : uint32_t {
    Descriptor = 0,
    Sampler = 1,
};
 
enum class StoreOperation : uint32_t {
    Store = 0, 
    DontCare = 1, 
    Resolve = 2, 
};
 
enum class PrimitiveTopology : uint32_t {
    PointList = 1, 
    LineList = 2, 
    LineStrip = 3, 
    TriangleList = 4, 
    TriangleStrip = 5, 
    TriangleFan = 6, 
    LineListAdj = 10, 
    LineStripAdj = 11, 
    TriangleListAdj = 12, 
    TriangleStripAdj = 13, 
};
 
enum class TopologyType : uint32_t {
    Point = 1, 
    Line = 2, 
    Triangle = 3, 
    Patch = 4, 
};
 
enum class DeviceFeature : uint32_t {
    EnchancedBarriers = 1,
    WaitForPresent = 2,
    AdvancedIndexBuffer = 4,
    DynamicVSync = 5,
    UnusedRenderTargets = 6, 
    PushDescriptors = 7, 
};
 
enum class Filter : uint32_t {
    Point = 0, 
    Linear = 1, 
};
 
enum class AddressMode : uint32_t {
    Repeat = 0, 
    MirroredRepeat = 1, 
    ClampToEdge = 2, 
    ClampToBorder = 3, 
    MirrorClampToEdge = 4, 
};
 
enum class TextureViewType : uint32_t {
    Texture1D = 0, 
    Texture1DArray = 1, 
    Texture2D = 2, 
    Texture2DArray = 3, 
    Texture2DMS = 4, 
    Texture2DMSArray = 5, 
    Texture3D = 6, 
    TextureCube = 7, 
    TextureCubeArray = 8, 
};
 
enum class ComponentSwizzle : uint32_t {
    Red = 0, 
    Green = 1, 
    Blue = 2, 
    Alpha = 3, 
    Zero = 4, 
    One = 5, 
};
 
enum class IndexType : uint32_t {
    UInt16 = 2, 
    UInt32 = 4, 
};
 
enum class FactoryExtID : uint32_t {
    Custom = 0, 
    DebugExtension = 1,
};
 
enum class DeviceExtID : uint32_t {
    Custom = 0, 
    DescriptorBufferExtension = 1,
    ExtendedAllocation = 2,
};
 
enum class ASCopyMode : uint32_t {
    Clone = 0, 
    Compact = 1, 
    Serialize = 2, 
    Deserialize = 3, 
};
 
enum class AdapterFlags {
    None = 0x0, 
    Remote = 1 << 0, 
    Software = 1 << 1, 
};
 
enum class DSSelect {
    None = 0x0, 
    Depth = 1 << 0, 
    Stencil = 1 << 1, 
    DepthStencil = 0x3, 
};
 
enum class ColorComponents {
    None = 0x0, 
    R = 1 << 0, 
    G = 1 << 1, 
    B = 1 << 2, 
    A = 1 << 3, 
    All = 0xF, 
};
 
enum class BufferUsage {
    None = 0x0, 
    CopySrc = 1 << 0, 
    CopyDst = 1 << 1, 
    ConstantBuffer = 1 << 2, 
    IndexBuffer = 1 << 3, 
    VertexBuffer = 1 << 4, 
    IndirectBuffer = 1 << 5, 
    StorageBuffer = 1 << 6, 
    AccelerationStructureBuffer = 1 << 7, 
    AccelerationStructureInput = 1 << 8, 
    ShaderBindingTable = 1 << 9, 
};
 
enum class MemoryFlags {
    None = 0x0, 
    DedicatedAllocation = 1 << 0,
    Mapped = 1 << 1,
    Exportable = 1 << 2,
};
 
enum class RenderPassFlags {
    None = 0x0, 
    Suspending = 1 << 1, 
    Resuming = 1 << 2, 
};
 
enum class BarrierSync {
    None = 0x0, 
    All = 1 << 0, 
    Draw = 1 << 1, 
    IndexInput = 1 << 2, 
    VertexShading = 1 << 3, 
    PixelShading = 1 << 4, 
    DepthStencil = 1 << 5, 
    RenderTarget = 1 << 6, 
    Compute = 1 << 7, 
    Raytracing = 1 << 8, 
    Copy = 1 << 9, 
    Resolve = 1 << 10, 
    ExecuteIndirect = 1 << 11, 
    AllShading = 1 << 12, 
    NonPixelShading = 1 << 13, 
    ClearUAV = 1 << 14, 
    VideoDecode = 1 << 15, 
    VideoEncode = 1 << 16, 
    BuildRTAS = 1 << 17, 
    CopyRTAS = 1 << 18, 
};
 
enum class ResourceAccess {
    Common = 0x0,
    VertexBuffer = 1 << 0, 
    ConstantBuffer = 1 << 1, 
    IndexBuffer = 1 << 2, 
    RenderTarget = 1 << 3, 
    UnorderedAccess = 1 << 4, 
    DepthWrite = 1 << 5, 
    DepthRead = 1 << 6, 
    ShaderResource = 1 << 7, 
    StreamOutput = 1 << 8, 
    IndirectArgument = 1 << 9, 
    CopyDest = 1 << 10, 
    CopySource = 1 << 11, 
    ConditionalRendering = 1 << 12, 
    AccelerationStructureRead = 1 << 13, 
    AccelerationStructureWrite = 1 << 14, 
    ShadingRate = 1 << 15, 
    VideoDecodeRead = 1 << 16, 
    VideoDecodeWrite = 1 << 17, 
    ResolveDest = 1 << 18, 
    ResolveSource = 1 << 19, 
    NoAccess = 1 << 31, 
};
 
enum class TextureUsage {
    None = 0x0, 
    RenderTarget = 1 << 0, 
    DepthStencil = 1 << 1, 
    CopySrc = 1 << 2, 
    CopyDst = 1 << 3, 
    ShaderResource = 1 << 4, 
    UnorderedAccess = 1 << 5, 
    HostCopy = 1 << 7, 
};
 
enum class FenceFlags {
    None = 0x0, 
    Shared = 1 << 0, 
};
 
enum class PipelineFlags {
    None = 0x0, 
    DescriptorBuffer = 1 << 0,
};
 
enum class ASGeometryFlags {
    None = 0x0, 
    Opaque = 1 << 0, 
    NoDuplicateAnyHitInvocation = 1 << 1, 
};
 
enum class AccelerationStructureFlags {
    None = 0x0, 
    AllowUpdate = 1 << 0, 
    AllowCompaction = 1 << 1, 
    PreferFastTrace = 1 << 2, 
    PreferFastBuild = 1 << 3, 
    MinimizeMemory = 1 << 4, 
};
 
enum class ASInstanceFlags {
    None = 0x0, 
    TriangleCullDisable = 1 << 0, 
    TriangleFrontCounterClockwise = 1 << 1, 
    ForceOpaque = 1 << 2, 
    ForceNoOpaque = 1 << 3, 
};
 
// [Result]
struct Result {
    wis::Status status = wis::Status::Ok; 
    const char* error = nullptr; 
};
// [Result]
 
// [Size2D]
struct Size2D {
    uint32_t width;
    uint32_t height;
};
// [Size2D]
 
// [Size3D]
struct Size3D {
    uint32_t width;
    uint32_t height;
    uint32_t depth_or_layers; 
};
// [Size3D]
 
// [BufferRegion]
struct BufferRegion {
    uint64_t src_offset = 0; 
    uint64_t dst_offset = 0; 
    uint64_t size_bytes; 
};
// [BufferRegion]
 
// [AdapterDesc]
struct AdapterDesc {
    std::array<const char, 256> description{}; 
    uint32_t vendor_id; 
    uint32_t device_id; 
    uint32_t subsys_id; 
    uint32_t revision; 
    uint64_t dedicated_video_memory; 
    uint64_t dedicated_system_memory; 
    uint64_t shared_system_memory; 
    uint64_t adapter_id; 
    std::array<uint8_t, 16> adapter_uuid{}; 
    wis::AdapterFlags flags; 
};
// [AdapterDesc]
 
// [InputSlotDesc]
struct InputSlotDesc {
    uint32_t slot; 
    uint32_t stride_bytes; 
    wis::InputClass input_class; 
};
// [InputSlotDesc]
 
// [InputAttribute]
struct InputAttribute {
    uint32_t input_slot; 
    const char* semantic_name; 
    uint32_t semantic_index; 
    uint32_t location; 
    wis::DataFormat format; 
    uint32_t offset_bytes; 
};
// [InputAttribute]
 
// [InputLayout]
struct InputLayout {
    const wis::InputSlotDesc* slots; 
    uint32_t slot_count; 
    const wis::InputAttribute* attributes; 
    uint32_t attribute_count; 
};
// [InputLayout]
 
// [RasterizerDesc]
struct RasterizerDesc {
    wis::FillMode fill_mode = wis::FillMode::Solid; 
    wis::CullMode cull_mode = wis::CullMode::Back; 
    wis::WindingOrder front_face = wis::WindingOrder::Clockwise; 
    bool depth_bias_enable = false; 
    float depth_bias = 0.0f; 
    float depth_bias_clamp = 0.0f; 
    float depth_bias_slope_factor = 0.0f; 
    bool depth_clip_enable = true; 
};
// [RasterizerDesc]
 
// [SampleDesc]
struct SampleDesc {
    wis::SampleRate rate = wis::SampleRate::S1; 
    float quality = 0.0f; 
    uint32_t sample_mask = 0xffffffff; 
};
// [SampleDesc]
 
// [StencilDesc]
struct StencilDesc {
    wis::StencilOp fail_op = wis::StencilOp::Keep; 
    wis::StencilOp depth_fail_op = wis::StencilOp::Keep; 
    wis::StencilOp pass_op = wis::StencilOp::Keep; 
    wis::Compare comparison = wis::Compare::Always; 
    uint8_t read_mask = 0xff; 
    uint8_t write_mask = 0xff; 
};
// [StencilDesc]
 
// [DepthStencilDesc]
struct DepthStencilDesc {
    bool depth_enable = false; 
    bool depth_write_enable = false; 
    wis::Compare depth_comp = wis::Compare::Less; 
    bool stencil_enable = false; 
    wis::StencilDesc stencil_front = {}; 
    wis::StencilDesc stencil_back = {}; 
    bool depth_bound_test = false; 
};
// [DepthStencilDesc]
 
// [BlendAttachmentDesc]
struct BlendAttachmentDesc {
    bool blend_enable = false; 
    wis::BlendFactor src_color_blend = wis::BlendFactor::One; 
    wis::BlendFactor dst_color_blend = wis::BlendFactor::Zero; 
    wis::BlendOp color_blend_op = wis::BlendOp::Add; 
    wis::BlendFactor src_alpha_blend = wis::BlendFactor::One; 
    wis::BlendFactor dst_alpha_blend = wis::BlendFactor::Zero; 
    wis::BlendOp alpha_blend_op = wis::BlendOp::Add; 
    wis::ColorComponents color_write_mask = wis::ColorComponents::All; 
};
// [BlendAttachmentDesc]
 
// [BlendStateDesc]
struct BlendStateDesc {
    bool logic_op_enable = false; 
    wis::LogicOp logic_op = wis::LogicOp::Noop; 
    std::array<wis::BlendAttachmentDesc, 8> attachments{}; 
    uint32_t attachment_count; 
};
// [BlendStateDesc]
 
// [RenderAttachmentsDesc]
struct RenderAttachmentsDesc {
    std::array<wis::DataFormat, 8> attachment_formats{}; 
    uint32_t attachments_count; 
    wis::DataFormat depth_attachment; 
};
// [RenderAttachmentsDesc]
 
// [PushConstant]
struct PushConstant {
    wis::ShaderStages stage; 
    uint32_t size_bytes; 
    uint32_t bind_register; 
};
// [PushConstant]
 
// [SwapchainDesc]
struct SwapchainDesc {
    wis::Size2D size; 
    wis::DataFormat format; 
    uint32_t buffer_count; 
    bool stereo; 
    bool vsync; 
    bool tearing; 
    wis::SwapchainScaling scaling; 
};
// [SwapchainDesc]
 
// [TextureDesc]
struct TextureDesc {
    wis::DataFormat format; 
    wis::Size3D size; 
    uint32_t mip_levels = 1; 
    wis::TextureLayout layout = wis::TextureLayout::Texture2D; 
    wis::SampleRate sample_count = wis::SampleRate::S1; 
    wis::TextureUsage usage = wis::TextureUsage::None; 
};
// [TextureDesc]
 
// [AllocationInfo]
struct AllocationInfo {
    uint64_t size_bytes; 
    uint64_t alignment_bytes; 
};
// [AllocationInfo]
 
// [TextureRegion]
struct TextureRegion {
    wis::Size3D offset;
    wis::Size3D size; 
    uint32_t mip; 
    uint32_t array_layer; 
    wis::DataFormat format; 
};
// [TextureRegion]
 
// [BufferTextureCopyRegion]
struct BufferTextureCopyRegion {
    uint64_t buffer_offset; 
    wis::TextureRegion texture; 
};
// [BufferTextureCopyRegion]
 
// [PushDescriptor]
struct PushDescriptor {
    wis::ShaderStages stage; 
    wis::DescriptorType type; 
};
// [PushDescriptor]
 
// [SubresourceRange]
struct SubresourceRange {
    uint32_t base_mip_level; 
    uint32_t level_count; 
    uint32_t base_array_layer; 
    uint32_t layer_count; 
};
// [SubresourceRange]
 
// [RenderTargetDesc]
struct RenderTargetDesc {
    wis::DataFormat format; 
    wis::TextureLayout layout = wis::TextureLayout::Texture2D; 
    uint32_t mip = 0; 
    uint32_t base_array_layer = 0; 
    uint32_t layer_count = 1; 
};
// [RenderTargetDesc]
 
// [Viewport]
struct Viewport {
    float top_leftx; 
    float top_lefty; 
    float width; 
    float height; 
    float min_depth; 
    float max_depth; 
};
// [Viewport]
 
// [Scissor]
struct Scissor {
    int32_t left; 
    int32_t top; 
    int32_t right; 
    int32_t bottom; 
};
// [Scissor]
 
// [BufferBarrier]
struct BufferBarrier {
    wis::BarrierSync sync_before; 
    wis::BarrierSync sync_after; 
    wis::ResourceAccess access_before; 
    wis::ResourceAccess access_after; 
    uint64_t offset = 0; 
    uint64_t size = UINT64_MAX; 
};
// [BufferBarrier]
 
// [TextureBarrier]
struct TextureBarrier {
    wis::BarrierSync sync_before; 
    wis::BarrierSync sync_after; 
    wis::ResourceAccess access_before; 
    wis::ResourceAccess access_after; 
    wis::TextureState state_before; 
    wis::TextureState state_after; 
    wis::SubresourceRange subresource_range;
};
// [TextureBarrier]
 
// [DescriptorTableEntry]
struct DescriptorTableEntry {
    wis::DescriptorType type; 
    uint32_t bind_register; 
    uint32_t binding; 
    uint32_t count; 
    uint32_t binding_space; 
};
// [DescriptorTableEntry]
 
// [DescriptorTable]
struct DescriptorTable {
    wis::DescriptorHeapType type; 
    const wis::DescriptorTableEntry* entries; 
    uint32_t entry_count; 
    wis::ShaderStages stage; 
};
// [DescriptorTable]
 
// [SamplerDesc]
struct SamplerDesc {
    wis::Filter min_filter; 
    wis::Filter mag_filter; 
    wis::Filter mip_filter; 
    bool anisotropic; 
    uint32_t max_anisotropy; 
    wis::AddressMode address_u; 
    wis::AddressMode address_v; 
    wis::AddressMode address_w; 
    float min_lod; 
    float max_lod; 
    float mip_lod_bias; 
    wis::Compare comparison_op; 
    std::array<float, 4> border_color{}; 
};
// [SamplerDesc]
 
// [ComponentMapping]
struct ComponentMapping {
    wis::ComponentSwizzle r = wis::ComponentSwizzle::Red; 
    wis::ComponentSwizzle g = wis::ComponentSwizzle::Green; 
    wis::ComponentSwizzle b = wis::ComponentSwizzle::Blue; 
    wis::ComponentSwizzle a = wis::ComponentSwizzle::Alpha; 
};
// [ComponentMapping]
 
// [ShaderResourceDesc]
struct ShaderResourceDesc {
    wis::DataFormat format; 
    wis::TextureViewType view_type; 
    wis::ComponentMapping component_mapping; 
    wis::SubresourceRange subresource_range; 
};
// [ShaderResourceDesc]
 
// [UnorderedAccessDesc]
struct UnorderedAccessDesc {
    wis::DataFormat format; 
    wis::TextureViewType view_type; 
    wis::SubresourceRange subresource_range; 
};
// [UnorderedAccessDesc]
 
// [FactoryExtQuery]
struct FactoryExtQuery {
    wis::FactoryExtID extension_id; 
    void* result;
};
// [FactoryExtQuery]
 
// [DeviceExtQuery]
struct DeviceExtQuery {
    wis::DeviceExtID extension_id; 
    void* result;
};
// [DeviceExtQuery]
 
// [TopLevelASBuildDesc]
struct TopLevelASBuildDesc {
    wis::AccelerationStructureFlags flags; 
    uint32_t instance_count; 
    uint64_t gpu_address; 
    bool indirect; 
    bool update;
};
// [TopLevelASBuildDesc]
 
// [AcceleratedGeometryInput]
struct AcceleratedGeometryInput {
    wis::ASGeometryType geometry_type; 
    wis::ASGeometryFlags flags; 
    uint64_t vertex_or_aabb_buffer_address; 
    uint64_t vertex_or_aabb_buffer_stride; 
    uint64_t index_buffer_address; 
    uint64_t transform_matrix_address; 
    uint32_t vertex_count; 
    uint32_t triangle_or_aabb_count; 
    wis::DataFormat vertex_format; 
    wis::IndexType index_format; 
};
// [AcceleratedGeometryInput]
 
// [ASAllocationInfo]
struct ASAllocationInfo {
    uint64_t scratch_size; 
    uint64_t result_size; 
    uint64_t update_size; 
};
// [ASAllocationInfo]
 
// [DescriptorBindingDesc]
struct DescriptorBindingDesc {
    wis::DescriptorType binding_type; 
    uint32_t binding_space; 
    uint32_t space_overlap_count;
    uint32_t binding_count;
};
// [DescriptorBindingDesc]
 
// [ShaderExport]
struct ShaderExport {
    const char* entry_point; 
    wis::RaytracingShaderType shader_type; 
    uint32_t shader_array_index; 
};
// [ShaderExport]
 
// [HitGroupDesc]
struct HitGroupDesc {
    wis::HitGroupType type;
    uint32_t closest_hit_export_index = UINT32_MAX; 
    uint32_t any_hit_export_index = UINT32_MAX; 
    uint32_t intersection_export_index = UINT32_MAX; 
};
// [HitGroupDesc]
 
// [ShaderBindingTableInfo]
struct ShaderBindingTableInfo {
    uint32_t entry_size; 
    uint32_t table_start_alignment; 
};
// [ShaderBindingTableInfo]
 
// [RaytracingDispatchDesc]
struct RaytracingDispatchDesc {
    uint64_t ray_gen_shader_table_address; 
    uint64_t miss_shader_table_address; 
    uint64_t hit_group_table_address; 
    uint64_t callable_shader_table_address; 
    uint32_t ray_gen_shader_table_size; 
    uint32_t miss_shader_table_size; 
    uint32_t hit_group_table_size; 
    uint32_t callable_shader_table_size; 
    uint32_t miss_shader_table_stride; 
    uint32_t hit_group_table_stride; 
    uint32_t callable_shader_table_stride; 
    uint32_t width; 
    uint32_t height; 
    uint32_t depth; 
};
// [RaytracingDispatchDesc]
 
// [TextureCopyRegion]
struct TextureCopyRegion {
    wis::TextureRegion src; 
    wis::TextureRegion dst; 
};
// [TextureCopyRegion]
 
// [DeviceConstants]
struct DeviceConstants {
    uint32_t min_cbuffer_offset_alingnment; 
    uint32_t min_buffer_offset_alingnment; 
};
// [DeviceConstants]
 
// [RaytracingConstants]
struct RaytracingConstants {
    uint32_t max_recursion_depth; 
};
// [RaytracingConstants]
 
//=================================DELEGATES=================================
 
using DebugCallback = void (*)(wis::Severity severity, const char* message, void* user_data);
//==============================TYPE TRAITS==============================
 
template<typename T>
struct is_flag_enum : public std::false_type {
};
template<>
struct is_flag_enum<wis::AdapterFlags> : public std::true_type {
};
template<>
struct is_flag_enum<wis::DSSelect> : public std::true_type {
};
template<>
struct is_flag_enum<wis::ColorComponents> : public std::true_type {
};
template<>
struct is_flag_enum<wis::BufferUsage> : public std::true_type {
};
template<>
struct is_flag_enum<wis::MemoryFlags> : public std::true_type {
};
template<>
struct is_flag_enum<wis::RenderPassFlags> : public std::true_type {
};
template<>
struct is_flag_enum<wis::BarrierSync> : public std::true_type {
};
template<>
struct is_flag_enum<wis::ResourceAccess> : public std::true_type {
};
template<>
struct is_flag_enum<wis::TextureUsage> : public std::true_type {
};
template<>
struct is_flag_enum<wis::FenceFlags> : public std::true_type {
};
template<>
struct is_flag_enum<wis::PipelineFlags> : public std::true_type {
};
template<>
struct is_flag_enum<wis::ASGeometryFlags> : public std::true_type {
};
template<>
struct is_flag_enum<wis::AccelerationStructureFlags> : public std::true_type {
};
template<>
struct is_flag_enum<wis::ASInstanceFlags> : public std::true_type {
};
//============================== CONSTS ==============================
 
inline constexpr Result success{
    wis::Status::Ok, "Operation succeeded"
};
 
template<typename RetTy>
struct ResultValue {
    Result status;
    RetTy value;
 
    constexpr ResultValue() noexcept = default;
    constexpr ResultValue(wis::Result status) noexcept
        : status(status)
    {
    }
 
    template<typename Callable, typename Callee, typename... Args>
        requires std::is_member_function_pointer_v<Callable>
    constexpr ResultValue(Callable&& f, Callee* self, Args&&... args) noexcept
        : value(std::invoke(f, self, status, std::forward<Args>(args)...))
    {
    }
    template<typename Callable, typename... Args>
    constexpr ResultValue(Callable&& f, Args&&... args) noexcept
        : value(f(status, std::forward<Args>(args)...))
    {
    }
 
    template<typename Callable, typename Callee, typename... Args>
    static constexpr ResultValue<RetTy> from_member_func(Callable&& f, Callee* self, Args&&... args) noexcept
    {
        ResultValue<RetTy> rv;
        rv.value = std::invoke(f, self, rv.status, std::forward<Args>(args)...);
        return rv;
    }
};
 
template<uint32_t s, typename RetTy>
constexpr decltype(auto) get(ResultValue<RetTy>& rv) noexcept
{
    if constexpr (s == 0) {
        return std::forward<Result>(rv.status);
    } else {
        return std::forward<RetTy>(rv.value);
    }
}
 
} // namespace wis