diff --git a/lib/sdl3/src/generators/gpu.py b/lib/sdl3/src/generators/gpu.py index 948a906..748d382 100644 --- a/lib/sdl3/src/generators/gpu.py +++ b/lib/sdl3/src/generators/gpu.py @@ -1,9 +1,25 @@ import os import sys from pprint import pprint +import math import subprocess +def convertCase(x): + s = '' + underbar = False + for y in x: + if y == '_': + underbar = True + continue + else: + s += y.lower() if not underbar else y + + if underbar: + underbar = False + return s + + origDir = os.path.abspath(os.path.dirname(__file__)) os.chdir(origDir) @@ -24,9 +40,30 @@ defines = [] lastList = None -with open(gpufile) as f: +with open(gpufile) as rf: mode = mode_default braceCount = 0 + f = rf.readlines() + + x = [ y + '\n' for y in """ +typedef struct SDL_FColor { + + float r; + float g; + float b; + float a; +} SDL_FColor; + +typedef enum SDL_FlipMode { + + SDL_FLIP_NONE, /**< Do not flip */ + SDL_FLIP_HORIZONTAL, /**< flip horizontally */ + SDL_FLIP_VERTICAL /**< flip vertically */ +} SDL_FlipMode; + """.split('\n')] + + f += x + for l in f: dropped = True line = l.strip() @@ -113,15 +150,16 @@ ostring = 'pub const c = @import("c.zig").c;\n\npub const PropertiesID = u32;' # time to generate types... # first the opaques +ostring += '\n' + typeMap = { 'Uint32': 'u32', 'float': 'f32', 'Sint32': 'i32', 'bool': 'bool', 'Uint8': 'u8', 'SDL_PropertiesID': 'PropertiesID','char': 'i8', 'size_t': 'usize', - 'SDL_GPUColorComponentFlags': 'GPUColorComponentFlags', 'SDL_FColor': 'FColor', 'SDL_FlipMode': 'FlipMode' } -typeMap_r= {} +typeMap_r = {} for t in typedefs_pod: @@ -151,9 +189,88 @@ for t in typedefs_opaque: ostring += '\n' +packedFlags = [ + ('SDL_GPUTextureUsageFlags', 'Uint32', [ + ('SDL_GPU_TEXTUREUSAGE_SAMPLER', 1 << 0), + ('SDL_GPU_TEXTUREUSAGE_COLOR_TARGET', 1 << 1), + ('SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET', 1 << 2), + ('SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ', 1 << 3), + ('SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ', 1 << 4), + ('SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE', 1 << 5), + ('SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE', 1 << 6), + ]), + ('SDL_GPUBufferUsageFlags', 'Uint32', [ + ('SDL_GPU_BUFFERUSAGE_VERTEX', (1 << 0)), + ('SDL_GPU_BUFFERUSAGE_INDEX', (1 << 1)), + ('SDL_GPU_BUFFERUSAGE_INDIRECT', (1 << 2)), + ('SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ', (1 << 3)), + ('SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ', (1 << 4)), + ('SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE', (1 << 5)), + ]), + ('SDL_GPUColorComponentFlags', 'Uint8', [ + ('SDL_GPU_COLORCOMPONENT_R', (1 << 0)), + ('SDL_GPU_COLORCOMPONENT_G', (1 << 1)), + ('SDL_GPU_COLORCOMPONENT_B', (1 << 2)), + ('SDL_GPU_COLORCOMPONENT_A', (1 << 3)), + ]), + ('SDL_GPUShaderFormat', 'Uint32', [ + ('SDL_GPU_SHADERFORMAT_PRIVATE', (1 << 0)), + ('SDL_GPU_SHADERFORMAT_SPIRV', (1 << 1)), + ('SDL_GPU_SHADERFORMAT_DXBC', (1 << 2)), + ('SDL_GPU_SHADERFORMAT_DXIL', (1 << 3)), + ('SDL_GPU_SHADERFORMAT_MSL', (1 << 4)), + ('SDL_GPU_SHADERFORMAT_METALLIB', (1 << 5)), + ], [('Invalid', '.{}')]), +] + +def makePackedFlags(typename, backingtype, flagList, constants=None): + global typeMap + global typeMap_r + + c_typename = typename + if typename.startswith("SDL_"): + typename = typename[4:] + + typeMap[c_typename] = typename + typeMap_r[typename] = c_typename + + rv = 'pub const ' + typename + ' = packed struct(' + typeMap[backingtype] + ') {\n' + + offset = 0 + padcount = 0 + for flag in flagList: + name = flag[0] + targetOffset = math.log2(flag[1]) + + if 'SDL_GPU_' in name: + name = name[8:] + name = convertCase(name) + + if targetOffset != offset: + diff = int(targetOffset - offset) + rv += ' ' + 'pad' + str(padcount) + ': u' + str(diff) + ' = 0,\n' + padcount += 1 + offset = targetOffset + + rv += ' ' + name + ': bool = false,\n' + offset += 1 + + if constants is not None: + for constant in constants: + rv += f' pub const {constant[0]}: @This() = {constant[1]};\n' + + rv += '};\n' + + return rv + +ostring += '\n' + +for p in packedFlags: + ostring += makePackedFlags(*p) + for t in typedefs_enum: typename = t.split("}")[1].strip('\n ;') - print("E", typename) + #print("E", typename, t) c_typename = typename if typename.startswith("SDL_"): typename = typename[4:] @@ -161,6 +278,45 @@ for t in typedefs_enum: typeMap[c_typename] = typename typeMap_r[typename] = c_typename + # print(t) + + inners = t.strip().split('\n')[1:-1] + e = [] + + for i in range(0, len(inners)): + line = inners[i] + if ',' in line or line == inners[-1]: + e.append(line.strip()) + + + for i in range(0, len(e)): + e[i] = e[i].replace('/*', '//') + e[i] = e[i].replace('SDL_GPU_', '') + + if ',' not in e[i]: + count = 0 + for x in e[i]: + if x == ' ': + break + count += 1 + + e[i] = e[i][:count] + ',' + e[i][count:] + + r = e[i].split(',') + + r[0] = convertCase(r[0]) + + e[i] = r[0] + ',' + r[1] + common = os.path.commonprefix(e) + #print(common) + #plos(e) + + ostring += 'pub const ' + typename + ' = ' + 'enum {\n' + for i in e: + ostring += ' ' + i + '\n' + ostring += '};\n\n' + + for t in typedefs_struct: typename = t.split("}")[1].strip('\n ;') c_typename = typename @@ -171,14 +327,6 @@ for t in typedefs_struct: typeMap_r[typename] = c_typename for t in typedefs_struct: - # > typedef struct SDL_GPUViewport{ - # float x; /**< The left offset of the viewport. */ - # float y; /**< The top offset of the viewport. */ - # float w; /**< The width of the viewport. */ - # float h; /**< The height of the viewport. */ - # float min_depth; /**< The minimum depth of the viewport. */ - # float max_depth; /**< The maximum depth of the viewport. */ - # } SDL_GPUViewport; typename = t.split("}")[1].strip('\n ;') c_typename = typename @@ -190,7 +338,7 @@ for t in typedefs_struct: inner = t.strip("\n ").split('\n')[1:-1] - print("----", typename) + # print("----", typename) for i in range(0, len(inner)): inner[i] = inner[i].replace('/*', "//") inner[i] = inner[i].replace('*<', "") @@ -237,5 +385,11 @@ for t in typedefs_struct: ostring += tstr + "\n" -print (ostring) +for t in functions: + print(t) + +# print (ostring) + +with open(os.path.abspath(os.path.join(origDir, '../gpu.zig')), 'w') as f: + f.write(ostring) diff --git a/lib/sdl3/src/gpu.zig b/lib/sdl3/src/gpu.zig index 20317e1..7391f36 100644 --- a/lib/sdl3/src/gpu.zig +++ b/lib/sdl3/src/gpu.zig @@ -1 +1,696 @@ -const c = @import("c.zig").c; +pub const c = @import("c.zig").c; + +pub const PropertiesID = u32; +pub const GPUDevice = opaque{}; +pub const GPUBuffer = opaque{}; +pub const GPUTransferBuffer = opaque{}; +pub const GPUTexture = opaque{}; +pub const GPUSampler = opaque{}; +pub const GPUShader = opaque{}; +pub const GPUComputePipeline = opaque{}; +pub const GPUGraphicsPipeline = opaque{}; +pub const GPUCommandBuffer = opaque{}; +pub const GPURenderPass = opaque{}; +pub const GPUComputePass = opaque{}; +pub const GPUCopyPass = opaque{}; +pub const GPUFence = opaque{}; + + +pub const GPUTextureUsageFlags = packed struct(u32) { + textureusageSampler: bool = false, + textureusageColorTarget: bool = false, + textureusageDepthStencilTarget: bool = false, + textureusageGraphicsStorageRead: bool = false, + textureusageComputeStorageRead: bool = false, + textureusageComputeStorageWrite: bool = false, + textureusageComputeStorageSimultaneousReadWrite: bool = false, +}; +pub const GPUBufferUsageFlags = packed struct(u32) { + bufferusageVertex: bool = false, + bufferusageIndex: bool = false, + bufferusageIndirect: bool = false, + bufferusageGraphicsStorageRead: bool = false, + bufferusageComputeStorageRead: bool = false, + bufferusageComputeStorageWrite: bool = false, +}; +pub const GPUColorComponentFlags = packed struct(u8) { + colorcomponentR: bool = false, + colorcomponentG: bool = false, + colorcomponentB: bool = false, + colorcomponentA: bool = false, +}; +pub const GPUShaderFormat = packed struct(u32) { + shaderformatPrivate: bool = false, + shaderformatSpirv: bool = false, + shaderformatDxbc: bool = false, + shaderformatDxil: bool = false, + shaderformatMsl: bool = false, + shaderformatMetallib: bool = false, + pub const Invalid: @This() = .{}; +}; +pub const GPUPrimitiveType = enum { + primitivetypeTrianglelist, //*< A series of separate triangles. */ + primitivetypeTrianglestrip, //*< A series of connected triangles. */ + primitivetypeLinelist, //*< A series of separate lines. */ + primitivetypeLinestrip, //*< A series of connected lines. */ + primitivetypePointlist, //*< A series of separate points. */ +}; + +pub const GPULoadOp = enum { + loadopLoad, //*< The previous contents of the texture will be preserved. */ + loadopClear, //*< The contents of the texture will be cleared to a color. */ + loadopDontCare, //*< The previous contents of the texture need not be preserved. The contents will be undefined. */ +}; + +pub const GPUStoreOp = enum { + storeopStore, //*< The contents generated during the render pass will be written to memory. */ + storeopDontCare, //*< The contents generated during the render pass are not needed and may be discarded. The contents will be undefined. */ + storeopResolve, //*< The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture may then be discarded and will be undefined. */ + storeopResolveAndStore, //*< The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture will be written to memory. */ +}; + +pub const GPUIndexElementSize = enum { + indexelementsize16bit, //*< The index elements are 16-bit. */ + indexelementsize32bit, //*< The index elements are 32-bit. */ +}; + +pub const GPUTextureFormat = enum { + textureformatInvalid, + textureformatA8Unorm, + textureformatR8Unorm, + textureformatR8g8Unorm, + textureformatR8g8b8a8Unorm, + textureformatR16Unorm, + textureformatR16g16Unorm, + textureformatR16g16b16a16Unorm, + textureformatR10g10b10a2Unorm, + textureformatB5g6r5Unorm, + textureformatB5g5r5a1Unorm, + textureformatB4g4r4a4Unorm, + textureformatB8g8r8a8Unorm, + textureformatBc1RgbaUnorm, + textureformatBc2RgbaUnorm, + textureformatBc3RgbaUnorm, + textureformatBc4RUnorm, + textureformatBc5RgUnorm, + textureformatBc7RgbaUnorm, + textureformatBc6hRgbFloat, + textureformatBc6hRgbUfloat, + textureformatR8Snorm, + textureformatR8g8Snorm, + textureformatR8g8b8a8Snorm, + textureformatR16Snorm, + textureformatR16g16Snorm, + textureformatR16g16b16a16Snorm, + textureformatR16Float, + textureformatR16g16Float, + textureformatR16g16b16a16Float, + textureformatR32Float, + textureformatR32g32Float, + textureformatR32g32b32a32Float, + textureformatR11g11b10Ufloat, + textureformatR8Uint, + textureformatR8g8Uint, + textureformatR8g8b8a8Uint, + textureformatR16Uint, + textureformatR16g16Uint, + textureformatR16g16b16a16Uint, + textureformatR32Uint, + textureformatR32g32Uint, + textureformatR32g32b32a32Uint, + textureformatR8Int, + textureformatR8g8Int, + textureformatR8g8b8a8Int, + textureformatR16Int, + textureformatR16g16Int, + textureformatR16g16b16a16Int, + textureformatR32Int, + textureformatR32g32Int, + textureformatR32g32b32a32Int, + textureformatR8g8b8a8UnormSrgb, + textureformatB8g8r8a8UnormSrgb, + textureformatBc1RgbaUnormSrgb, + textureformatBc2RgbaUnormSrgb, + textureformatBc3RgbaUnormSrgb, + textureformatBc7RgbaUnormSrgb, + textureformatD16Unorm, + textureformatD24Unorm, + textureformatD32Float, + textureformatD24UnormS8Uint, + textureformatD32FloatS8Uint, + textureformatAstc4x4Unorm, + textureformatAstc5x4Unorm, + textureformatAstc5x5Unorm, + textureformatAstc6x5Unorm, + textureformatAstc6x6Unorm, + textureformatAstc8x5Unorm, + textureformatAstc8x6Unorm, + textureformatAstc8x8Unorm, + textureformatAstc10x5Unorm, + textureformatAstc10x6Unorm, + textureformatAstc10x8Unorm, + textureformatAstc10x10Unorm, + textureformatAstc12x10Unorm, + textureformatAstc12x12Unorm, + textureformatAstc4x4UnormSrgb, + textureformatAstc5x4UnormSrgb, + textureformatAstc5x5UnormSrgb, + textureformatAstc6x5UnormSrgb, + textureformatAstc6x6UnormSrgb, + textureformatAstc8x5UnormSrgb, + textureformatAstc8x6UnormSrgb, + textureformatAstc8x8UnormSrgb, + textureformatAstc10x5UnormSrgb, + textureformatAstc10x6UnormSrgb, + textureformatAstc10x8UnormSrgb, + textureformatAstc10x10UnormSrgb, + textureformatAstc12x10UnormSrgb, + textureformatAstc12x12UnormSrgb, + textureformatAstc4x4Float, + textureformatAstc5x4Float, + textureformatAstc5x5Float, + textureformatAstc6x5Float, + textureformatAstc6x6Float, + textureformatAstc8x5Float, + textureformatAstc8x6Float, + textureformatAstc8x8Float, + textureformatAstc10x5Float, + textureformatAstc10x6Float, + textureformatAstc10x8Float, + textureformatAstc10x10Float, + textureformatAstc12x10Float, + textureformatAstc12x12Float, +}; + +pub const GPUTextureType = enum { + texturetype2d, //*< The texture is a 2-dimensional image. */ + texturetype2dArray, //*< The texture is a 2-dimensional array image. */ + texturetype3d, //*< The texture is a 3-dimensional image. */ + texturetypeCube, //*< The texture is a cube image. */ + texturetypeCubeArray, //*< The texture is a cube array image. */ +}; + +pub const GPUSampleCount = enum { + samplecount1, //*< No multisampling. */ + samplecount2, //*< MSAA 2x */ + samplecount4, //*< MSAA 4x */ + samplecount8, //*< MSAA 8x */ +}; + +pub const GPUCubeMapFace = enum { + cubemapfacePositivex, + cubemapfaceNegativex, + cubemapfacePositivey, + cubemapfaceNegativey, + cubemapfacePositivez, + cubemapfaceNegativez, +}; + +pub const GPUTransferBufferUsage = enum { + transferbufferusageUpload, + transferbufferusageDownload, +}; + +pub const GPUShaderStage = enum { + shaderstageVertex, + shaderstageFragment, +}; + +pub const GPUVertexElementFormat = enum { + vertexelementformatInvalid, + vertexelementformatInt, + vertexelementformatInt2, + vertexelementformatInt3, + vertexelementformatInt4, + vertexelementformatUint, + vertexelementformatUint2, + vertexelementformatUint3, + vertexelementformatUint4, + vertexelementformatFloat, + vertexelementformatFloat2, + vertexelementformatFloat3, + vertexelementformatFloat4, + vertexelementformatByte2, + vertexelementformatByte4, + vertexelementformatUbyte2, + vertexelementformatUbyte4, + vertexelementformatByte2Norm, + vertexelementformatByte4Norm, + vertexelementformatUbyte2Norm, + vertexelementformatUbyte4Norm, + vertexelementformatShort2, + vertexelementformatShort4, + vertexelementformatUshort2, + vertexelementformatUshort4, + vertexelementformatShort2Norm, + vertexelementformatShort4Norm, + vertexelementformatUshort2Norm, + vertexelementformatUshort4Norm, + vertexelementformatHalf2, + vertexelementformatHalf4, +}; + +pub const GPUVertexInputRate = enum { + vertexinputrateVertex, //*< Attribute addressing is a function of the vertex index. */ + vertexinputrateInstance, //*< Attribute addressing is a function of the instance index. */ +}; + +pub const GPUFillMode = enum { + fillmodeFill, //*< Polygons will be rendered via rasterization. */ + fillmodeLine, //*< Polygon edges will be drawn as line segments. */ +}; + +pub const GPUCullMode = enum { + cullmodeNone, //*< No triangles are culled. */ + cullmodeFront, //*< Front-facing triangles are culled. */ + cullmodeBack, //*< Back-facing triangles are culled. */ +}; + +pub const GPUFrontFace = enum { + frontfaceCounterClockwise, //*< A triangle with counter-clockwise vertex winding will be considered front-facing. */ + frontfaceClockwise, //*< A triangle with clockwise vertex winding will be considered front-facing. */ +}; + +pub const GPUCompareOp = enum { + compareopInvalid, + compareopNever, //*< The comparison always evaluates false. */ + compareopLess, //*< The comparison evaluates reference < test. */ + compareopEqual, //*< The comparison evaluates reference == test. */ + compareopLessOrEqual, //*< The comparison evaluates reference <= test. */ + compareopGreater, //*< The comparison evaluates reference > test. */ + compareopNotEqual, //*< The comparison evaluates reference != test. */ + compareopGreaterOrEqual, //*< The comparison evalutes reference >= test. */ + compareopAlways, //*< The comparison always evaluates true. */ +}; + +pub const GPUStencilOp = enum { + stencilopInvalid, + stencilopKeep, //*< Keeps the current value. */ + stencilopZero, //*< Sets the value to 0. */ + stencilopReplace, //*< Sets the value to reference. */ + stencilopIncrementAndClamp, //*< Increments the current value and clamps to the maximum value. */ + stencilopDecrementAndClamp, //*< Decrements the current value and clamps to 0. */ + stencilopInvert, //*< Bitwise-inverts the current value. */ + stencilopIncrementAndWrap, //*< Increments the current value and wraps back to 0. */ + stencilopDecrementAndWrap, //*< Decrements the current value and wraps to the maximum value. */ +}; + +pub const GPUBlendOp = enum { + blendopInvalid, + blendopAdd, //*< (source * source_factor) + (destination * destination_factor) */ + blendopSubtract, //*< (source * source_factor) - (destination * destination_factor) */ + blendopReverseSubtract, //*< (destination * destination_factor) - (source * source_factor) */ + blendopMin, //*< min(source + blendopMax //*< max(source, destination) */ +}; + +pub const GPUBlendFactor = enum { + blendfactorInvalid, + blendfactorZero, //*< 0 */ + blendfactorOne, //*< 1 */ + blendfactorSrcColor, //*< source color */ + blendfactorOneMinusSrcColor, //*< 1 - source color */ + blendfactorDstColor, //*< destination color */ + blendfactorOneMinusDstColor, //*< 1 - destination color */ + blendfactorSrcAlpha, //*< source alpha */ + blendfactorOneMinusSrcAlpha, //*< 1 - source alpha */ + blendfactorDstAlpha, //*< destination alpha */ + blendfactorOneMinusDstAlpha, //*< 1 - destination alpha */ + blendfactorConstantColor, //*< blend constant */ + blendfactorOneMinusConstantColor, //*< 1 - blend constant */ + blendfactorSrcAlphaSaturate //*< min(source alpha, 1 - destination alpha) */ +}; + +pub const GPUFilter = enum { + filterNearest, //*< Point filtering. */ + filterLinear, //*< Linear filtering. */ +}; + +pub const GPUSamplerMipmapMode = enum { + samplermipmapmodeNearest, //*< Point filtering. */ + samplermipmapmodeLinear, //*< Linear filtering. */ +}; + +pub const GPUSamplerAddressMode = enum { + sampleraddressmodeRepeat, //*< Specifies that the coordinates will wrap around. */ + sampleraddressmodeMirroredRepeat, //*< Specifies that the coordinates will wrap around mirrored. */ + sampleraddressmodeClampToEdge, //*< Specifies that the coordinates will clamp to the 0-1 range. */ +}; + +pub const GPUPresentMode = enum { + presentmodeVsync, + presentmodeImmediate, + presentmodeMailbox, +}; + +pub const GPUSwapchainComposition = enum { + swapchaincompositionSdr, + swapchaincompositionSdrLinear, + swapchaincompositionHdrExtendedLinear, + swapchaincompositionHdr10St2084, +}; + +pub const FlipMode = enum { + sdlFlipNone, //*< Do not flip */ + sdlFlipHorizontal, //*< flip horizontally */ + sdlFlipVertical, //*< flip vertically */ +}; + +pub const GPUViewport = extern struct { + x: f32, // The left offset of the viewport. + y: f32, // The top offset of the viewport. + w: f32, // The width of the viewport. + h: f32, // The height of the viewport. + min_depth: f32, // The minimum depth of the viewport. + max_depth: f32, // The maximum depth of the viewport. +}; + +pub const GPUTextureTransferInfo = extern struct { + transfer_buffer: *GPUTransferBuffer, // The transfer buffer used in the transfer operation. + offset: u32, // The starting byte of the image data in the transfer buffer. + pixels_per_row: u32, // The number of pixels from one row to the next. + rows_per_layer: u32, // The number of rows from one layer/depth-slice to the next. +}; + +pub const GPUTransferBufferLocation = extern struct { + transfer_buffer: *GPUTransferBuffer, // The transfer buffer used in the transfer operation. + offset: u32, // The starting byte of the buffer data in the transfer buffer. +}; + +pub const GPUTextureLocation = extern struct { + texture: *GPUTexture, // The texture used in the copy operation. + mip_level: u32, // The mip level index of the location. + layer: u32, // The layer index of the location. + x: u32, // The left offset of the location. + y: u32, // The top offset of the location. + z: u32, // The front offset of the location. +}; + +pub const GPUTextureRegion = extern struct { + texture: *GPUTexture, // The texture used in the copy operation. + mip_level: u32, // The mip level index to transfer. + layer: u32, // The layer index to transfer. + x: u32, // The left offset of the region. + y: u32, // The top offset of the region. + z: u32, // The front offset of the region. + w: u32, // The width of the region. + h: u32, // The height of the region. + d: u32, // The depth of the region. +}; + +pub const GPUBlitRegion = extern struct { + texture: *GPUTexture, // The texture. + mip_level: u32, // The mip level index of the region. + layer_or_depth_plane: u32, // The layer index or depth plane of the region. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. + x: u32, // The left offset of the region. + y: u32, // The top offset of the region. + w: u32, // The width of the region. + h: u32, // The height of the region. +}; + +pub const GPUBufferLocation = extern struct { + buffer: *GPUBuffer, // The buffer. + offset: u32, // The starting byte within the buffer. +}; + +pub const GPUBufferRegion = extern struct { + buffer: *GPUBuffer, // The buffer. + offset: u32, // The starting byte within the buffer. + size: u32, // The size in bytes of the region. +}; + +pub const GPUIndirectDrawCommand = extern struct { + num_vertices: u32, // The number of vertices to draw. + num_instances: u32, // The number of instances to draw. + first_vertex: u32, // The index of the first vertex to draw. + first_instance: u32, // The ID of the first instance to draw. +}; + +pub const GPUIndexedIndirectDrawCommand = extern struct { + num_indices: u32, // The number of indices to draw per instance. + num_instances: u32, // The number of instances to draw. + first_index: u32, // The base index within the index buffer. + vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer. + first_instance: u32, // The ID of the first instance to draw. +}; + +pub const GPUIndirectDispatchCommand = extern struct { + groupcount_x: u32, // The number of local workgroups to dispatch in the X dimension. + groupcount_y: u32, // The number of local workgroups to dispatch in the Y dimension. + groupcount_z: u32, // The number of local workgroups to dispatch in the Z dimension. +}; + +pub const GPUSamplerCreateInfo = extern struct { + min_filter: GPUFilter, // The minification filter to apply to lookups. + mag_filter: GPUFilter, // The magnification filter to apply to lookups. + mipmap_mode: GPUSamplerMipmapMode, // The mipmap filter to apply to lookups. + address_mode_u: GPUSamplerAddressMode, // The addressing mode for U coordinates outside [0, 1). + address_mode_v: GPUSamplerAddressMode, // The addressing mode for V coordinates outside [0, 1). + address_mode_w: GPUSamplerAddressMode, // The addressing mode for W coordinates outside [0, 1). + mip_lod_bias: f32, // The bias to be added to mipmap LOD calculation. + max_anisotropy: f32, // The anisotropy value clamp used by the sampler. If enable_anisotropy is false, this is ignored. + compare_op: GPUCompareOp, // The comparison operator to apply to fetched data before filtering. + min_lod: f32, // Clamps the minimum of the computed LOD value. + max_lod: f32, // Clamps the maximum of the computed LOD value. + enable_anisotropy: bool, // true to enable anisotropic filtering. + enable_compare: bool, // true to enable comparison against a reference value during lookups. + padding1: u8, + padding2: u8, + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUVertexBufferDescription = extern struct { + slot: u32, // The binding slot of the vertex buffer. + pitch: u32, // The byte pitch between consecutive elements of the vertex buffer. + input_rate: GPUVertexInputRate, // Whether attribute addressing is a function of the vertex index or instance index. + instance_step_rate: u32, // Reserved for future use. Must be set to 0. +}; + +pub const GPUVertexAttribute = extern struct { + location: u32, // The shader input location index. + buffer_slot: u32, // The binding slot of the associated vertex buffer. + format: GPUVertexElementFormat, // The size and type of the attribute data. + offset: u32, // The byte offset of this attribute relative to the start of the vertex element. +}; + +pub const GPUVertexInputState = extern struct { + vertex_buffer_descriptions: *const GPUVertexBufferDescription, // A pointer to an array of vertex buffer descriptions. + num_vertex_buffers: u32, // The number of vertex buffer descriptions in the above array. + vertex_attributes: *const GPUVertexAttribute, // A pointer to an array of vertex attribute descriptions. + num_vertex_attributes: u32, // The number of vertex attribute descriptions in the above array. +}; + +pub const GPUStencilOpState = extern struct { + fail_op: GPUStencilOp, // The action performed on samples that fail the stencil test. + pass_op: GPUStencilOp, // The action performed on samples that pass the depth and stencil tests. + depth_fail_op: GPUStencilOp, // The action performed on samples that pass the stencil test and fail the depth test. + compare_op: GPUCompareOp, // The comparison operator used in the stencil test. +}; + +pub const GPUColorTargetBlendState = extern struct { + src_color_blendfactor: GPUBlendFactor, // The value to be multiplied by the source RGB value. + dst_color_blendfactor: GPUBlendFactor, // The value to be multiplied by the destination RGB value. + color_blend_op: GPUBlendOp, // The blend operation for the RGB components. + src_alpha_blendfactor: GPUBlendFactor, // The value to be multiplied by the source alpha. + dst_alpha_blendfactor: GPUBlendFactor, // The value to be multiplied by the destination alpha. + alpha_blend_op: GPUBlendOp, // The blend operation for the alpha component. + color_write_mask: GPUColorComponentFlags, // A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false. + enable_blend: bool, // Whether blending is enabled for the color target. + enable_color_write_mask: bool, // Whether the color write mask is enabled. + padding1: u8, + padding2: u8, +}; + +pub const GPUShaderCreateInfo = extern struct { + code_size: usize, // The size in bytes of the code pointed to. + code: *const u8, // A pointer to shader code. + entrypoint: *const i8, // A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. + format: GPUShaderFormat, // The format of the shader code. + stage: GPUShaderStage, // The stage the shader program corresponds to. + num_samplers: u32, // The number of samplers defined in the shader. + num_storage_textures: u32, // The number of storage textures defined in the shader. + num_storage_buffers: u32, // The number of storage buffers defined in the shader. + num_uniform_buffers: u32, // The number of uniform buffers defined in the shader. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUTextureCreateInfo = extern struct { + type: GPUTextureType, // The base dimensionality of the texture. + format: GPUTextureFormat, // The pixel format of the texture. + usage: GPUTextureUsageFlags, // How the texture is intended to be used by the client. + width: u32, // The width of the texture. + height: u32, // The height of the texture. + layer_count_or_depth: u32, // The layer count or depth of the texture. This value is treated as a layer count on 2D array textures, and as a depth value on 3D textures. + num_levels: u32, // The number of mip levels in the texture. + sample_count: GPUSampleCount, // The number of samples per texel. Only applies if the texture is used as a render target. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUBufferCreateInfo = extern struct { + usage: GPUBufferUsageFlags, // How the buffer is intended to be used by the client. + size: u32, // The size in bytes of the buffer. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUTransferBufferCreateInfo = extern struct { + usage: GPUTransferBufferUsage, // How the transfer buffer is intended to be used by the client. + size: u32, // The size in bytes of the transfer buffer. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPURasterizerState = extern struct { + fill_mode: GPUFillMode, // Whether polygons will be filled in or drawn as lines. + cull_mode: GPUCullMode, // The facing direction in which triangles will be culled. + front_face: GPUFrontFace, // The vertex winding that will cause a triangle to be determined as front-facing. + depth_bias_constant_factor: f32, // A scalar factor controlling the depth value added to each fragment. + depth_bias_clamp: f32, // The maximum depth bias of a fragment. + depth_bias_slope_factor: f32, // A scalar factor applied to a fragment's slope in depth calculations. + enable_depth_bias: bool, // true to bias fragment depth values. + enable_depth_clip: bool, // true to enable depth clip, false to enable depth clamp. + padding1: u8, + padding2: u8, +}; + +pub const GPUMultisampleState = extern struct { + sample_count: GPUSampleCount, // The number of samples to be used in rasterization. + sample_mask: u32, // Reserved for future use. Must be set to 0. + enable_mask: bool, // Reserved for future use. Must be set to false. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUDepthStencilState = extern struct { + compare_op: GPUCompareOp, // The comparison operator used for depth testing. + back_stencil_state: GPUStencilOpState, // The stencil op state for back-facing triangles. + front_stencil_state: GPUStencilOpState, // The stencil op state for front-facing triangles. + compare_mask: u8, // Selects the bits of the stencil values participating in the stencil test. + write_mask: u8, // Selects the bits of the stencil values updated by the stencil test. + enable_depth_test: bool, // true enables the depth test. + enable_depth_write: bool, // true enables depth writes. Depth writes are always disabled when enable_depth_test is false. + enable_stencil_test: bool, // true enables the stencil test. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUColorTargetDescription = extern struct { + format: GPUTextureFormat, // The pixel format of the texture to be used as a color target. + blend_state: GPUColorTargetBlendState, // The blend state to be used for the color target. +}; + +pub const GPUGraphicsPipelineTargetInfo = extern struct { + color_target_descriptions: *const GPUColorTargetDescription, // A pointer to an array of color target descriptions. + num_color_targets: u32, // The number of color target descriptions in the above array. + depth_stencil_format: GPUTextureFormat, // The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is false. + has_depth_stencil_target: bool, // true specifies that the pipeline uses a depth-stencil target. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUGraphicsPipelineCreateInfo = extern struct { + vertex_shader: *GPUShader, // The vertex shader used by the graphics pipeline. + fragment_shader: *GPUShader, // The fragment shader used by the graphics pipeline. + vertex_input_state: GPUVertexInputState, // The vertex layout of the graphics pipeline. + primitive_type: GPUPrimitiveType, // The primitive topology of the graphics pipeline. + rasterizer_state: GPURasterizerState, // The rasterizer state of the graphics pipeline. + multisample_state: GPUMultisampleState, // The multisample state of the graphics pipeline. + depth_stencil_state: GPUDepthStencilState, // The depth-stencil state of the graphics pipeline. + target_info: GPUGraphicsPipelineTargetInfo, // Formats and blend modes for the render targets of the graphics pipeline. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUComputePipelineCreateInfo = extern struct { + code_size: usize, // The size in bytes of the compute shader code pointed to. + code: *const u8, // A pointer to compute shader code. + entrypoint: *const i8, // A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. + format: GPUShaderFormat, // The format of the compute shader code. + num_samplers: u32, // The number of samplers defined in the shader. + num_readonly_storage_textures: u32, // The number of readonly storage textures defined in the shader. + num_readonly_storage_buffers: u32, // The number of readonly storage buffers defined in the shader. + num_readwrite_storage_textures: u32, // The number of read-write storage textures defined in the shader. + num_readwrite_storage_buffers: u32, // The number of read-write storage buffers defined in the shader. + num_uniform_buffers: u32, // The number of uniform buffers defined in the shader. + threadcount_x: u32, // The number of threads in the X dimension. This should match the value in the shader. + threadcount_y: u32, // The number of threads in the Y dimension. This should match the value in the shader. + threadcount_z: u32, // The number of threads in the Z dimension. This should match the value in the shader. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUColorTargetInfo = extern struct { + texture: *GPUTexture, // The texture that will be used as a color target by a render pass. + mip_level: u32, // The mip level to use as a color target. + layer_or_depth_plane: u32, // The layer index or depth plane to use as a color target. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. + clear_color: FColor, // The color to clear the color target to at the start of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + load_op: GPULoadOp, // What is done with the contents of the color target at the beginning of the render pass. + store_op: GPUStoreOp, // What is done with the results of the render pass. + resolve_texture: *GPUTexture, // The texture that will receive the results of a multisample resolve operation. Ignored if a RESOLVE* store_op is not used. + resolve_mip_level: u32, // The mip level of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. + resolve_layer: u32, // The layer index of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. + cycle: bool, // true cycles the texture if the texture is bound and load_op is not LOAD + cycle_resolve_texture: bool, // true cycles the resolve texture if the resolve texture is bound. Ignored if a RESOLVE* store_op is not used. + padding1: u8, + padding2: u8, +}; + +pub const GPUDepthStencilTargetInfo = extern struct { + texture: *GPUTexture, // The texture that will be used as the depth stencil target by the render pass. + clear_depth: f32, // The value to clear the depth component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + load_op: GPULoadOp, // What is done with the depth contents at the beginning of the render pass. + store_op: GPUStoreOp, // What is done with the depth results of the render pass. + stencil_load_op: GPULoadOp, // What is done with the stencil contents at the beginning of the render pass. + stencil_store_op: GPUStoreOp, // What is done with the stencil results of the render pass. + cycle: bool, // true cycles the texture if the texture is bound and any load ops are not LOAD + clear_stencil: u8, // The value to clear the stencil component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + padding1: u8, + padding2: u8, +}; + +pub const GPUBlitInfo = extern struct { + destination: GPUBlitRegion, // The destination region for the blit. + load_op: GPULoadOp, // What is done with the contents of the destination before the blit. + clear_color: FColor, // The color to clear the destination region to before the blit. Ignored if load_op is not SDL_GPU_LOADOP_CLEAR. + flip_mode: FlipMode, // The flip mode for the source region. + filter: GPUFilter, // The filter mode used when blitting. + cycle: bool, // true cycles the destination texture if it is already bound. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUBufferBinding = extern struct { + buffer: *GPUBuffer, // The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_VERTEX for SDL_BindGPUVertexBuffers, or SDL_GPU_BUFFERUSAGE_INDEX for SDL_BindGPUIndexBuffer. + offset: u32, // The starting byte of the data to bind in the buffer. +}; + +pub const GPUTextureSamplerBinding = extern struct { + texture: *GPUTexture, // The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. + sampler: *GPUSampler, // The sampler to bind. +}; + +pub const GPUStorageBufferReadWriteBinding = extern struct { + buffer: *GPUBuffer, // The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE. + cycle: bool, // true cycles the buffer if it is already bound. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUStorageTextureReadWriteBinding = extern struct { + texture: *GPUTexture, // The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE or SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE. + mip_level: u32, // The mip level index to bind. + layer: u32, // The layer index to bind. + cycle: bool, // true cycles the texture if it is already bound. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const FColor = extern struct { + r: f32, + g: f32, + b: f32, + a: f32, +}; +