-- vim: syntax=lua -- bgfx interface version(140) typedef "bool" typedef "char" typedef "float" typedef "int8_t" typedef "int32_t" typedef "int64_t" typedef "uint8_t" typedef "uint16_t" typedef "uint32_t" typedef "uint64_t" typedef "uintptr_t" typedef "va_list" typedef "void" typedef "ViewId" typedef "CallbackI" { cname = "callback_interface" } typedef "bx::AllocatorI" { cname = "allocator_interface" } --- Memory release callback. funcptr.ReleaseFn "void" .ptr "void*" --- Pointer to allocated data. .userData "void*" --- User defined data if needed. --- Color RGB/alpha/depth write. When it's not specified write will be disabled. flag.StateWrite { bits = 64, base = 1, section = "State Flags", label = "Write" } .R --- Enable R write. .G --- Enable G write. .B --- Enable B write. .A --- Enable alpha write. .Z (39) --- Enable depth write. .Rgb { "R", "G", "B" } --- Enable RGB write. .Mask { "Rgb", "A", "Z" } --- Write all channels mask. --- Depth test state. When `BGFX_STATE_DEPTH_` is not specified depth test will be disabled. flag.StateDepthTest { bits = 64, shift = 4, range = 4, base = 1, desc = "Depth test state", section = "State Flags", label = "Depth Test" } .Less --- Enable depth test, less. .Lequal --- Enable depth test, less or equal. .Equal --- Enable depth test, equal. .Gequal --- Enable depth test, greater or equal. .Greater --- Enable depth test, greater. .Notequal --- Enable depth test, not equal. .Never --- Enable depth test, never. .Always --- Enable depth test, always. () --- Use BGFX_STATE_BLEND_FUNC(_src, _dst) or BGFX_STATE_BLEND_FUNC_SEPARATE(_srcRGB, _dstRGB, _srcA, _dstA) --- helper macros. flag.StateBlend { bits = 64, shift = 12, range = 16, base = 1, desc = "Blend state", section = "State Flags", label = "Blend Mode" } .Zero --- 0, 0, 0, 0 .One --- 1, 1, 1, 1 .SrcColor --- Rs, Gs, Bs, As .InvSrcColor --- 1-Rs, 1-Gs, 1-Bs, 1-As .SrcAlpha --- As, As, As, As .InvSrcAlpha --- 1-As, 1-As, 1-As, 1-As .DstAlpha --- Ad, Ad, Ad, Ad .InvDstAlpha --- 1-Ad, 1-Ad, 1-Ad ,1-Ad .DstColor --- Rd, Gd, Bd, Ad .InvDstColor --- 1-Rd, 1-Gd, 1-Bd, 1-Ad .SrcAlphaSat --- f, f, f, 1; f = min(As, 1-Ad) .Factor --- Blend factor .InvFactor --- 1-Blend factor () --- Use BGFX_STATE_BLEND_EQUATION(_equation) or BGFX_STATE_BLEND_EQUATION_SEPARATE(_equationRGB, _equationA) --- helper macros. flag.StateBlendEquation { bits = 64, shift = 28, range = 6, base = 0, desc = "Blend equation", section = "State Flags", label = "Blend Equation" } .Add --- Blend add: src + dst. .Sub --- Blend subtract: src - dst. .Revsub --- Blend reverse subtract: dst - src. .Min --- Blend min: min(src, dst). .Max --- Blend max: max(src, dst). () --- Cull state. When `BGFX_STATE_CULL_*` is not specified culling will be disabled. flag.StateCull { bits = 64, shift = 36, range = 2, base = 1, desc = "Culling mode", section = "State Flags", label = "Primitive Culling" } .Cw --- Cull clockwise triangles. .Ccw --- Cull counter-clockwise triangles. () --- Alpha reference value. flag.StateAlphaRef { bits = 64, shift = 40, range = 8, desc = "Alpha reference", "helper" } flag.StatePt { bits = 64, shift = 48, range = 3, base = 1, desc = "Primitive type", section = "State Flags", label = "Primitive Type" } .Tristrip --- Tristrip. .Lines --- Lines. .Linestrip --- Line strip. .Points --- Points. () --- Point size value. flag.StatePointSize { bits = 64, shift = 52, range = 4, desc = "Point size", "helper" } --- Enable MSAA write when writing into MSAA frame buffer. --- This flag is ignored when not writing into MSAA frame buffer. flag.State { bits = 64, range = 64, desc = "State", section = "State Flags", label = "Misc" } .Msaa (57) --- Enable MSAA rasterization. .Lineaa (58) --- Enable line AA rasterization. .ConservativeRaster (59) --- Enable conservative rasterization. .None (0) --- No state. .FrontCcw(40) --- Front counter-clockwise (default is clockwise). .BlendIndependent(35) --- Enable blend independent. .BlendAlphaToCoverage (36) --- Enable alpha to coverage. .Default { "WriteRgb", "WriteA", "WriteZ", "DepthTestLess", "CullCw", "Msaa" } --- Default state is write to RGB, alpha, and depth with depth test less enabled, with clockwise --- culling and MSAA (when writing into MSAA frame buffer, otherwise this flag is ignored). --- Do not use! flag.StateReserved { bits = 64, shift = 61, range = 3 } --- Set stencil ref value. flag.StencilFuncRef { bits = 32, shift = 0, range = 8, "helper" } --- Set stencil rmask value. flag.StencilFuncRmask { bits = 32, shift = 8, range = 8, "helper" } flag.Stencil { bits = 32, const } .None (0x00000000) .Mask (0xffffffff) .Default (0x00000000) flag.StencilTest { bits = 32, shift = 16, range = 4, base = 1, desc = "Stencil test", section = "Stencil Flags" } .Less --- Enable stencil test, less. .Lequal --- Enable stencil test, less or equal. .Equal --- Enable stencil test, equal. .Gequal --- Enable stencil test, greater or equal. .Greater --- Enable stencil test, greater. .Notequal --- Enable stencil test, not equal. .Never --- Enable stencil test, never. .Always --- Enable stencil test, always. () flag.StencilOpFailS { bits = 32, shift = 20, range = 4, base = 0, desc = "Stencil operation fail" } .Zero --- Zero. .Keep --- Keep. .Replace --- Replace. .Incr --- Increment and wrap. .Incrsat --- Increment and clamp. .Decr --- Decrement and wrap. .Decrsat --- Decrement and clamp. .Invert --- Invert. () flag.StencilOpFailZ { bits = 32, shift = 24, range = 4, base = 0, desc = "Stencil operation depth fail" } .Zero --- Zero. .Keep --- Keep. .Replace --- Replace. .Incr --- Increment and wrap. .Incrsat --- Increment and clamp. .Decr --- Decrement and wrap. .Decrsat --- Decrement and clamp. .Invert --- Invert. () flag.StencilOpPassZ { bits = 32, shift = 28, range = 4, base = 0, desc = "Stencil operation depth pass" } .Zero --- Zero. .Keep --- Keep. .Replace --- Replace. .Incr --- Increment and wrap. .Incrsat --- Increment and clamp. .Decr --- Decrement and wrap. .Decrsat --- Decrement and clamp. .Invert --- Invert. () flag.Clear { bits = 16 } .None --- No clear flags. .Color --- Clear color. .Depth --- Clear depth. .Stencil --- Clear stencil. .DiscardColor_0 --- Discard frame buffer attachment 0. .DiscardColor_1 --- Discard frame buffer attachment 1. .DiscardColor_2 --- Discard frame buffer attachment 2. .DiscardColor_3 --- Discard frame buffer attachment 3. .DiscardColor_4 --- Discard frame buffer attachment 4. .DiscardColor_5 --- Discard frame buffer attachment 5. .DiscardColor_6 --- Discard frame buffer attachment 6. .DiscardColor_7 --- Discard frame buffer attachment 7. .DiscardDepth --- Discard frame buffer depth attachment. .DiscardStencil --- Discard frame buffer stencil attachment. .DiscardColorMask { "DiscardColor_0", "DiscardColor_1", "DiscardColor_2", "DiscardColor_3", "DiscardColor_4", "DiscardColor_5", "DiscardColor_6", "DiscardColor_7" } .DiscardMask { "DiscardColorMask", "DiscardDepth", "DiscardStencil" } --- Rendering state discard. When state is preserved in submit, rendering states can be discarded --- on a finer grain. flag.Discard { bits = 8, const, desc = "Discard flags" } .None (0x00) --- Preserve everything. .Bindings (0x01) --- Discard texture sampler and buffer bindings. .IndexBuffer (0x02) --- Discard index buffer. .InstanceData (0x04) --- Discard instance data. .State (0x08) --- Discard state and uniform bindings. .Transform (0x10) --- Discard transform. .VertexStreams (0x20) --- Discard vertex streams. .All (0xff) --- Discard all states. () flag.Debug { bits = 32, section = "Debug Flags" } .None --- No debug. .Wireframe --- Enable wireframe for all primitives. .Ifh --- Enable infinitely fast hardware test. No draw calls will be submitted to driver. --- It's useful when profiling to quickly assess bottleneck between CPU and GPU. .Stats --- Enable statistics display. .Text --- Enable debug text display. .Profiler --- Enable profiler. This causes per-view statistics to be collected, available through `bgfx::Stats::ViewStats`. This is unrelated to the profiler functions in `bgfx::CallbackI`. () flag.BufferComputeFormat { bits = 16, shift = 0, range = 4, base = 1 } ._8x1 --- 1 x 8-bit value ._8x2 --- 2 x 8-bit values ._8x4 --- 4 x 8-bit values ._16x1 --- 1 x 16-bit value ._16x2 --- 2 x 16-bit values ._16x4 --- 4 x 16-bit values ._32x1 --- 1 x 32-bit value ._32x2 --- 2 x 32-bit values ._32x4 --- 4 x 32-bit values () flag.BufferComputeType { bits = 16, shift = 4, range = 2, base = 1 } .Int --- Type `int`. .Uint --- Type `uint`. .Float --- Type `float`. () flag.Buffer { bits = 16, base = 8 } .None(0) .ComputeRead --- Buffer will be read by shader. .ComputeWrite --- Buffer will be used for writing. .DrawIndirect --- Buffer will be used for storing draw indirect commands. .AllowResize --- Allow dynamic index/vertex buffer resize during update. .Index32 --- Index buffer contains 32-bit indices. .ComputeReadWrite { "ComputeRead", "ComputeWrite" } () flag.Texture { bits = 64, section = "Textures" } .None (0) .MsaaSample (36) --- Texture will be used for MSAA sampling. .Rt (37) --- Render target no MSAA. .ComputeWrite (45) --- Texture will be used for compute write. .Srgb (46) --- Sample texture as sRGB. .BlitDst (47) --- Texture will be used as blit destination. .ReadBack (48) --- Texture will be used for read back from GPU. .ExternalShared (49) --- Texture is shared with other device or other process. () flag.TextureRtMsaa { bits = 64, shift = 36, range = 3, base = 2 } .X2 --- Render target MSAAx2 mode. .X4 --- Render target MSAAx4 mode. .X8 --- Render target MSAAx8 mode. .X16 --- Render target MSAAx16 mode. () flag.TextureRt { bits = 64, shift = 36, range = 4, section = "Textures" } .WriteOnly (9) --- Render target will be used for writing --- Sampler flags. flag.SamplerU { bits = 32, shift = 0, range = 2, base = 1 } .Mirror --- Wrap U mode: Mirror .Clamp --- Wrap U mode: Clamp .Border --- Wrap U mode: Border () flag.SamplerV { bits = 32, shift = 2, range = 2, base = 1 } .Mirror --- Wrap V mode: Mirror .Clamp --- Wrap V mode: Clamp .Border --- Wrap V mode: Border () flag.SamplerW { bits = 32, shift = 4, range = 2, base = 1 } .Mirror --- Wrap W mode: Mirror .Clamp --- Wrap W mode: Clamp .Border --- Wrap W mode: Border () flag.SamplerMin { bits = 32, shift = 6, range = 2, base = 1 } .Point --- Min sampling mode: Point .Anisotropic --- Min sampling mode: Anisotropic () flag.SamplerMag { bits = 32, shift = 8, range = 2, base = 1 } .Point --- Mag sampling mode: Point .Anisotropic --- Mag sampling mode: Anisotropic () flag.SamplerMip { bits = 32, shift = 10, range = 1, base = 1 } .Point --- Mip sampling mode: Point () flag.SamplerCompare { bits = 32, shift = 16, range = 4, base = 1 } .Less --- Compare when sampling depth texture: less. .Lequal --- Compare when sampling depth texture: less or equal. .Equal --- Compare when sampling depth texture: equal. .Gequal --- Compare when sampling depth texture: greater or equal. .Greater --- Compare when sampling depth texture: greater. .Notequal --- Compare when sampling depth texture: not equal. .Never --- Compare when sampling depth texture: never. .Always --- Compare when sampling depth texture: always. () flag.SamplerBorderColor { bits = 32, shift = 24, range = 4, "helper" } flag.SamplerReserved { bits = 32, shift = 28, range = 4 } flag.Sampler { bits = 32 } .None .SampleStencil (21) --- Sample stencil instead of depth. .Point { "MinPoint", "MagPoint", "MipPoint" } .UvwMirror { "UMirror", "VMirror", "WMirror" } .UvwClamp { "UClamp", "VClamp", "WClamp" } .UvwBorder { "UBorder", "VBorder", "WBorder" } .BitsMask { "UMask", "VMask", "WMask", "MinMask", "MagMask", "MipMask", "CompareMask" } () flag.ResetMsaa { bits = 32, shift = 4, range = 3, base = 1 } .X2 --- Enable 2x MSAA. .X4 --- Enable 4x MSAA. .X8 --- Enable 8x MSAA. .X16 --- Enable 16x MSAA. () flag.Reset { bits = 32, section = "Reset" } .None ( 0) --- No reset flags. .Fullscreen ( 1) --- Not supported yet. .Vsync ( 8) --- Enable V-Sync. .Maxanisotropy ( 9) --- Turn on/off max anisotropy. .Capture (10) --- Begin screen capture. .FlushAfterRender (14) --- Flush rendering after submitting to GPU. .FlipAfterRender (15) --- This flag specifies where flip occurs. Default behaviour is that flip occurs --- before rendering new frame. This flag only has effect when `BGFX_CONFIG_MULTITHREADED=0`. .SrgbBackbuffer (16) --- Enable sRGB backbuffer. .Hdr10 (17) --- Enable HDR10 rendering. .Hidpi (18) --- Enable HiDPI rendering. .DepthClamp (19) --- Enable depth clamp. .Suspend (20) --- Suspend rendering. .TransparentBackbuffer (21) --- Transparent backbuffer. Availability depends on: `BGFX_CAPS_TRANSPARENT_BACKBUFFER`. () flag.ResetFullscreen { bits = 32, shift = 0, range = 1, base = 1 } () flag.ResetReserved { bits = 32, shift = 31, range = 1, desc = "Internal" } flag.Caps { bits = 64, base = 1, name = "Caps", section = "Available Caps" } .AlphaToCoverage --- Alpha to coverage is supported. .BlendIndependent --- Blend independent is supported. .Compute --- Compute shaders are supported. .ConservativeRaster --- Conservative rasterization is supported. .DrawIndirect --- Draw indirect is supported. .DrawIndirectCount --- Draw indirect with indirect count is supported. .FragmentDepth --- Fragment depth is available in fragment shader. .FragmentOrdering --- Fragment ordering is available in fragment shader. .GraphicsDebugger --- Graphics debugger is present. .Hdr10 --- HDR10 rendering is supported. .Hidpi --- HiDPI rendering is supported. .ImageRw --- Image Read/Write is supported. .Index32 --- 32-bit indices are supported. .Instancing --- Instancing is supported. .OcclusionQuery --- Occlusion query is supported. .PrimitiveId --- PrimitiveID is available in fragment shader. .RendererMultithreaded --- Renderer is on separate thread. .SwapChain --- Multiple windows are supported. .TextureBlit --- Texture blit is supported. .TextureCompareLequal --- Texture compare less equal mode is supported. .TextureCompareReserved .TextureCubeArray --- Cubemap texture array is supported. .TextureDirectAccess --- CPU direct access to GPU texture memory. .TextureExternal --- External texture is supported. .TextureExternalShared --- External shared texture is supported. .TextureReadBack --- Read-back texture is supported. .Texture_2dArray --- 2D texture array is supported. .Texture_3d --- 3D textures are supported. .TransparentBackbuffer --- Transparent back buffer supported. .VariableRateShading --- Variable Rate Shading .VertexAttribHalf --- Vertex attribute half-float is supported. .VertexAttribUint10 --- Vertex attribute 10_10_10_2 is supported. .VertexId --- Rendering with VertexID only is supported. .ViewportLayerArray --- Viewport layer is available in vertex shader. .TextureCompareAll --- All texture compare modes are supported. { "TextureCompareReserved", "TextureCompareLequal" } () flag.CapsFormat { bits = 32 } .TextureNone --- Texture format is not supported. .Texture_2d --- Texture format is supported. .Texture_2dSrgb --- Texture as sRGB format is supported. .Texture_2dEmulated --- Texture format is emulated. .Texture_3d --- Texture format is supported. .Texture_3dSrgb --- Texture as sRGB format is supported. .Texture_3dEmulated --- Texture format is emulated. .TextureCube --- Texture format is supported. .TextureCubeSrgb --- Texture as sRGB format is supported. .TextureCubeEmulated --- Texture format is emulated. .TextureVertex --- Texture format can be used from vertex shader. .TextureImageRead --- Texture format can be used as image and read from. .TextureImageWrite --- Texture format can be used as image and written to. .TextureFramebuffer --- Texture format can be used as frame buffer. .TextureFramebufferMsaa --- Texture format can be used as MSAA frame buffer. .TextureMsaa --- Texture can be sampled as MSAA. .TextureMipAutogen --- Texture format supports auto-generated mips. .TextureBackbuffer --- Texture format can be used as back buffer format. () flag.Resolve { bits = 8 } .None --- No resolve flags. .AutoGenMips --- Auto-generate mip maps on resolve. () flag.PciId { bits = 16, const, section = "Initialization and Shutdown" } .None (0x0000) --- Autoselect adapter. .SoftwareRasterizer (0x0001) --- Software rasterizer. .Amd (0x1002) --- AMD adapter. .Apple (0x106b) --- Apple adapter. .Intel (0x8086) --- Intel adapter. .Nvidia (0x10de) --- nVidia adapter. .Microsoft (0x1414) --- Microsoft adapter. .Arm (0x13b5) --- ARM adapter. () flag.CubeMap { bits = 8, const } .PositiveX (0x00) --- Cubemap +x. .NegativeX (0x01) --- Cubemap -x. .PositiveY (0x02) --- Cubemap +y. .NegativeY (0x03) --- Cubemap -y. .PositiveZ (0x04) --- Cubemap +z. .NegativeZ (0x05) --- Cubemap -z. () flag.Frame { bits = 8, section = "Frame" } .None --- No frame flags. .DebugCapture --- Capture frame with graphics debugger. .Discard --- Discard all draw calls. () --- Fatal error enum. enum.Fatal { underscore, comment = "" } .DebugCheck .InvalidShader .UnableToInitialize .UnableToCreateTexture .DeviceLost () --- Renderer backend type enum. enum.RendererType { comment = "Renderer types:", section = "Renderer" } .Noop --- No rendering. .Agc --- AGC .Direct3D11 --- Direct3D 11.0 .Direct3D12 --- Direct3D 12.0 .Gnm --- GNM .Metal --- Metal .Nvn --- NVN .OpenGLES --- OpenGL ES 2.0+ .OpenGL --- OpenGL 2.1+ .Vulkan --- Vulkan .WebGPU --- WebGPU () --- Access mode enum. enum.Access { comment = "Access:", section = "Compute/Buffers" } .Read --- Read. .Write --- Write. .ReadWrite --- Read and write. () --- Vertex attribute enum. enum.Attrib { comment = "Corresponds to vertex shader attribute.", section = "Vertex Buffers" } .Position --- a_position .Normal --- a_normal .Tangent --- a_tangent .Bitangent --- a_bitangent .Color0 --- a_color0 .Color1 --- a_color1 .Color2 --- a_color2 .Color3 --- a_color3 .Indices --- a_indices .Weight --- a_weight .TexCoord0 --- a_texcoord0 .TexCoord1 --- a_texcoord1 .TexCoord2 --- a_texcoord2 .TexCoord3 --- a_texcoord3 .TexCoord4 --- a_texcoord4 .TexCoord5 --- a_texcoord5 .TexCoord6 --- a_texcoord6 .TexCoord7 --- a_texcoord7 () --- Vertex attribute type enum. enum.AttribType { comment = "Attribute types:", section = "Vertex Buffers" } .Uint8 --- Uint8 .Uint10 --- Uint10, availability depends on: `BGFX_CAPS_VERTEX_ATTRIB_UINT10`. .Int16 --- Int16 .Half --- Half, availability depends on: `BGFX_CAPS_VERTEX_ATTRIB_HALF`. .Float --- Float () --- Texture format enum. --- --- Notation: --- --- RGBA16S --- ^ ^ ^ --- | | +-- [ ]Unorm --- | | [F]loat --- | | [S]norm --- | | [I]nt --- | | [U]int --- | +---- Number of bits per component --- +-------- Components --- --- @attention Availability depends on Caps (see: formats). enum.TextureFormat { comment = "Texture formats:", section = "Textures" } .BC1 --- Block Compression 1. 5-bit R, 6-bit G, 5-bit B, 1-bit A. 4 BPP. .BC2 --- Block Compression 2. 5-bit R, 6-bit G, 5-bit B, 4-bit explicit A. 8 BPP. .BC3 --- Block Compression 3. 5-bit R, 6-bit G, 5-bit B, 8-bit interpolated A. 8 BPP. .BC4 --- Block Compression 4. Single 8-bit red channel, unsigned normalized. 4 BPP. .BC5 --- Block Compression 5. Two 8-bit channels (RG), unsigned normalized. 8 BPP. .BC6H --- Block Compression 6H. Three 16-bit floating-point channels (RGB), HDR. 8 BPP. .BC7 --- RGB 4-7 bits per color channel, 0-8 bits alpha. Block Compression 7. High-quality RGBA, 4-7 bits per color, 0-8 bits alpha. 8 BPP. .ETC1 --- Ericsson Texture Compression 1. 8-bit per channel RGB. 4 BPP. .ETC2 --- Ericsson Texture Compression 2. 8-bit per channel RGB. 4 BPP. .ETC2A --- Ericsson Texture Compression 2 with full alpha. 8-bit per channel RGBA. 8 BPP. .ETC2A1 --- Ericsson Texture Compression 2 with 1-bit punch-through alpha. 4 BPP. .EACR11 --- ETC2 Alpha Compression, single 11-bit red channel, unsigned normalized. 4 BPP. .EACR11S --- ETC2 Alpha Compression, single 11-bit red channel, signed normalized. 4 BPP. .EACRG11 --- ETC2 Alpha Compression, two 11-bit channels (RG), unsigned normalized. 8 BPP. .EACRG11S --- ETC2 Alpha Compression, two 11-bit channels (RG), signed normalized. 8 BPP. .PTC12 --- PowerVR Texture Compression v1. 3-channel RGB. 2 BPP. .PTC14 --- PowerVR Texture Compression v1. 3-channel RGB. 4 BPP. .PTC12A --- PowerVR Texture Compression v1. 4-channel RGBA. 2 BPP. .PTC14A --- PowerVR Texture Compression v1. 4-channel RGBA. 4 BPP. .PTC22 --- PowerVR Texture Compression v2. 4-channel RGBA. 2 BPP. .PTC24 --- PowerVR Texture Compression v2. 4-channel RGBA. 4 BPP. .ATC --- AMD Texture Compression. 3-channel RGB. 4 BPP. .ATCE --- AMD Texture Compression with explicit alpha. 4-channel RGBA. 8 BPP. .ATCI --- AMD Texture Compression with interpolated alpha. 4-channel RGBA. 8 BPP. .ASTC4x4 --- Adaptive Scalable Texture Compression, 4x4 block, RGBA. 8.00 BPP. .ASTC5x4 --- Adaptive Scalable Texture Compression, 5x4 block, RGBA. 6.40 BPP. .ASTC5x5 --- Adaptive Scalable Texture Compression, 5x5 block, RGBA. 5.12 BPP. .ASTC6x5 --- Adaptive Scalable Texture Compression, 6x5 block, RGBA. 4.27 BPP. .ASTC6x6 --- Adaptive Scalable Texture Compression, 6x6 block, RGBA. 3.56 BPP. .ASTC8x5 --- Adaptive Scalable Texture Compression, 8x5 block, RGBA. 3.20 BPP. .ASTC8x6 --- Adaptive Scalable Texture Compression, 8x6 block, RGBA. 2.67 BPP. .ASTC8x8 --- Adaptive Scalable Texture Compression, 8x8 block, RGBA. 2.00 BPP. .ASTC10x5 --- Adaptive Scalable Texture Compression, 10x5 block, RGBA. 2.56 BPP. .ASTC10x6 --- Adaptive Scalable Texture Compression, 10x6 block, RGBA. 2.13 BPP. .ASTC10x8 --- Adaptive Scalable Texture Compression, 10x8 block, RGBA. 1.60 BPP. .ASTC10x10 --- Adaptive Scalable Texture Compression, 10x10 block, RGBA. 1.28 BPP. .ASTC12x10 --- Adaptive Scalable Texture Compression, 12x10 block, RGBA. 1.07 BPP. .ASTC12x12 --- Adaptive Scalable Texture Compression, 12x12 block, RGBA. 0.89 BPP. .Unknown --- Compressed formats above. .R1 --- 1-bit single-channel red. Monochrome, 1-bit per pixel. 1 BPP. .A8 --- 8-bit single-channel alpha, unsigned normalized. 8 BPP. .R8 --- 8-bit single-channel red, unsigned normalized. 8 BPP. .R8I --- 8-bit single-channel red, signed integer. 8 BPP. .R8U --- 8-bit single-channel red, unsigned integer. 8 BPP. .R8S --- 8-bit single-channel red, signed normalized. 8 BPP. .R16 --- 16-bit single-channel red, unsigned normalized. 16 BPP. .R16I --- 16-bit single-channel red, signed integer. 16 BPP. .R16U --- 16-bit single-channel red, unsigned integer. 16 BPP. .R16F --- 16-bit single-channel red, half-precision floating point. 16 BPP. .R16S --- 16-bit single-channel red, signed normalized. 16 BPP. .R32I --- 32-bit single-channel red, signed integer. 32 BPP. .R32U --- 32-bit single-channel red, unsigned integer. 32 BPP. .R32F --- 32-bit single-channel red, full-precision floating point. 32 BPP. .RG8 --- Two 8-bit channels (red, green), unsigned normalized. 16 BPP. .RG8I --- Two 8-bit channels (red, green), signed integer. 16 BPP. .RG8U --- Two 8-bit channels (red, green), unsigned integer. 16 BPP. .RG8S --- Two 8-bit channels (red, green), signed normalized. 16 BPP. .RG16 --- Two 16-bit channels (red, green), unsigned normalized. 32 BPP. .RG16I --- Two 16-bit channels (red, green), signed integer. 32 BPP. .RG16U --- Two 16-bit channels (red, green), unsigned integer. 32 BPP. .RG16F --- Two 16-bit channels (red, green), half-precision floating point. 32 BPP. .RG16S --- Two 16-bit channels (red, green), signed normalized. 32 BPP. .RG32I --- Two 32-bit channels (red, green), signed integer. 64 BPP. .RG32U --- Two 32-bit channels (red, green), unsigned integer. 64 BPP. .RG32F --- Two 32-bit channels (red, green), full-precision floating point. 64 BPP. .RGB8 --- Three 8-bit channels (red, green, blue), unsigned normalized. 24 BPP. .RGB8I --- Three 8-bit channels (red, green, blue), signed integer. 24 BPP. .RGB8U --- Three 8-bit channels (red, green, blue), unsigned integer. 24 BPP. .RGB8S --- Three 8-bit channels (red, green, blue), signed normalized. 24 BPP. .RGB9E5F --- Shared-exponent RGB. 9 bits per RGB channel with a shared 5-bit exponent, floating point. 32 BPP. .BGRA8 --- Four 8-bit channels (blue, green, red, alpha), unsigned normalized. BGRA byte order. 32 BPP. .RGBA8 --- Four 8-bit channels (red, green, blue, alpha), unsigned normalized. 32 BPP. .RGBA8I --- Four 8-bit channels (red, green, blue, alpha), signed integer. 32 BPP. .RGBA8U --- Four 8-bit channels (red, green, blue, alpha), unsigned integer. 32 BPP. .RGBA8S --- Four 8-bit channels (red, green, blue, alpha), signed normalized. 32 BPP. .RGBA16 --- Four 16-bit channels (red, green, blue, alpha), unsigned normalized. 64 BPP. .RGBA16I --- Four 16-bit channels (red, green, blue, alpha), signed integer. 64 BPP. .RGBA16U --- Four 16-bit channels (red, green, blue, alpha), unsigned integer. 64 BPP. .RGBA16F --- Four 16-bit channels (red, green, blue, alpha), half-precision floating point. 64 BPP. .RGBA16S --- Four 16-bit channels (red, green, blue, alpha), signed normalized. 64 BPP. .RGBA32I --- Four 32-bit channels (red, green, blue, alpha), signed integer. 128 BPP. .RGBA32U --- Four 32-bit channels (red, green, blue, alpha), unsigned integer. 128 BPP. .RGBA32F --- Four 32-bit channels (red, green, blue, alpha), full-precision floating point. 128 BPP. .B5G6R5 --- Packed 16-bit, 5-bit blue, 6-bit green, 5-bit red. BGR byte order, unsigned normalized. 16 BPP. .R5G6B5 --- Packed 16-bit, 5-bit red, 6-bit green, 5-bit blue. RGB byte order, unsigned normalized. 16 BPP. .BGRA4 --- Packed 16-bit, 4-bit per channel (blue, green, red, alpha). BGRA byte order, unsigned normalized. 16 BPP. .RGBA4 --- Packed 16-bit, 4-bit per channel (red, green, blue, alpha), unsigned normalized. 16 BPP. .BGR5A1 --- Packed 16-bit, 5-bit blue, 5-bit green, 5-bit red, 1-bit alpha. BGRA byte order, unsigned normalized. 16 BPP. .RGB5A1 --- Packed 16-bit, 5-bit red, 5-bit green, 5-bit blue, 1-bit alpha, unsigned normalized. 16 BPP. .RGB10A2 --- Packed 32-bit, 10-bit red, 10-bit green, 10-bit blue, 2-bit alpha, unsigned normalized. 32 BPP. .RG11B10F --- Packed 32-bit, 11-bit red, 11-bit green, 10-bit blue, unsigned floating point. No alpha. 32 BPP. .UnknownDepth --- Depth formats below. .D16 --- 16-bit depth, unsigned normalized. 16 BPP. .D24 --- 24-bit depth, unsigned normalized (stored as 32-bit with 8 bits unused). 32 BPP. .D24S8 --- 24-bit depth, unsigned normalized, with 8-bit stencil. 32 BPP. .D32 --- 32-bit depth, unsigned normalized. 32 BPP. .D16F --- 16-bit depth, floating point. 16 BPP. .D24F --- 24-bit depth, floating point (stored as 32-bit). 32 BPP. .D32F --- 32-bit depth, floating point. 32 BPP. .D0S8 --- 8-bit stencil only, no depth. 8 BPP. () --- Uniform type enum. enum.UniformType { comment = "Uniform types:", section = "Uniforms" } .Sampler --- Sampler. .End --- Reserved, do not use. .Vec4 --- 4 floats vector. .Mat3 --- 3x3 matrix. .Mat4 --- 4x4 matrix. () --- Uniform frequency enum. enum.UniformFreq { comment = "Uniform frequency:", section = "Uniforms" } .Draw --- Changing per draw call. .View --- Changing per view. .Frame --- Changing per frame. () --- Backbuffer ratio enum. enum.BackbufferRatio { comment = "Backbuffer ratios:" } .Equal --- Equal to backbuffer. .Half --- One half size of backbuffer. .Quarter --- One quarter size of backbuffer. .Eighth --- One eighth size of backbuffer. .Sixteenth --- One sixteenth size of backbuffer. .Double --- Double size of backbuffer. () --- Occlusion query result. enum.OcclusionQueryResult { comment = "Occlusion query results:", section = "Occlusion Query" } .Invisible --- Query failed test. .Visible --- Query passed test. .NoResult --- Query result is not available yet. () --- Primitive topology. enum.Topology { underscore, comment = "Primitive topology:" } .TriList --- Triangle list. .TriStrip --- Triangle strip. .LineList --- Line list. .LineStrip --- Line strip. .PointList --- Point list. () --- Topology conversion function. enum.TopologyConvert { underscore, comment = "Topology conversion functions:", section = "Miscellaneous" } .TriListFlipWinding --- Flip winding order of triangle list. .TriStripFlipWinding --- Flip winding order of triangle strip. .TriListToLineList --- Convert triangle list to line list. .TriStripToTriList --- Convert triangle strip to triangle list. .LineStripToLineList --- Convert line strip to line list. () --- Topology sort order. enum.TopologySort { underscore, comment = "Topology sort order:", section = "Miscellaneous" } .DirectionFrontToBackMin .DirectionFrontToBackAvg .DirectionFrontToBackMax .DirectionBackToFrontMin .DirectionBackToFrontAvg .DirectionBackToFrontMax .DistanceFrontToBackMin .DistanceFrontToBackAvg .DistanceFrontToBackMax .DistanceBackToFrontMin .DistanceBackToFrontAvg .DistanceBackToFrontMax () --- View mode sets draw call sort order. enum.ViewMode { underscore, comment = "View modes:", section = "Views" } .Default --- Default sort order. .Sequential --- Sort in the same order in which submit calls were called. .DepthAscending --- Sort draw call depth in ascending order. .DepthDescending --- Sort draw call depth in descending order. () --- Shading Rate. enum.ShadingRate { underscore, comment = "Shading rate:", section = "Views" } .Rate1x1 --- 1x1 .Rate1x2 --- 1x2 .Rate2x1 --- 2x1 .Rate2x2 --- 2x2 .Rate2x4 --- 2x4 .Rate4x2 --- 4x2 .Rate4x4 --- 4x4 () --- Native window handle type. enum.NativeWindowHandleType { underscore, comment = "Native Window handle type:" } .Default --- Platform default handle type (X11 on Linux). .Wayland --- Wayland. () --- Render frame enum. enum.RenderFrame { underscore, comment = "", section = "Platform specific" } .NoContext --- Renderer context is not created yet. .Render --- Renderer context is created and rendering. .Timeout --- Renderer context wait for main thread signal timed out without rendering. .Exiting --- Renderer context is getting destroyed. () --- GPU info. struct.GPU { namespace = "Caps" } .vendorId "uint16_t" --- Vendor PCI id. See `BGFX_PCI_ID_*`. .deviceId "uint16_t" --- Device id. --- Renderer runtime limits. struct.Limits { namespace = "Caps" } .maxDrawCalls "uint32_t" --- Maximum number of draw calls. .maxBlits "uint32_t" --- Maximum number of blit calls. .maxTextureSize "uint32_t" --- Maximum texture size. .maxTextureLayers "uint32_t" --- Maximum texture layers. .maxViews "uint32_t" --- Maximum number of views. .maxFrameBuffers "uint32_t" --- Maximum number of frame buffer handles. .maxFBAttachments "uint32_t" --- Maximum number of frame buffer attachments. .maxPrograms "uint32_t" --- Maximum number of program handles. .maxShaders "uint32_t" --- Maximum number of shader handles. .maxTextures "uint32_t" --- Maximum number of texture handles. .maxTextureSamplers "uint32_t" --- Maximum number of texture samplers. .maxComputeBindings "uint32_t" --- Maximum number of compute bindings. .maxVertexLayouts "uint32_t" --- Maximum number of vertex format layouts. .maxVertexStreams "uint32_t" --- Maximum number of vertex streams. .maxIndexBuffers "uint32_t" --- Maximum number of index buffer handles. .maxVertexBuffers "uint32_t" --- Maximum number of vertex buffer handles. .maxDynamicIndexBuffers "uint32_t" --- Maximum number of dynamic index buffer handles. .maxDynamicVertexBuffers "uint32_t" --- Maximum number of dynamic vertex buffer handles. .maxUniforms "uint32_t" --- Maximum number of uniform handles. .maxOcclusionQueries "uint32_t" --- Maximum number of occlusion query handles. .maxEncoders "uint32_t" --- Maximum number of encoder threads. .minResourceCbSize "uint32_t" --- Minimum resource command buffer size. .maxTransientVbSize "uint32_t" --- Maximum transient vertex buffer size. .maxTransientIbSize "uint32_t" --- Maximum transient index buffer size. .minUniformBufferSize "uint32_t" --- Mimimum uniform buffer size. --- Renderer capabilities. struct.Caps { section = "Capabilities" } .rendererType "RendererType::Enum" --- Renderer backend type. See: `bgfx::RendererType` .supported "uint64_t" --- Supported functionality. --- @attention See `BGFX_CAPS_*` flags at https://bkaradzic.github.io/bgfx/bgfx.html#available-caps .vendorId "uint16_t" --- Selected GPU vendor PCI id. .deviceId "uint16_t" --- Selected GPU device id. .homogeneousDepth "bool" --- True when NDC depth is in [-1, 1] range, otherwise its [0, 1]. .originBottomLeft "bool" --- True when NDC origin is at bottom left. .numGPUs "uint8_t" --- Number of enumerated GPUs. .gpu "GPU[4]" --- Enumerated GPUs. .limits "Limits" --- Renderer runtime limits. .formats "uint32_t[TextureFormat::Count]" --- Supported texture format capabilities flags: --- - `BGFX_CAPS_FORMAT_TEXTURE_NONE` - Texture format is not supported. --- - `BGFX_CAPS_FORMAT_TEXTURE_2D` - Texture format is supported. --- - `BGFX_CAPS_FORMAT_TEXTURE_2D_SRGB` - Texture as sRGB format is supported. --- - `BGFX_CAPS_FORMAT_TEXTURE_2D_EMULATED` - Texture format is emulated. --- - `BGFX_CAPS_FORMAT_TEXTURE_3D` - Texture format is supported. --- - `BGFX_CAPS_FORMAT_TEXTURE_3D_SRGB` - Texture as sRGB format is supported. --- - `BGFX_CAPS_FORMAT_TEXTURE_3D_EMULATED` - Texture format is emulated. --- - `BGFX_CAPS_FORMAT_TEXTURE_CUBE` - Texture format is supported. --- - `BGFX_CAPS_FORMAT_TEXTURE_CUBE_SRGB` - Texture as sRGB format is supported. --- - `BGFX_CAPS_FORMAT_TEXTURE_CUBE_EMULATED` - Texture format is emulated. --- - `BGFX_CAPS_FORMAT_TEXTURE_VERTEX` - Texture format can be used from vertex shader. --- - `BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ` - Texture format can be used as image --- and read from. --- - `BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE` - Texture format can be used as image --- and written to. --- - `BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER` - Texture format can be used as frame --- buffer. --- - `BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER_MSAA` - Texture format can be used as MSAA --- frame buffer. --- - `BGFX_CAPS_FORMAT_TEXTURE_MSAA` - Texture can be sampled as MSAA. --- - `BGFX_CAPS_FORMAT_TEXTURE_MIP_AUTOGEN` - Texture format supports auto-generated --- mips. --- - `BGFX_CAPS_FORMAT_TEXTURE_BACKBUFFER` - Texture format can be used as back buffer format. --- Internal data. struct.InternalData { section = "Platform specific" } .caps "const Caps*" --- Renderer capabilities. .context "void*" --- GL context, or D3D device. --- Platform data. struct.PlatformData { ctor, section = "Platform specific" } .ndt "void*" --- Native display type (*nix specific). .nwh "void*" --- Native window handle. If `NULL`, bgfx will create a headless --- context/device, provided the rendering API supports it. .context "void*" --- GL context, D3D device, or Vulkan device. If `NULL`, bgfx --- will create context/device. .queue "void*" --- D3D12 Queue. If `NULL` bgfx will create queue. .backBuffer "void*" --- GL back-buffer, or D3D render target view. If `NULL` bgfx will --- create back-buffer color surface. .backBufferDS "void*" --- Backbuffer depth/stencil. If `NULL`, bgfx will create a back-buffer --- depth/stencil surface. .type "NativeWindowHandleType::Enum" --- Handle type. Needed for platforms having more than one option. --- Backbuffer resolution and reset parameters. struct.Resolution { ctor, section = "Initialization and Shutdown" } .formatColor "TextureFormat::Enum" --- Backbuffer color format. .formatDepthStencil "TextureFormat::Enum" --- Backbuffer depth/stencil format. .width "uint32_t" --- Backbuffer width. .height "uint32_t" --- Backbuffer height. .reset "uint32_t" --- Reset parameters. .numBackBuffers "uint8_t" --- Number of back buffers. .maxFrameLatency "uint8_t" --- Maximum frame latency. .debugTextScale "uint8_t" --- Scale factor for debug text. --- Configurable runtime limits parameters. struct.Limits { ctor, namespace = "Init" } .maxEncoders "uint16_t" --- Maximum number of encoder threads. .minResourceCbSize "uint32_t" --- Minimum resource command buffer size. .maxTransientVbSize "uint32_t" --- Maximum transient vertex buffer size. .maxTransientIbSize "uint32_t" --- Maximum transient index buffer size. .minUniformBufferSize "uint32_t" --- Mimimum uniform buffer size. --- Initialization parameters used by `bgfx::init`. struct.Init { ctor, section = "Initialization and Shutdown" } .type "RendererType::Enum" --- Select rendering backend. When set to RendererType::Count --- a default rendering backend will be selected appropriate to the platform. --- See: `bgfx::RendererType` .vendorId "uint16_t" --- Vendor PCI ID. If set to `BGFX_PCI_ID_NONE`, discrete and integrated --- GPUs will be prioritised. --- - `BGFX_PCI_ID_NONE` - Autoselect adapter. --- - `BGFX_PCI_ID_SOFTWARE_RASTERIZER` - Software rasterizer. --- - `BGFX_PCI_ID_AMD` - AMD adapter. --- - `BGFX_PCI_ID_APPLE` - Apple adapter. --- - `BGFX_PCI_ID_INTEL` - Intel adapter. --- - `BGFX_PCI_ID_NVIDIA` - NVIDIA adapter. --- - `BGFX_PCI_ID_MICROSOFT` - Microsoft adapter. .deviceId "uint16_t" --- Device ID. If set to 0 it will select first device, or device with --- matching ID. .capabilities "uint64_t" --- Capabilities initialization mask (default: UINT64_MAX). .debug "bool" --- Enable device for debugging. .profile "bool" --- Enable device for profiling. .fallback "bool" --- Enable fallback to next available renderer. .platformData "PlatformData" --- Platform data. .resolution "Resolution" --- Backbuffer resolution and reset parameters. See: `bgfx::Resolution`. .limits "Limits" --- Configurable runtime limits parameters. .callback "CallbackI*" --- Provide application specific callback interface. --- See: `bgfx::CallbackI` .allocator "bx::AllocatorI*" --- Custom allocator. When a custom allocator is not --- specified, bgfx uses the CRT allocator. Bgfx assumes --- custom allocator is thread safe. --- Memory must be obtained by calling `bgfx::alloc`, `bgfx::copy`, or `bgfx::makeRef`. --- --- @attention It is illegal to create this structure on stack and pass it to any bgfx API. struct.Memory { section = "Resources" } .data "uint8_t*" --- Pointer to data. .size "uint32_t" --- Data size. --- Transient index buffer. struct.TransientIndexBuffer { section = "Draw/Buffers" } .data "uint8_t*" --- Pointer to data. .size "uint32_t" --- Data size. .startIndex "uint32_t" --- First index. .handle "IndexBufferHandle" --- Index buffer handle. .isIndex16 "bool" --- Index buffer format is 16-bits if true, otherwise it is 32-bit. --- Transient vertex buffer. struct.TransientVertexBuffer { section = "Draw/Buffers" } .data "uint8_t*" --- Pointer to data. .size "uint32_t" --- Data size. .startVertex "uint32_t" --- First vertex. .stride "uint16_t" --- Vertex stride. .handle "VertexBufferHandle" --- Vertex buffer handle. .layoutHandle "VertexLayoutHandle" --- Vertex layout handle. --- Instance data buffer info. struct.InstanceDataBuffer { section = "Draw/Buffers" } .data "uint8_t*" --- Pointer to data. .size "uint32_t" --- Data size. .offset "uint32_t" --- Offset in vertex buffer. .num "uint32_t" --- Number of instances. .stride "uint16_t" --- Vertex buffer stride. .handle "VertexBufferHandle" --- Vertex buffer object handle. --- Texture info. struct.TextureInfo { section = "Textures" } .format "TextureFormat::Enum" --- Texture format. .storageSize "uint32_t" --- Total amount of bytes required to store texture. .width "uint16_t" --- Texture width. .height "uint16_t" --- Texture height. .depth "uint16_t" --- Texture depth. .numLayers "uint16_t" --- Number of layers in texture array. .numMips "uint8_t" --- Number of MIP maps. .bitsPerPixel "uint8_t" --- Format bits per pixel. .cubeMap "bool" --- Texture is cubemap. --- Uniform info. struct.UniformInfo { section = "Uniforms" } .name "char[256]" --- Uniform name. .type "UniformType::Enum" --- Uniform type. .num "uint16_t" --- Number of elements in array. --- Frame buffer texture attachment info. struct.Attachment { shortname, section = "Frame Buffers" } .access "Access::Enum" --- Attachment access. See `Access::Enum`. .handle "TextureHandle" --- Render target texture handle. .mip "uint16_t" --- Mip level. .layer "uint16_t" --- Cubemap side or depth layer/slice to use. .numLayers "uint16_t" --- Number of texture layer/slice(s) in array to use. .resolve "uint8_t" --- Resolve flags. See: `BGFX_RESOLVE_*` --- Init attachment. func.Attachment.init "void" .handle "TextureHandle" --- Render target texture handle. .access "Access::Enum" --- Access. See `Access::Enum`. { default = "Access::Write" } .layer "uint16_t" --- Cubemap side or depth layer/slice to use. { default = 0 } .numLayers "uint16_t" --- Number of texture layer/slice(s) in array to use. { default = 1 } .mip "uint16_t" --- Mip level. { default = 0 } .resolve "uint8_t" --- Resolve flags. See: `BGFX_RESOLVE_*` { default = "BGFX_RESOLVE_AUTO_GEN_MIPS" } --- Transform data. struct.Transform .data "float*" --- Pointer to first 4x4 matrix. .num "uint16_t" --- Number of matrices. --- View stats. struct.ViewStats { section = "Statistics" } .name "char[256]" --- View name. .view "ViewId" --- View id. .cpuTimeBegin "int64_t" --- CPU (submit) begin time. .cpuTimeEnd "int64_t" --- CPU (submit) end time. .gpuTimeBegin "int64_t" --- GPU begin time. .gpuTimeEnd "int64_t" --- GPU end time. .gpuFrameNum "uint32_t" --- Frame which generated gpuTimeBegin, gpuTimeEnd. --- Encoder stats. struct.EncoderStats { section = "Statistics" } .cpuTimeBegin "int64_t" --- Encoder thread CPU submit begin time. .cpuTimeEnd "int64_t" --- Encoder thread CPU submit end time. --- Renderer statistics data. --- --- @remarks All time values are high-resolution timestamps, while --- time frequencies define timestamps-per-second for that hardware. struct.Stats { section = "Statistics" } .cpuTimeFrame "int64_t" --- CPU time between two `bgfx::frame` calls. .cpuTimeBegin "int64_t" --- Render thread CPU submit begin time. .cpuTimeEnd "int64_t" --- Render thread CPU submit end time. .cpuTimerFreq "int64_t" --- CPU timer frequency. Timestamps-per-second .gpuTimeBegin "int64_t" --- GPU frame begin time. .gpuTimeEnd "int64_t" --- GPU frame end time. .gpuTimerFreq "int64_t" --- GPU timer frequency. .waitRender "int64_t" --- Time spent waiting for render backend thread to finish issuing draw commands to underlying graphics API. .waitSubmit "int64_t" --- Time spent waiting for submit thread to advance to next frame. .numDraw "uint32_t" --- Number of draw calls submitted. .numCompute "uint32_t" --- Number of compute calls submitted. .numBlit "uint32_t" --- Number of blit calls submitted. .maxGpuLatency "uint32_t" --- GPU driver latency. .gpuFrameNum "uint32_t" --- Frame which generated gpuTimeBegin, gpuTimeEnd. .numDynamicIndexBuffers "uint16_t" --- Number of used dynamic index buffers. .numDynamicVertexBuffers "uint16_t" --- Number of used dynamic vertex buffers. .numFrameBuffers "uint16_t" --- Number of used frame buffers. .numIndexBuffers "uint16_t" --- Number of used index buffers. .numOcclusionQueries "uint16_t" --- Number of used occlusion queries. .numPrograms "uint16_t" --- Number of used programs. .numShaders "uint16_t" --- Number of used shaders. .numTextures "uint16_t" --- Number of used textures. .numUniforms "uint16_t" --- Number of used uniforms. .numVertexBuffers "uint16_t" --- Number of used vertex buffers. .numVertexLayouts "uint16_t" --- Number of used vertex layouts. .textureMemoryUsed "int64_t" --- Estimate of texture memory used. .rtMemoryUsed "int64_t" --- Estimate of render target memory used. .transientVbUsed "int32_t" --- Amount of transient vertex buffer used. .transientIbUsed "int32_t" --- Amount of transient index buffer used. .numPrims "uint32_t[Topology::Count]" --- Number of primitives rendered. .gpuMemoryMax "int64_t" --- Maximum available GPU memory for application. .gpuMemoryUsed "int64_t" --- Amount of GPU memory used by the application. .width "uint16_t" --- Backbuffer width in pixels. .height "uint16_t" --- Backbuffer height in pixels. .textWidth "uint16_t" --- Debug text width in characters. .textHeight "uint16_t" --- Debug text height in characters. .numViews "uint16_t" --- Number of view stats. .viewStats "ViewStats*" --- Array of View stats. .numEncoders "uint8_t" --- Number of encoders used during frame. .encoderStats "EncoderStats*" --- Array of encoder stats. --- Vertex layout. struct.VertexLayout { ctor, section = "Vertex Buffers" } .hash "uint32_t" --- Hash. .stride "uint16_t" --- Stride. .offset "uint16_t[Attrib::Count]" --- Attribute offsets. .attributes "uint16_t[Attrib::Count]" --- Used attributes. --- Encoders are used for submitting draw calls from multiple threads. Only one encoder --- per thread should be used. Use `bgfx::begin()` to obtain an encoder for a thread. struct.Encoder { section = "Encoder" } handle "DynamicIndexBufferHandle" handle "DynamicVertexBufferHandle" handle "FrameBufferHandle" handle "IndexBufferHandle" handle "IndirectBufferHandle" handle "OcclusionQueryHandle" handle "ProgramHandle" handle "ShaderHandle" handle "TextureHandle" handle "UniformHandle" handle "VertexBufferHandle" handle "VertexLayoutHandle" --- Start VertexLayout. func.VertexLayout.begin "VertexLayout&" --- Returns itself. .rendererType "RendererType::Enum" --- Renderer backend type. See: `bgfx::RendererType` { default = "RendererType::Noop" } --- Add attribute to VertexLayout. --- --- @remarks Must be called between begin/end. --- func.VertexLayout.add "VertexLayout&" --- Returns itself. .attrib "Attrib::Enum" --- Attribute semantics. See: `bgfx::Attrib` .num "uint8_t" --- Number of elements 1, 2, 3 or 4. .type "AttribType::Enum" --- Element type. .normalized "bool" --- When using fixed point AttribType (f.e. Uint8) { default = false } --- value will be normalized for vertex shader usage. When normalized --- is set to true, AttribType::Uint8 value in range 0-255 will be --- in range 0.0-1.0 in vertex shader. .asInt "bool" --- Packaging rule for vertexPack, vertexUnpack, and { default = false } --- vertexConvert for AttribType::Uint8 and AttribType::Int16. --- Unpacking code must be implemented inside vertex shader. --- Decode attribute. func.VertexLayout.decode { const } "void" .attrib "Attrib::Enum" --- Attribute semantics. See: `bgfx::Attrib` .num "uint8_t &" { out } --- Number of elements. .type "AttribType::Enum &" { out } --- Element type. .normalized "bool &" { out } --- Attribute is normalized. .asInt "bool &" { out } --- Attribute is packed as int. --- Returns `true` if VertexLayout contains attribute. func.VertexLayout.has { const, cppinline = "return UINT16_MAX != m_attributes[_attrib];" } "bool" --- True if VertexLayout contains attribute. .attrib "Attrib::Enum" --- Attribute semantics. See: `bgfx::Attrib` --- Skip `_num` bytes in vertex stream. func.VertexLayout.skip "VertexLayout&" --- Returns itself. .num "uint8_t" --- Number of bytes to skip. -- Notice: `end` is a keyword in lua. --- End VertexLayout. func.VertexLayout["end"] "void" --- Returns relative attribute offset from the vertex. func.VertexLayout.getOffset { const, cppinline = "return m_offset[_attrib];" } "uint16_t" --- Relative attribute offset from the vertex. .attrib "Attrib::Enum" --- Attribute semantics. See: `bgfx::Attrib` --- Returns vertex stride. func.VertexLayout.getStride { const, cppinline = "return m_stride;" } "uint16_t" --- Vertex stride. --- Returns size of vertex buffer for number of vertices. func.VertexLayout.getSize { const, cppinline = "return _num*m_stride;" } "uint32_t" --- Size of vertex buffer for number of vertices. .num "uint32_t" --- Number of vertices. --- Pack vertex attribute into vertex stream format. func.vertexPack { section = "Miscellaneous" } "void" .input "const float[4]" --- Value to be packed into vertex stream. .inputNormalized "bool" --- `true` if input value is already normalized. .attr "Attrib::Enum" --- Attribute to pack. .layout "const VertexLayout &" --- Vertex stream layout. .data "void*" --- Destination vertex stream where data will be packed. .index "uint32_t" --- Vertex index that will be modified. { default = 0 } --- Unpack vertex attribute from vertex stream format. func.vertexUnpack { section = "Miscellaneous" } "void" .output "float[4]" { out } --- Result of unpacking. .attr "Attrib::Enum" --- Attribute to unpack. .layout "const VertexLayout &" --- Vertex stream layout. .data "const void*" --- Source vertex stream from where data will be unpacked. .index "uint32_t" --- Vertex index that will be unpacked. { default = 0 } --- Converts vertex stream data from one vertex stream format to another. func.vertexConvert { section = "Miscellaneous" } "void" .dstLayout "const VertexLayout &" --- Destination vertex stream layout. .dstData "void*" --- Destination vertex stream. .srcLayout "const VertexLayout &" --- Source vertex stream layout. .srcData "const void*" --- Source vertex stream data. .num "uint32_t" --- Number of vertices to convert from source to destination. { default = 1 } --- Weld vertices. Returns number of unique vertices after welding. func.weldVertices { section = "Miscellaneous" } "uint32_t" --- Number of unique vertices after vertex welding. .output "void*" --- Welded vertices remapping table. The size of buffer --- must be the same as number of vertices. .layout "const VertexLayout &" --- Vertex stream layout. .data "const void*" --- Vertex stream. .num "uint32_t" --- Number of vertices in vertex stream. .index32 "bool" --- Set to `true` if input indices are 32-bit. .epsilon "float" --- Error tolerance for vertex position comparison. { default = "0.001f" } --- Convert index buffer for use with different primitive topologies. func.topologyConvert { section = "Miscellaneous" } "uint32_t" --- Number of output indices after conversion. .conversion "TopologyConvert::Enum" --- Conversion type, see `TopologyConvert::Enum`. .dst "void*" { out } --- Destination index buffer. If this argument is NULL --- function will return number of indices after conversion. .dstSize "uint32_t" --- Destination index buffer in bytes. It must be --- large enough to contain output indices. If destination size is --- insufficient index buffer will be truncated. .indices "const void*" --- Source indices. .numIndices "uint32_t" --- Number of input indices. .index32 "bool" --- Set to `true` if input indices are 32-bit. --- Sort indices. func.topologySortTriList { section = "Miscellaneous" } "void" .sort "TopologySort::Enum" --- Sort order, see `TopologySort::Enum`. .dst "void*" { out } --- Destination index buffer. .dstSize "uint32_t" --- Destination index buffer in bytes. It must be --- large enough to contain output indices. If destination size is --- insufficient index buffer will be truncated. .dir "const float[3]" --- Direction (vector must be normalized). .pos "const float[3]" --- Position. .vertices "const void*" --- Pointer to first vertex represented as --- float x, y, z. Must contain at least number of vertices --- referencende by index buffer. .stride "uint32_t" --- Vertex stride. .indices "const void*" --- Source indices. .numIndices "uint32_t" --- Number of input indices. .index32 "bool" --- Set to `true` if input indices are 32-bit. --- Returns supported backend API renderers. func.getSupportedRenderers { section = "Renderer" } "uint8_t" --- Number of supported renderers. .max "uint8_t" --- Maximum number of elements in _enum array. { default = 0 } .enum "RendererType::Enum*" { inout } --- Array where supported renderers will be written. { default = NULL } --- Returns name of renderer. func.getRendererName "const char*" --- Name of renderer. .type "RendererType::Enum" --- Renderer backend type. See: `bgfx::RendererType` --- Fill bgfx::Init struct with default values, before using it to initialize the library. func.initCtor { cfunc } "void" .init "Init*" --- Pointer to structure to be initialized. See: `bgfx::Init` for more info. --- Initialize the bgfx library. func.init { cfunc, section = "Initialization and Shutdown" } "bool" --- `true` if initialization was successful. .init "const Init &" --- Initialization parameters. See: `bgfx::Init` for more info. --- Shutdown bgfx library. func.shutdown { section = "Initialization and Shutdown" } "void" --- Reset graphic settings and back-buffer size. --- --- @attention This call doesn’t change the window size, it just resizes --- the back-buffer. Your windowing code controls the window size. --- func.reset { section = "Reset" } "void" .width "uint32_t" --- Back-buffer width. .height "uint32_t" --- Back-buffer height. .flags "uint32_t" --- See: `BGFX_RESET_*` for more info. { default = "BGFX_RESET_NONE" } --- - `BGFX_RESET_NONE` - No reset flags. --- - `BGFX_RESET_FULLSCREEN` - Not supported yet. --- - `BGFX_RESET_MSAA_X[2/4/8/16]` - Enable 2, 4, 8 or 16 x MSAA. --- - `BGFX_RESET_VSYNC` - Enable V-Sync. --- - `BGFX_RESET_MAXANISOTROPY` - Turn on/off max anisotropy. --- - `BGFX_RESET_CAPTURE` - Begin screen capture. --- - `BGFX_RESET_FLUSH_AFTER_RENDER` - Flush rendering after submitting to GPU. --- - `BGFX_RESET_FLIP_AFTER_RENDER` - This flag specifies where flip --- occurs. Default behaviour is that flip occurs before rendering new --- frame. This flag only has effect when `BGFX_CONFIG_MULTITHREADED=0`. --- - `BGFX_RESET_SRGB_BACKBUFFER` - Enable sRGB back-buffer. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. { default = "TextureFormat::Count" } --- Advance to next frame. This is the main frame-advancement call on the --- API thread (the thread from which `bgfx::init` was called). --- --- **Multithreaded renderer** (`BGFX_CONFIG_MULTITHREADED=1`, default): --- This call waits for the render thread to finish processing the previous --- frame, then swaps internal submit/render buffers, signals the render --- thread to begin processing the new frame via `bgfx::renderFrame`, and --- returns immediately. The render thread and API thread then run in --- parallel: the API thread builds the next frame while the render thread --- executes GPU commands for the current frame. --- --- **Single-threaded renderer** (`BGFX_CONFIG_MULTITHREADED=0`, or when --- `bgfx::renderFrame` and `bgfx::init` are called from the same thread): --- This call swaps internal buffers and performs frame rendering inline --- (internally calls `bgfx::renderFrame`), then returns. --- --- @remarks --- Must be called from the API thread (the thread that called --- `bgfx::init`). In multithreaded mode, this call synchronizes with --- `bgfx::renderFrame` running on the render thread via semaphores: --- `bgfx::frame` waits for the render thread to finish, then posts a --- signal that `bgfx::renderFrame` waits on to begin the next frame. --- See also: `bgfx::renderFrame`. --- func.frame { section = "Frame" } "uint32_t" --- Current frame number. This might be used in conjunction with --- double/multi buffering data outside the library and passing it to --- library via `bgfx::makeRef` calls. .flags "uint8_t" --- Frame flags. See: `BGFX_FRAME_*` for more info. { default = "BGFX_FRAME_NONE" } --- - `BGFX_FRAME_NONE` - No frame flag. --- - `BGFX_FRAME_DEBUG_CAPTURE` - Capture frame with graphics debugger. --- - `BGFX_FRAME_DISCARD` - Discard all draw calls. --- Returns current renderer backend API type. --- --- @remarks --- Library must be initialized. --- func.getRendererType { section = "Renderer" } "RendererType::Enum" --- Renderer backend type. See: `bgfx::RendererType` --- Returns renderer capabilities. --- --- @remarks --- Library must be initialized. --- func.getCaps { section = "Capabilities" } "const Caps*" --- Pointer to static `bgfx::Caps` structure. --- Returns performance counters. --- --- @attention Pointer returned is valid until `bgfx::frame` is called. --- func.getStats { section = "Statistics" } "const Stats*" --- Performance counters. --- Allocate buffer to pass to bgfx calls. Data will be freed inside bgfx. func.alloc { section = "Resources" } "const Memory*" --- Allocated memory. .size "uint32_t" --- Size to allocate. --- Allocate buffer and copy data into it. Data will be freed inside bgfx. func.copy { section = "Resources" } "const Memory*" --- Allocated memory. .data "const void*" --- Pointer to data to be copied. .size "uint32_t" --- Size of data to be copied. --- Make reference to data to pass to bgfx. Unlike `bgfx::alloc`, this call --- doesn't allocate memory for data. It just copies the _data pointer. You --- can pass `ReleaseFn` function pointer to release this memory after it's --- consumed, otherwise you must make sure _data is available for at least 2 --- `bgfx::frame` calls. `ReleaseFn` function must be able to be called --- from any thread. --- --- @attention Data passed must be available for at least 2 `bgfx::frame` calls. --- func.makeRef { conly } "const Memory*" --- Referenced memory. .data "const void*" --- Pointer to data. .size "uint32_t" --- Size of data. --- Make reference to data to pass to bgfx. Unlike `bgfx::alloc`, this call --- doesn't allocate memory for data. It just copies the _data pointer. You --- can pass `ReleaseFn` function pointer to release this memory after it's --- consumed, otherwise you must make sure _data is available for at least 2 --- `bgfx::frame` calls. `ReleaseFn` function must be able to be called --- from any thread. --- --- @attention Data passed must be available for at least 2 `bgfx::frame` calls. --- func.makeRef { cname = "make_ref_release", section = "Resources" } "const Memory*" --- Referenced memory. .data "const void*" --- Pointer to data. .size "uint32_t" --- Size of data. .releaseFn "ReleaseFn" --- Callback function to release memory after use. { default = NULL } .userData "void*" --- User data to be passed to callback function. { default = NULL } --- Set debug flags. func.setDebug { section = "Debug Features" } "void" .debug "uint32_t" --- Available flags: --- - `BGFX_DEBUG_IFH` - Infinitely fast hardware. When this flag is set --- all rendering calls will be skipped. This is useful when profiling --- to quickly assess potential bottlenecks between CPU and GPU. --- - `BGFX_DEBUG_PROFILER` - Enable profiler. --- - `BGFX_DEBUG_STATS` - Display internal statistics. --- - `BGFX_DEBUG_TEXT` - Display debug text. --- - `BGFX_DEBUG_WIREFRAME` - Wireframe rendering. All rendering --- primitives will be rendered as lines. --- Clear internal debug text buffer. func.dbgTextClear { section = "Debug Text Display" } "void" .attr "uint8_t" --- Background color. { default = 0 } .small "bool" --- Default 8x16 or 8x8 font. { default = false } --- Print formatted data to internal debug text character-buffer (VGA-compatible text mode). func.dbgTextPrintf { vararg = "dbgTextPrintfVargs", section = "Debug Text Display" } "void" .x "uint16_t" --- Position x from the left corner of the window. .y "uint16_t" --- Position y from the top corner of the window. .attr "uint8_t" --- Color palette. Where top 4-bits represent index of background, and bottom --- 4-bits represent foreground color from standard VGA text palette (ANSI escape codes). .format "const char*" --- `printf` style format. --- Print formatted data from variable argument list to internal debug text character-buffer (VGA-compatible text mode). func.dbgTextPrintfVargs { cname = "dbg_text_vprintf", section = "Debug Text Display" } "void" .x "uint16_t" --- Position x from the left corner of the window. .y "uint16_t" --- Position y from the top corner of the window. .attr "uint8_t" --- Color palette. Where top 4-bits represent index of background, and bottom --- 4-bits represent foreground color from standard VGA text palette (ANSI escape codes). .format "const char*" --- `printf` style format. .argList "va_list" --- Variable arguments list for format string. --- Draw image into internal debug text buffer. func.dbgTextImage { section = "Debug Text Display" } "void" .x "uint16_t" --- Position x from the left corner of the window. .y "uint16_t" --- Position y from the top corner of the window. .width "uint16_t" --- Image width. .height "uint16_t" --- Image height. .data "const void*" --- Raw image data (character/attribute raw encoding). .pitch "uint16_t" --- Image pitch in bytes. --- Create static index buffer. func.createIndexBuffer { section = "Index Buffers" } "IndexBufferHandle" .mem "const Memory*" --- Index buffer data. .flags "uint16_t" --- Buffer creation flags. { default = "BGFX_BUFFER_NONE" } --- - `BGFX_BUFFER_NONE` - No flags. --- - `BGFX_BUFFER_COMPUTE_READ` - Buffer will be read from by compute shader. --- - `BGFX_BUFFER_COMPUTE_WRITE` - Buffer will be written into by compute shader. When buffer --- is created with `BGFX_BUFFER_COMPUTE_WRITE` flag it cannot be updated from CPU. --- - `BGFX_BUFFER_COMPUTE_READ_WRITE` - Buffer will be used for read/write by compute shader. --- - `BGFX_BUFFER_ALLOW_RESIZE` - Buffer will resize on buffer update if a different amount of --- data is passed. If this flag is not specified, and more data is passed on update, the buffer --- will be trimmed to fit the existing buffer size. This flag has effect only on dynamic --- buffers. --- - `BGFX_BUFFER_INDEX32` - Buffer is using 32-bit indices. This flag has effect only on --- index buffers. --- Set static index buffer debug name. func.setName { cname = "set_index_buffer_name", section = "Index Buffers" } "void" .handle "IndexBufferHandle" --- Static index buffer handle. .name "const char*" --- Static index buffer name. .len "int32_t" --- Static index buffer name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string. --- Destroy static index buffer. func.destroy { cname = "destroy_index_buffer", section = "Index Buffers" } "void" .handle "IndexBufferHandle" --- Static index buffer handle. --- Create vertex layout. Vertex layouts are used to describe the format of vertex data. func.createVertexLayout { section = "Vertex Buffers" } "VertexLayoutHandle" .layout "const VertexLayout &" --- Vertex layout. --- Destroy vertex layout. func.destroy { cname = "destroy_vertex_layout", section = "Vertex Buffers" } "void" .layoutHandle "VertexLayoutHandle" --- Vertex layout handle. --- Create static vertex buffer. func.createVertexBuffer { section = "Vertex Buffers" } "VertexBufferHandle" --- Static vertex buffer handle. .mem "const Memory*" --- Vertex buffer data. .layout "const VertexLayout &" --- Vertex layout. .flags "uint16_t" --- Buffer creation flags. { default = "BGFX_BUFFER_NONE" } --- - `BGFX_BUFFER_NONE` - No flags. --- - `BGFX_BUFFER_COMPUTE_READ` - Buffer will be read from by compute shader. --- - `BGFX_BUFFER_COMPUTE_WRITE` - Buffer will be written into by compute shader. When buffer --- is created with `BGFX_BUFFER_COMPUTE_WRITE` flag it cannot be updated from CPU. --- - `BGFX_BUFFER_COMPUTE_READ_WRITE` - Buffer will be used for read/write by compute shader. --- - `BGFX_BUFFER_ALLOW_RESIZE` - Buffer will resize on buffer update if a different amount of --- data is passed. If this flag is not specified, and more data is passed on update, the buffer --- will be trimmed to fit the existing buffer size. This flag has effect only on dynamic buffers. --- - `BGFX_BUFFER_INDEX32` - Buffer is using 32-bit indices. This flag has effect only on index buffers. --- Set static vertex buffer debug name. func.setName { cname = "set_vertex_buffer_name", section = "Vertex Buffers" } "void" .handle "VertexBufferHandle" --- Static vertex buffer handle. .name "const char*" --- Static vertex buffer name. .len "int32_t" --- Static vertex buffer name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string. --- Destroy static vertex buffer. func.destroy { cname = "destroy_vertex_buffer", section = "Vertex Buffers" } "void" .handle "VertexBufferHandle" --- Static vertex buffer handle. --- Create empty dynamic index buffer. func.createDynamicIndexBuffer { section = "Index Buffers" } "DynamicIndexBufferHandle" --- Dynamic index buffer handle. .num "uint32_t" --- Number of indices. .flags "uint16_t" --- Buffer creation flags. { default = "BGFX_BUFFER_NONE" } --- - `BGFX_BUFFER_NONE` - No flags. --- - `BGFX_BUFFER_COMPUTE_READ` - Buffer will be read from by compute shader. --- - `BGFX_BUFFER_COMPUTE_WRITE` - Buffer will be written into by compute shader. When buffer --- is created with `BGFX_BUFFER_COMPUTE_WRITE` flag it cannot be updated from CPU. --- - `BGFX_BUFFER_COMPUTE_READ_WRITE` - Buffer will be used for read/write by compute shader. --- - `BGFX_BUFFER_ALLOW_RESIZE` - Buffer will resize on buffer update if a different amount of --- data is passed. If this flag is not specified, and more data is passed on update, the buffer --- will be trimmed to fit the existing buffer size. This flag has effect only on dynamic --- buffers. --- - `BGFX_BUFFER_INDEX32` - Buffer is using 32-bit indices. This flag has effect only on --- index buffers. --- Create a dynamic index buffer and initialize it. func.createDynamicIndexBuffer { cname = "create_dynamic_index_buffer_mem", section = "Index Buffers" } "DynamicIndexBufferHandle" --- Dynamic index buffer handle. .mem "const Memory*" --- Index buffer data. .flags "uint16_t" --- Buffer creation flags. { default = "BGFX_BUFFER_NONE" } --- - `BGFX_BUFFER_NONE` - No flags. --- - `BGFX_BUFFER_COMPUTE_READ` - Buffer will be read from by compute shader. --- - `BGFX_BUFFER_COMPUTE_WRITE` - Buffer will be written into by compute shader. When buffer --- is created with `BGFX_BUFFER_COMPUTE_WRITE` flag it cannot be updated from CPU. --- - `BGFX_BUFFER_COMPUTE_READ_WRITE` - Buffer will be used for read/write by compute shader. --- - `BGFX_BUFFER_ALLOW_RESIZE` - Buffer will resize on buffer update if a different amount of --- data is passed. If this flag is not specified, and more data is passed on update, the buffer --- will be trimmed to fit the existing buffer size. This flag has effect only on dynamic --- buffers. --- - `BGFX_BUFFER_INDEX32` - Buffer is using 32-bit indices. This flag has effect only on --- index buffers. --- Update dynamic index buffer. func.update { cname = "update_dynamic_index_buffer", section = "Index Buffers" } "void" .handle "DynamicIndexBufferHandle" --- Dynamic index buffer handle. .startIndex "uint32_t" --- Start index. .mem "const Memory*" --- Index buffer data. --- Destroy dynamic index buffer. func.destroy { cname = "destroy_dynamic_index_buffer", section = "Index Buffers" } "void" .handle "DynamicIndexBufferHandle" --- Dynamic index buffer handle. --- Create empty dynamic vertex buffer. func.createDynamicVertexBuffer { section = "Vertex Buffers" } "DynamicVertexBufferHandle" --- Dynamic vertex buffer handle. .num "uint32_t" --- Number of vertices. .layout "const VertexLayout&" --- Vertex layout. .flags "uint16_t" --- Buffer creation flags. { default = "BGFX_BUFFER_NONE" } --- - `BGFX_BUFFER_NONE` - No flags. --- - `BGFX_BUFFER_COMPUTE_READ` - Buffer will be read from by compute shader. --- - `BGFX_BUFFER_COMPUTE_WRITE` - Buffer will be written into by compute shader. When buffer --- is created with `BGFX_BUFFER_COMPUTE_WRITE` flag it cannot be updated from CPU. --- - `BGFX_BUFFER_COMPUTE_READ_WRITE` - Buffer will be used for read/write by compute shader. --- - `BGFX_BUFFER_ALLOW_RESIZE` - Buffer will resize on buffer update if a different amount of --- data is passed. If this flag is not specified, and more data is passed on update, the buffer --- will be trimmed to fit the existing buffer size. This flag has effect only on dynamic --- buffers. --- - `BGFX_BUFFER_INDEX32` - Buffer is using 32-bit indices. This flag has effect only on --- index buffers. --- Create dynamic vertex buffer and initialize it. func.createDynamicVertexBuffer { cname = "create_dynamic_vertex_buffer_mem", section = "Vertex Buffers" } "DynamicVertexBufferHandle" --- Dynamic vertex buffer handle. .mem "const Memory*" --- Vertex buffer data. .layout "const VertexLayout&" --- Vertex layout. .flags "uint16_t" --- Buffer creation flags. { default = "BGFX_BUFFER_NONE" } --- - `BGFX_BUFFER_NONE` - No flags. --- - `BGFX_BUFFER_COMPUTE_READ` - Buffer will be read from by compute shader. --- - `BGFX_BUFFER_COMPUTE_WRITE` - Buffer will be written into by compute shader. When buffer --- is created with `BGFX_BUFFER_COMPUTE_WRITE` flag it cannot be updated from CPU. --- - `BGFX_BUFFER_COMPUTE_READ_WRITE` - Buffer will be used for read/write by compute shader. --- - `BGFX_BUFFER_ALLOW_RESIZE` - Buffer will resize on buffer update if a different amount of --- data is passed. If this flag is not specified, and more data is passed on update, the buffer --- will be trimmed to fit the existing buffer size. This flag has effect only on dynamic --- buffers. --- - `BGFX_BUFFER_INDEX32` - Buffer is using 32-bit indices. This flag has effect only on --- index buffers. --- Update dynamic vertex buffer. func.update { cname = "update_dynamic_vertex_buffer", section = "Vertex Buffers" } "void" .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer handle. .startVertex "uint32_t" --- Start vertex. .mem "const Memory*" --- Vertex buffer data. --- Destroy dynamic vertex buffer. func.destroy { cname = "destroy_dynamic_vertex_buffer", section = "Vertex Buffers" } "void" .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer handle. --- Returns number of requested or maximum available indices. func.getAvailTransientIndexBuffer { section = "Index Buffers" } "uint32_t" --- Number of requested or maximum available indices. .num "uint32_t" --- Number of required indices. .index32 "bool" --- Set to `true` if input indices will be 32-bit. { default = false } --- Returns number of requested or maximum available vertices. func.getAvailTransientVertexBuffer { section = "Vertex Buffers" } "uint32_t" --- Number of requested or maximum available vertices. .num "uint32_t" --- Number of required vertices. .layout "const VertexLayout &" --- Vertex layout. --- Returns number of requested or maximum available instance buffer slots. func.getAvailInstanceDataBuffer { section = "Instance Buffer" } "uint32_t" --- Number of requested or maximum available instance buffer slots. .num "uint32_t" --- Number of required instances. .stride "uint16_t" --- Stride per instance. --- Allocate transient index buffer. --- func.allocTransientIndexBuffer { section = "Index Buffers" } "void" .tib "TransientIndexBuffer*" { out } --- TransientIndexBuffer structure will be filled, and will be valid --- for the duration of frame, and can be reused for multiple draw --- calls. .num "uint32_t" --- Number of indices to allocate. .index32 "bool" --- Set to `true` if input indices will be 32-bit. { default = false } --- Allocate transient vertex buffer. func.allocTransientVertexBuffer { section = "Vertex Buffers" } "void" .tvb "TransientVertexBuffer*" { out } --- TransientVertexBuffer structure will be filled, and will be valid --- for the duration of frame, and can be reused for multiple draw --- calls. .num "uint32_t" --- Number of vertices to allocate. .layout "const VertexLayout &" --- Vertex layout. --- Check for required space and allocate transient vertex and index --- buffers. If both space requirements are satisfied function returns --- true. --- func.allocTransientBuffers "bool" .tvb "TransientVertexBuffer*" { out } --- TransientVertexBuffer structure will be filled, and will be valid --- for the duration of frame, and can be reused for multiple draw --- calls. .layout "const VertexLayout &" --- Vertex layout. .numVertices "uint32_t" --- Number of vertices to allocate. .tib "TransientIndexBuffer*" { out } --- TransientIndexBuffer structure will be filled, and will be valid --- for the duration of frame, and can be reused for multiple draw --- calls. .numIndices "uint32_t" --- Number of indices to allocate. .index32 "bool" --- Set to `true` if input indices will be 32-bit. { default = false } --- Allocate instance data buffer. func.allocInstanceDataBuffer { section = "Instance Buffer" } "void" .idb "InstanceDataBuffer*" { out } --- InstanceDataBuffer structure will be filled, and will be valid --- for duration of frame, and can be reused for multiple draw --- calls. .num "uint32_t" --- Number of instances. .stride "uint16_t" --- Instance stride. Must be multiple of 16. --- Create draw indirect buffer. func.createIndirectBuffer { section = "Indirect Buffer" } "IndirectBufferHandle" --- Indirect buffer handle. .num "uint32_t" --- Number of indirect calls. --- Destroy draw indirect buffer. func.destroy { cname = "destroy_indirect_buffer", section = "Indirect Buffer" } "void" .handle "IndirectBufferHandle" --- Indirect buffer handle. --- Create shader from memory buffer. --- --- @remarks --- Shader binary is obtained by compiling shader offline with shaderc command line tool. --- func.createShader { section = "Shaders and Programs" } "ShaderHandle" --- Shader handle. .mem "const Memory*" --- Shader binary. --- Returns the number of uniforms and uniform handles used inside a shader. --- --- @remarks --- Only non-predefined uniforms are returned. --- func.getShaderUniforms { section = "Shaders and Programs" } "uint16_t" --- Number of uniforms used by shader. .handle "ShaderHandle" --- Shader handle. .uniforms "UniformHandle*" { out } --- UniformHandle array where data will be stored. { default = NULL } .max "uint16_t" --- Maximum capacity of array. { default = 0 } --- Set shader debug name. func.setName { cname = "set_shader_name", section = "Debug" } "void" .handle "ShaderHandle" --- Shader handle. .name "const char*" --- Shader name. .len "int32_t" --- Shader name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string). --- Destroy shader. --- --- @remark Once a shader program is created with _handle, --- it is safe to destroy that shader. --- func.destroy { cname = "destroy_shader", section = "Shaders and Programs" } "void" .handle "ShaderHandle" --- Shader handle. --- Create program with vertex and fragment shaders. func.createProgram { section = "Shaders and Programs" } "ProgramHandle" --- Program handle if vertex shader output and fragment shader --- input are matching, otherwise returns invalid program handle. .vsh "ShaderHandle" --- Vertex shader. .fsh "ShaderHandle" --- Fragment shader. .destroyShaders "bool" --- If true, shaders will be destroyed when program is destroyed. { default = false } --- Create program with compute shader. func.createProgram { cname = "create_compute_program", section = "Shaders and Programs" } "ProgramHandle" --- Program handle. .csh "ShaderHandle" --- Compute shader. .destroyShaders "bool" --- If true, shaders will be destroyed when program is destroyed. { default = false } --- Destroy program. func.destroy { cname = "destroy_program", section = "Shaders and Programs" } "void" .handle "ProgramHandle" --- Program handle. --- Validate texture parameters. func.isTextureValid { section = "Textures" } "bool" --- True if a texture with the same parameters can be created. .depth "uint16_t" --- Depth dimension of volume texture. .cubeMap "bool" --- Indicates that texture contains cubemap. .numLayers "uint16_t" --- Number of layers in texture array. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .flags "uint64_t" --- Texture flags. See `BGFX_TEXTURE_*`. --- Validate frame buffer parameters. func.isFrameBufferValid { section = "Frame Buffers" } "bool" --- True if a frame buffer with the same parameters can be created. .num "uint8_t" --- Number of attachments. .attachment "const Attachment*" --- Attachment texture info. See: `bgfx::Attachment`. --- Calculate amount of memory required for texture. func.calcTextureSize { section = "Textures" } "void" .info "TextureInfo &" { out } --- Resulting texture info structure. See: `TextureInfo`. .width "uint16_t" --- Width. .height "uint16_t" --- Height. .depth "uint16_t" --- Depth dimension of volume texture. .cubeMap "bool" --- Indicates that texture contains cubemap. .hasMips "bool" --- Indicates that texture contains full mip-map chain. .numLayers "uint16_t" --- Number of layers in texture array. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. --- Create texture from memory buffer. func.createTexture { section = "Textures" } "TextureHandle" --- Texture handle. .mem "const Memory*" --- DDS, KTX or PVR texture binary data. .flags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) { default = "BGFX_TEXTURE_NONE|BGFX_SAMPLER_NONE" } --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. .skip "uint8_t" --- Skip top level mips when parsing texture. { default = 0 } .info "TextureInfo*" { out } --- When non-`NULL` is specified it returns parsed texture information. { default = NULL } --- Create 2D texture. func.createTexture2D { section = "Textures" } "TextureHandle" --- Texture handle. .width "uint16_t" --- Width. .height "uint16_t" --- Height. .hasMips "bool" --- Indicates that texture contains full mip-map chain. .numLayers "uint16_t" --- Number of layers in texture array. Must be 1 if caps --- `BGFX_CAPS_TEXTURE_2D_ARRAY` flag is not set. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .flags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) { default = "BGFX_TEXTURE_NONE|BGFX_SAMPLER_NONE" } --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. .mem "const Memory*" --- Texture data. If `_mem` is non-NULL, created texture will be immutable. If { default = NULL } --- `_mem` is NULL content of the texture is uninitialized. When `_numLayers` is more than --- 1, expected memory layout is texture and all mips together for each array element. .external "uint64_t" --- Native API pointer to texture. { default = 0 } --- Create texture with size based on back-buffer ratio. Texture will maintain ratio --- if back buffer resolution changes. func.createTexture2D { cname = "create_texture_2d_scaled", section = "Textures" } "TextureHandle" --- Texture handle. .ratio "BackbufferRatio::Enum" --- Texture size in respect to back-buffer size. See: `BackbufferRatio::Enum`. .hasMips "bool" --- Indicates that texture contains full mip-map chain. .numLayers "uint16_t" --- Number of layers in texture array. Must be 1 if caps --- `BGFX_CAPS_TEXTURE_2D_ARRAY` flag is not set. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .flags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) { default = "BGFX_TEXTURE_NONE|BGFX_SAMPLER_NONE" } --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. --- Create 3D texture. func.createTexture3D { section = "Textures" } "TextureHandle" --- Texture handle. .width "uint16_t" --- Width. .height "uint16_t" --- Height. .depth "uint16_t" --- Depth. .hasMips "bool" --- Indicates that texture contains full mip-map chain. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .flags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) { default = "BGFX_TEXTURE_NONE|BGFX_SAMPLER_NONE" } --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. .mem "const Memory*" --- Texture data. If `_mem` is non-NULL, created texture will be immutable. If { default = NULL } --- `_mem` is NULL content of the texture is uninitialized. When `_numLayers` is more than --- 1, expected memory layout is texture and all mips together for each array element. .external "uint64_t" --- Native API pointer to texture. { default = 0 } --- Create Cube texture. func.createTextureCube { section = "Textures" } "TextureHandle" --- Texture handle. .size "uint16_t" --- Cube side size. .hasMips "bool" --- Indicates that texture contains full mip-map chain. .numLayers "uint16_t" --- Number of layers in texture array. Must be 1 if caps --- `BGFX_CAPS_TEXTURE_2D_ARRAY` flag is not set. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .flags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) { default = "BGFX_TEXTURE_NONE|BGFX_SAMPLER_NONE" } --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. .mem "const Memory*" --- Texture data. If `_mem` is non-NULL, created texture will be immutable. If { default = NULL } --- `_mem` is NULL content of the texture is uninitialized. When `_numLayers` is more than .external "uint64_t" --- Native API pointer to texture. { default = 0 } --- Update 2D texture. --- --- @attention It's valid to update only mutable texture. See `bgfx::createTexture2D` for more info. --- func.updateTexture2D { section = "Textures" } "void" .handle "TextureHandle" --- Texture handle. .layer "uint16_t" --- Layer in texture array. .mip "uint8_t" --- Mip level. .x "uint16_t" --- X offset in texture. .y "uint16_t" --- Y offset in texture. .width "uint16_t" --- Width of texture block. .height "uint16_t" --- Height of texture block. .mem "const Memory*" --- Texture update data. .pitch "uint16_t" --- Pitch of input image (bytes). When _pitch is set to --- UINT16_MAX, it will be calculated internally based on _width. { default = UINT16_MAX } --- Update 3D texture. --- --- @attention It's valid to update only mutable texture. See `bgfx::createTexture3D` for more info. --- func.updateTexture3D { section = "Textures" } "void" .handle "TextureHandle" --- Texture handle. .mip "uint8_t" --- Mip level. .x "uint16_t" --- X offset in texture. .y "uint16_t" --- Y offset in texture. .z "uint16_t" --- Z offset in texture. .width "uint16_t" --- Width of texture block. .height "uint16_t" --- Height of texture block. .depth "uint16_t" --- Depth of texture block. .mem "const Memory*" --- Texture update data. --- Update Cube texture. --- --- @attention It's valid to update only mutable texture. See `bgfx::createTextureCube` for more info. --- func.updateTextureCube { section = "Textures" } "void" .handle "TextureHandle" --- Texture handle. .layer "uint16_t" --- Layer in texture array. .side "uint8_t" --- Cubemap side `BGFX_CUBE_MAP__`, --- where 0 is +X, 1 is -X, 2 is +Y, 3 is -Y, 4 is +Z, and 5 is -Z. --- --- +----------+ --- |-z 2| --- | ^ +y | --- | | | Unfolded cube: --- | +---->+x | --- +----------+----------+----------+----------+ --- |+y 1|+y 4|+y 0|+y 5| --- | ^ -x | ^ +z | ^ +x | ^ -z | --- | | | | | | | | | --- | +---->+z | +---->+x | +---->-z | +---->-x | --- +----------+----------+----------+----------+ --- |+z 3| --- | ^ -y | --- | | | --- | +---->+x | --- +----------+ .mip "uint8_t" --- Mip level. .x "uint16_t" --- X offset in texture. .y "uint16_t" --- Y offset in texture. .width "uint16_t" --- Width of texture block. .height "uint16_t" --- Height of texture block. .mem "const Memory*" --- Texture update data. .pitch "uint16_t" --- Pitch of input image (bytes). When _pitch is set to --- UINT16_MAX, it will be calculated internally based on _width. { default = UINT16_MAX } --- Read back texture content. --- --- @attention Texture must be created with `BGFX_TEXTURE_READ_BACK` flag. --- @attention Availability depends on: `BGFX_CAPS_TEXTURE_READ_BACK`. --- func.readTexture { section = "Textures" } "uint32_t" --- Frame number when the result will be available. See: `bgfx::frame`. .handle "TextureHandle" --- Texture handle. .data "void*" --- Destination buffer. .mip "uint8_t" --- Mip level. { default = 0 } --- Set texture debug name. func.setName { cname = "set_texture_name", section = "Debug" } "void" .handle "TextureHandle" --- Texture handle. .name "const char*" --- Texture name. .len "int32_t" --- Texture name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string. --- Returns texture direct access pointer. --- --- @attention Availability depends on: `BGFX_CAPS_TEXTURE_DIRECT_ACCESS`. This feature --- is available on GPUs that have unified memory architecture (UMA) support. --- func.getDirectAccessPtr { section = "Textures" } "void*" --- Pointer to texture memory. If returned pointer is `NULL` direct access --- is not available for this texture. If pointer is `UINTPTR_MAX` sentinel value --- it means texture is pending creation. Pointer returned can be cached and it --- will be valid until texture is destroyed. .handle "TextureHandle" --- Texture handle. --- Destroy texture. func.destroy { cname = "destroy_texture", section = "Textures" } "void" .handle "TextureHandle" --- Texture handle. --- Create frame buffer (simple). func.createFrameBuffer { section = "Frame Buffers" } "FrameBufferHandle" --- Frame buffer handle. .width "uint16_t" --- Texture width. .height "uint16_t" --- Texture height. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .textureFlags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) { default = "BGFX_SAMPLER_U_CLAMP|BGFX_SAMPLER_V_CLAMP" } --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. --- Create frame buffer with size based on back-buffer ratio. Frame buffer will maintain ratio --- if back buffer resolution changes. func.createFrameBuffer { cname = "create_frame_buffer_scaled", section = "Frame Buffers" } "FrameBufferHandle" --- Frame buffer handle. .ratio "BackbufferRatio::Enum" --- Frame buffer size in respect to back-buffer size. See: --- `BackbufferRatio::Enum`. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .textureFlags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) { default = "BGFX_SAMPLER_U_CLAMP|BGFX_SAMPLER_V_CLAMP" } --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. --- Create MRT frame buffer from texture handles (simple). func.createFrameBuffer { cname = "create_frame_buffer_from_handles", section = "Frame Buffers" } "FrameBufferHandle" --- Frame buffer handle. .num "uint8_t" --- Number of texture handles. .handles "const TextureHandle*" --- Texture attachments. .destroyTexture "bool" --- If true, textures will be destroyed when { default = false } --- frame buffer is destroyed. --- Create MRT frame buffer from texture handles with specific layer and --- mip level. func.createFrameBuffer { cname = "create_frame_buffer_from_attachment", section = "Frame Buffers" } "FrameBufferHandle" --- Frame buffer handle. .num "uint8_t" --- Number of attachments. .attachment "const Attachment*" --- Attachment texture info. See: `bgfx::Attachment`. .destroyTexture "bool" --- If true, textures will be destroyed when { default = false } --- frame buffer is destroyed. --- Create frame buffer for multiple window rendering. --- --- @remarks --- Frame buffer cannot be used for sampling. --- --- @attention Availability depends on: `BGFX_CAPS_SWAP_CHAIN`. --- func.createFrameBuffer { cname = "create_frame_buffer_from_nwh", section = "Frame Buffers" } "FrameBufferHandle" --- Frame buffer handle. .nwh "void*" --- OS' target native window handle. .width "uint16_t" --- Window back buffer width. .height "uint16_t" --- Window back buffer height. .format "TextureFormat::Enum" --- Window back buffer color format. { default = "TextureFormat::Count" } .depthFormat "TextureFormat::Enum" --- Window back buffer depth format. { default = "TextureFormat::Count" } --- Set frame buffer debug name. func.setName { cname = "set_frame_buffer_name", section = "Frame Buffers" } "void" .handle "FrameBufferHandle" --- Frame buffer handle. .name "const char*" --- Frame buffer name. .len "int32_t" --- Frame buffer name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string. --- Obtain texture handle of frame buffer attachment. func.getTexture { section = "Frame Buffers" } "TextureHandle" .handle "FrameBufferHandle" --- Frame buffer handle. .attachment "uint8_t" { default = 0 } --- Destroy frame buffer. func.destroy { cname = "destroy_frame_buffer", section = "Frame Buffers" } "void" .handle "FrameBufferHandle" --- Frame buffer handle. --- Create shader uniform parameter. --- --- @remarks --- 1. Uniform names are unique. It's valid to call `bgfx::createUniform` --- multiple times with the same uniform name. The library will always --- return the same handle, but the handle reference count will be --- incremented. This means that the same number of `bgfx::destroyUniform` --- must be called to properly destroy the uniform. --- --- 2. Predefined uniforms (declared in `bgfx_shader.sh`): --- - `u_viewRect vec4(x, y, width, height)` - view rectangle for current --- view, in pixels. --- - `u_viewTexel vec4(1.0/width, 1.0/height, undef, undef)` - inverse --- width and height --- - `u_view mat4` - view matrix --- - `u_invView mat4` - inverted view matrix --- - `u_proj mat4` - projection matrix --- - `u_invProj mat4` - inverted projection matrix --- - `u_viewProj mat4` - concatenated view projection matrix --- - `u_invViewProj mat4` - concatenated inverted view projection matrix --- - `u_model mat4[BGFX_CONFIG_MAX_BONES]` - array of model matrices. --- - `u_modelView mat4` - concatenated model view matrix, only first --- model matrix from array is used. --- - `u_invModelView mat4` - inverted concatenated model view matrix. --- - `u_modelViewProj mat4` - concatenated model view projection matrix. --- - `u_alphaRef float` - alpha reference value for alpha test. --- func.createUniform { section = "Uniforms" } "UniformHandle" --- Handle to uniform object. .name "const char*" --- Uniform name in shader. .type "UniformType::Enum" --- Type of uniform (See: `bgfx::UniformType`). .num "uint16_t" --- Number of elements in array. { default = 1 } --- Create shader uniform parameter. --- --- @remarks --- 1. Uniform names are unique. It's valid to call `bgfx::createUniform` --- multiple times with the same uniform name. The library will always --- return the same handle, but the handle reference count will be --- incremented. This means that the same number of `bgfx::destroyUniform` --- must be called to properly destroy the uniform. --- --- 2. Predefined uniforms (declared in `bgfx_shader.sh`): --- - `u_viewRect vec4(x, y, width, height)` - view rectangle for current --- view, in pixels. --- - `u_viewTexel vec4(1.0/width, 1.0/height, undef, undef)` - inverse --- width and height --- - `u_view mat4` - view matrix --- - `u_invView mat4` - inverted view matrix --- - `u_proj mat4` - projection matrix --- - `u_invProj mat4` - inverted projection matrix --- - `u_viewProj mat4` - concatenated view projection matrix --- - `u_invViewProj mat4` - concatenated inverted view projection matrix --- - `u_model mat4[BGFX_CONFIG_MAX_BONES]` - array of model matrices. --- - `u_modelView mat4` - concatenated model view matrix, only first --- model matrix from array is used. --- - `u_invModelView mat4` - inverted concatenated model view matrix. --- - `u_modelViewProj mat4` - concatenated model view projection matrix. --- - `u_alphaRef float` - alpha reference value for alpha test. --- func.createUniform { cname = "create_uniform_with_freq", section = "Uniforms" } "UniformHandle" --- Handle to uniform object. .name "const char*" --- Uniform name in shader. .freq "UniformFreq::Enum" --- Uniform change frequency (See: `bgfx::UniformFreq`). .type "UniformType::Enum" --- Type of uniform (See: `bgfx::UniformType`). .num "uint16_t" --- Number of elements in array. { default = 1 } --- Retrieve uniform info. func.getUniformInfo { section = "Uniforms" } "void" .handle "UniformHandle" --- Handle to uniform object. .info "UniformInfo &" { out } --- Uniform info. --- Destroy shader uniform parameter. func.destroy { cname = "destroy_uniform", section = "Uniforms" } "void" .handle "UniformHandle" --- Handle to uniform object. --- Create occlusion query. Occlusion queries allow the GPU to determine --- if any pixels passed the depth test. func.createOcclusionQuery { section = "Occlusion Query" } "OcclusionQueryHandle" --- Handle to occlusion query object. --- Retrieve occlusion query result from previous frame. func.getResult { section = "Occlusion Query" } "OcclusionQueryResult::Enum" --- Occlusion query result. .handle "OcclusionQueryHandle" --- Handle to occlusion query object. .result "int32_t*" { out } --- Number of pixels that passed test. This argument --- can be `NULL` if result of occlusion query is not needed. { default = NULL } --- Destroy occlusion query. func.destroy { cname = "destroy_occlusion_query", section = "Occlusion Query" } "void" .handle "OcclusionQueryHandle" --- Handle to occlusion query object. --- Set palette color value. func.setPaletteColor { section = "Miscellaneous" } "void" .index "uint8_t" --- Index into palette. .rgba "const float[4]" --- RGBA floating point values. --- Set palette color value. func.setPaletteColor { cname = "set_palette_color_rgba32f", section = "Miscellaneous" } "void" .index "uint8_t" --- Index into palette. .r "float" --- Red value (RGBA floating point values) .g "float" --- Green value (RGBA floating point values) .b "float" --- Blue value (RGBA floating point values) .a "float" --- Alpha value (RGBA floating point values) --- Set palette color value. func.setPaletteColor { cname = "set_palette_color_rgba8", section = "Miscellaneous" } "void" .index "uint8_t" --- Index into palette. .rgba "uint32_t" --- Packed 32-bit RGBA value. --- Set view name. --- --- @remarks --- This is debug only feature. --- --- In graphics debugger view name will appear as: --- --- "nnnc " --- ^ ^ ^ --- | +--- compute (C) --- +------ view id --- func.setViewName { section = "Views" } "void" .id "ViewId" --- View id. .name "const char*" --- View name. .len "int32_t" --- View name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string. --- Set view rectangle. Draw primitive outside view will be clipped. func.setViewRect { section = "Views" } "void" .id "ViewId" --- View id. .x "uint16_t" --- Position x from the left corner of the window. .y "uint16_t" --- Position y from the top corner of the window. .width "uint16_t" --- Width of view port region. .height "uint16_t" --- Height of view port region. --- Set view rectangle. Draw primitive outside view will be clipped. func.setViewRect { cname = "set_view_rect_ratio", section = "Views" } "void" .id "ViewId" --- View id. .x "uint16_t" --- Position x from the left corner of the window. .y "uint16_t" --- Position y from the top corner of the window. .ratio "BackbufferRatio::Enum" --- Width and height will be set in respect to back-buffer size. --- See: `BackbufferRatio::Enum`. --- Set view scissor. Draw primitive outside view will be clipped. When --- _x, _y, _width and _height are set to 0, scissor will be disabled. func.setViewScissor { section = "Views" } "void" .id "ViewId" --- View id. .x "uint16_t" --- Position x from the left corner of the window. { default = 0 } .y "uint16_t" --- Position y from the top corner of the window. { default = 0 } .width "uint16_t" --- Width of view scissor region. { default = 0 } .height "uint16_t" --- Height of view scissor region. { default = 0 } --- Set view clear flags. func.setViewClear { section = "Views" } "void" .id "ViewId" --- View id. .flags "uint16_t" --- Clear flags. Use `BGFX_CLEAR_NONE` to remove any clear --- operation. See: `BGFX_CLEAR_*`. .rgba "uint32_t" --- Color clear value. { default = "0x000000ff" } .depth "float" --- Depth clear value. { default = "1.0f" } .stencil "uint8_t" --- Stencil clear value. { default = 0 } --- Set view clear flags with different clear color for each --- frame buffer texture. `bgfx::setPaletteColor` must be used to set up a --- clear color palette. func.setViewClear { cname = "set_view_clear_mrt", section = "Views" } "void" .id "ViewId" --- View id. .flags "uint16_t" --- Clear flags. Use `BGFX_CLEAR_NONE` to remove any clear --- operation. See: `BGFX_CLEAR_*`. .depth "float" --- Depth clear value. .stencil "uint8_t" --- Stencil clear value. .c0 "uint8_t" --- Palette index for frame buffer attachment 0. { default = UINT8_MAX } .c1 "uint8_t" --- Palette index for frame buffer attachment 1. { default = UINT8_MAX } .c2 "uint8_t" --- Palette index for frame buffer attachment 2. { default = UINT8_MAX } .c3 "uint8_t" --- Palette index for frame buffer attachment 3. { default = UINT8_MAX } .c4 "uint8_t" --- Palette index for frame buffer attachment 4. { default = UINT8_MAX } .c5 "uint8_t" --- Palette index for frame buffer attachment 5. { default = UINT8_MAX } .c6 "uint8_t" --- Palette index for frame buffer attachment 6. { default = UINT8_MAX } .c7 "uint8_t" --- Palette index for frame buffer attachment 7. { default = UINT8_MAX } --- Set view sorting mode. --- --- @remarks --- View mode must be set prior calling `bgfx::submit` for the view. --- func.setViewMode { section = "Views" } "void" .id "ViewId" --- View id. .mode "ViewMode::Enum" --- View sort mode. See `ViewMode::Enum`. { default = "ViewMode::Default" } --- Set view frame buffer. --- --- @remarks --- Not persistent after `bgfx::reset` call. --- func.setViewFrameBuffer { section = "Views" } "void" .id "ViewId" --- View id. .handle "FrameBufferHandle" --- Frame buffer handle. Passing `BGFX_INVALID_HANDLE` as --- frame buffer handle will draw primitives from this view into --- default back buffer. --- Set view's view matrix and projection matrix, --- all draw primitives in this view will use these two matrices. func.setViewTransform { section = "Views" } "void" .id "ViewId" --- View id. .view "const void*" --- View matrix. .proj "const void*" --- Projection matrix. --- Post submit view reordering. func.setViewOrder { section = "Views" } "void" .id "ViewId" --- First view id. { default = 0 } .num "uint16_t" --- Number of views to remap. { default = UINT16_MAX } .order "const ViewId*" --- View remap id table. Passing `NULL` will reset view ids --- to default state. { default = NULL } --- Set view shading rate. --- --- @attention Availability depends on: `BGFX_CAPS_VARIABLE_RATE_SHADING`. --- func.setViewShadingRate { section = "Views" } "void" .id "ViewId" --- View id. .shadingRate "ShadingRate::Enum" --- Shading rate. { default = "ShadingRate::Rate1x1" } --- Reset all view settings to default. func.resetView { section = "Views" } "void" .id "ViewId" --- _id View id. --- Begin submitting draw calls from thread. func.begin { cname = "encoder_begin", section = "Encoder" } "Encoder*" --- Encoder. .forThread "bool" --- Explicitly request an encoder for a worker thread. { default = false } --- End submitting draw calls from thread. func["end"] { cname = "encoder_end", section = "Encoder" } "void" .encoder "Encoder*" --- Encoder. --- Sets a debug marker. This allows you to group graphics calls together for easy browsing in --- graphics debugging tools. func.Encoder.setMarker { section = "Debug" } "void" .name "const char*" --- Marker name. .len "int32_t" --- Marker name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string. --- Set render states for draw primitive. --- --- @remarks --- 1. To set up more complex states use: --- `BGFX_STATE_ALPHA_REF(_ref)`, --- `BGFX_STATE_POINT_SIZE(_size)`, --- `BGFX_STATE_BLEND_FUNC(_src, _dst)`, --- `BGFX_STATE_BLEND_FUNC_SEPARATE(_srcRGB, _dstRGB, _srcA, _dstA)`, --- `BGFX_STATE_BLEND_EQUATION(_equation)`, --- `BGFX_STATE_BLEND_EQUATION_SEPARATE(_equationRGB, _equationA)` --- 2. `BGFX_STATE_BLEND_EQUATION_ADD` is set when no other blend --- equation is specified. --- func.Encoder.setState { section = "State" } "void" .state "uint64_t" --- State flags. Default state for primitive type is --- triangles. See: `BGFX_STATE_DEFAULT`. --- - `BGFX_STATE_DEPTH_TEST_*` - Depth test function. --- - `BGFX_STATE_BLEND_*` - See remark 1 about BGFX_STATE_BLEND_FUNC. --- - `BGFX_STATE_BLEND_EQUATION_*` - See remark 2. --- - `BGFX_STATE_CULL_*` - Backface culling mode. --- - `BGFX_STATE_WRITE_*` - Enable R, G, B, A or Z write. --- - `BGFX_STATE_MSAA` - Enable hardware multisample antialiasing. --- - `BGFX_STATE_PT_[TRISTRIP/LINES/POINTS]` - Primitive type. .rgba "uint32_t" --- Sets blend factor used by `BGFX_STATE_BLEND_FACTOR` and --- `BGFX_STATE_BLEND_INV_FACTOR` blend modes. { default = 0 } --- Set condition for rendering. func.Encoder.setCondition { section = "Conditional Rendering" } "void" .handle "OcclusionQueryHandle" --- Occlusion query handle. .visible "bool" --- Render if occlusion query is visible. --- Set stencil test state. func.Encoder.setStencil { section = "Stencil" } "void" .fstencil "uint32_t" --- Front stencil state. .bstencil "uint32_t" --- Back stencil state. If back is set to `BGFX_STENCIL_NONE` --- _fstencil is applied to both front and back facing primitives. { default = "BGFX_STENCIL_NONE" } --- Set scissor for draw primitive. --- --- @remark --- To scissor for all primitives in view see `bgfx::setViewScissor`. --- func.Encoder.setScissor { section = "Scissor" } "uint16_t" --- Scissor cache index. .x "uint16_t" --- Position x from the left corner of the window. .y "uint16_t" --- Position y from the top corner of the window. .width "uint16_t" --- Width of view scissor region. .height "uint16_t" --- Height of view scissor region. --- Set scissor from cache for draw primitive. --- --- @remark --- To scissor for all primitives in view see `bgfx::setViewScissor`. --- func.Encoder.setScissor { cname = "set_scissor_cached", section = "Scissor" } "void" .cache "uint16_t" --- Index in scissor cache. { default = UINT16_MAX } --- Set model matrix for draw primitive. If it is not called, --- the model will be rendered with an identity model matrix. func.Encoder.setTransform { section = "Transform" } "uint32_t" --- Index into matrix cache in case the same model matrix has --- to be used for other draw primitive call. .mtx "const void*" --- Pointer to first matrix in array. .num "uint16_t" --- Number of matrices in array. { default = 1 } --- Set model matrix from matrix cache for draw primitive. func.Encoder.setTransform { cname = "set_transform_cached", section = "Transform" } "void" .cache "uint32_t" --- Index in matrix cache. .num "uint16_t" --- Number of matrices from cache. { default = 1 } --- Reserve matrices in internal matrix cache. --- --- @attention Pointer returned can be modified until `bgfx::frame` is called. --- func.Encoder.allocTransform { section = "Transform" } "uint32_t" --- Index in matrix cache. .transform "Transform*" { out } --- Pointer to `Transform` structure. .num "uint16_t" --- Number of matrices. --- Set shader uniform parameter for draw primitive. func.Encoder.setUniform { section = "Draw/Uniforms" } "void" .handle "UniformHandle" --- Uniform. .value "const void*" --- Pointer to uniform data. .num "uint16_t" --- Number of elements. Passing `UINT16_MAX` will --- use the _num passed on uniform creation. { default = 1 } --- Set shader uniform parameter for view. --- --- @attention Uniform must be created with `bgfx::UniformFreq::View` argument. --- func.setViewUniform { section = "Draw/Uniforms" } "void" .id "ViewId" --- View id. .handle "UniformHandle" --- Uniform. .value "const void*" --- Pointer to uniform data. .num "uint16_t" --- Number of elements. Passing `UINT16_MAX` will --- use the _num passed on uniform creation. { default = 1 } --- Set shader uniform parameter for frame. --- --- @attention Uniform must be created with `bgfx::UniformFreq::View` argument. --- func.setFrameUniform { section = "Draw/Uniforms" } "void" .handle "UniformHandle" --- Uniform. .value "const void*" --- Pointer to uniform data. .num "uint16_t" --- Number of elements. Passing `UINT16_MAX` will --- use the _num passed on uniform creation. { default = 1 } --- Set index buffer for draw primitive. func.Encoder.setIndexBuffer { cpponly, section = "Draw/Buffers" } "void" .handle "IndexBufferHandle" --- Index buffer. --- Set index buffer for draw primitive. func.Encoder.setIndexBuffer { section = "Draw/Buffers" } "void" .handle "IndexBufferHandle" --- Index buffer. .firstIndex "uint32_t" --- First index to render. .numIndices "uint32_t" --- Number of indices to render. --- Set index buffer for draw primitive. func.Encoder.setIndexBuffer { cpponly, section = "Draw/Buffers" } "void" .handle "DynamicIndexBufferHandle" --- Dynamic index buffer. --- Set index buffer for draw primitive. func.Encoder.setIndexBuffer { cname = "set_dynamic_index_buffer", section = "Draw/Buffers" } "void" .handle "DynamicIndexBufferHandle" --- Dynamic index buffer. .firstIndex "uint32_t" --- First index to render. .numIndices "uint32_t" --- Number of indices to render. --- Set index buffer for draw primitive. func.Encoder.setIndexBuffer { cpponly, section = "Draw/Buffers" } "void" .tib "const TransientIndexBuffer*" --- Transient index buffer. --- Set index buffer for draw primitive. func.Encoder.setIndexBuffer { cname = "set_transient_index_buffer", section = "Draw/Buffers" } "void" .tib "const TransientIndexBuffer*" --- Transient index buffer. .firstIndex "uint32_t" --- First index to render. .numIndices "uint32_t" --- Number of indices to render. --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { cpponly } "void" .stream "uint8_t" --- Vertex stream. .handle "VertexBufferHandle" --- Vertex buffer. --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { conly } "void" .stream "uint8_t" --- Vertex stream. .handle "VertexBufferHandle" --- Vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { cname = "set_vertex_buffer_with_layout", section = "Draw/Buffers" } "void" .stream "uint8_t" --- Vertex stream. .handle "VertexBufferHandle" --- Vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. If invalid --- handle is used, vertex layout used for creation --- of vertex buffer will be used. { default = "BGFX_INVALID_HANDLE" } --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { cpponly } "void" .stream "uint8_t" --- Vertex stream. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { conly, cname = "set_dynamic_vertex_buffer" } "void" .stream "uint8_t" --- Vertex stream. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { cname = "set_dynamic_vertex_buffer_with_layout", section = "Draw/Buffers" } "void" .stream "uint8_t" --- Vertex stream. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. If invalid --- handle is used, vertex layout used for creation --- of vertex buffer will be used. { default = "BGFX_INVALID_HANDLE" } --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { cpponly } "void" .stream "uint8_t" --- Vertex stream. .tvb "const TransientVertexBuffer*" --- Transient vertex buffer. --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { conly, cname = "set_transient_vertex_buffer" } "void" .stream "uint8_t" --- Vertex stream. .tvb "const TransientVertexBuffer*" --- Transient vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. --- Set vertex buffer for draw primitive. func.Encoder.setVertexBuffer { cname = "set_transient_vertex_buffer_with_layout", section = "Draw/Buffers" } "void" .stream "uint8_t" --- Vertex stream. .tvb "const TransientVertexBuffer*" --- Transient vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. If invalid --- handle is used, vertex layout used for creation --- of vertex buffer will be used. { default = "BGFX_INVALID_HANDLE" } --- Set number of vertices for auto generated vertices use in conjunction --- with gl_VertexID. --- --- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. --- func.Encoder.setVertexCount { section = "Draw/Buffers" } "void" .numVertices "uint32_t" --- Number of vertices. --- Set instance data buffer for draw primitive. func.Encoder.setInstanceDataBuffer { cpponly, section = "Draw/Buffers" } "void" .idb "const InstanceDataBuffer*" --- Transient instance data buffer. --- Set instance data buffer for draw primitive. func.Encoder.setInstanceDataBuffer { section = "Draw/Buffers" } "void" .idb "const InstanceDataBuffer*" --- Transient instance data buffer. .start "uint32_t" --- First instance data. .num "uint32_t" --- Number of data instances. --- Set instance data buffer for draw primitive. func.Encoder.setInstanceDataBuffer { cname = "set_instance_data_from_vertex_buffer", section = "Draw/Buffers" } "void" .handle "VertexBufferHandle" --- Vertex buffer. .startVertex "uint32_t" --- First instance data. .num "uint32_t" --- Number of data instances. --- Set instance data buffer for draw primitive. func.Encoder.setInstanceDataBuffer { cname = "set_instance_data_from_dynamic_vertex_buffer", section = "Draw/Buffers" } "void" .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. .startVertex "uint32_t" --- First instance data. .num "uint32_t" --- Number of data instances. --- Set number of instances for auto generated instances use in conjunction --- with gl_InstanceID. --- --- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. --- func.Encoder.setInstanceCount { section = "Draw/Buffers" } "void" .numInstances "uint32_t" --- Number of instances. --- Set texture stage for draw primitive. func.Encoder.setTexture { section = "Draw/Textures" } "void" .stage "uint8_t" --- Texture unit. .sampler "UniformHandle" --- Program sampler. .handle "TextureHandle" --- Texture handle. .flags "uint32_t" --- Texture sampling mode. Default value UINT32_MAX uses { default = UINT32_MAX } --- texture sampling settings from the texture. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. --- Submit an empty primitive for rendering. Uniforms and draw state --- will be applied but no geometry will be submitted. Useful in cases --- when no other draw/compute primitive is submitted to view, but it's --- desired to execute clear view. --- --- @remark --- These empty draw calls will sort before ordinary draw calls. --- func.Encoder.touch { section = "Miscellaneous" } "void" .id "ViewId" --- View id. --- Submit primitive for rendering. func.Encoder.submit { section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Submit primitive with occlusion query for rendering. func.Encoder.submit { cname = "submit_occlusion_query", section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .occlusionQuery "OcclusionQueryHandle" --- Occlusion query. .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Submit primitive for rendering with index and instance data info from --- indirect buffer. --- --- @attention Availability depends on: `BGFX_CAPS_DRAW_INDIRECT`. --- func.Encoder.submit { cname = "submit_indirect", section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .indirectHandle "IndirectBufferHandle" --- Indirect buffer. .start "uint32_t" --- First element in indirect buffer. { default = 0 } .num "uint32_t" --- Number of draws. { default = 1 } .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Submit primitive for rendering with index and instance data info and --- draw count from indirect buffers. --- --- @attention Availability depends on: `BGFX_CAPS_DRAW_INDIRECT_COUNT`. --- func.Encoder.submit { cname = "submit_indirect_count", section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .indirectHandle "IndirectBufferHandle" --- Indirect buffer. .start "uint32_t" --- First element in indirect buffer. .numHandle "IndexBufferHandle" --- Buffer for number of draws. Must be --- created with `BGFX_BUFFER_INDEX32` and `BGFX_BUFFER_DRAW_INDIRECT`. .numIndex "uint32_t" --- Element in number buffer. { default = 0 } .numMax "uint32_t" --- Max number of draws. { default = UINT32_MAX } .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Set compute index buffer. func.Encoder.setBuffer { cname = "set_compute_index_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "IndexBufferHandle" --- Index buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute vertex buffer. func.Encoder.setBuffer { cname = "set_compute_vertex_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "VertexBufferHandle" --- Vertex buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute dynamic index buffer. func.Encoder.setBuffer { cname = "set_compute_dynamic_index_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "DynamicIndexBufferHandle" --- Dynamic index buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute dynamic vertex buffer. func.Encoder.setBuffer { cname = "set_compute_dynamic_vertex_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute indirect buffer. func.Encoder.setBuffer { cname = "set_compute_indirect_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "IndirectBufferHandle" --- Indirect buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute image from texture. func.Encoder.setImage { section = "Images" } "void" .stage "uint8_t" --- Compute stage. .handle "TextureHandle" --- Texture handle. .mip "uint8_t" --- Mip level. .access "Access::Enum" --- Image access. See `Access::Enum`. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. { default = "TextureFormat::Count" } --- Dispatch compute. func.Encoder.dispatch { section = "Dispatch" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Compute program. .numX "uint32_t" --- Number of groups X. { default = 1 } .numY "uint32_t" --- Number of groups Y. { default = 1 } .numZ "uint32_t" --- Number of groups Z. { default = 1 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Dispatch compute indirect. func.Encoder.dispatch { cname = "dispatch_indirect", section = "Dispatch" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Compute program. .indirectHandle "IndirectBufferHandle" --- Indirect buffer. .start "uint32_t" --- First element in indirect buffer. { default = 0 } .num "uint32_t" --- Number of dispatches. { default = 1 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Discard previously set state for draw or compute call. func.Encoder.discard { section = "Miscellaneous" } "void" .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Blit 2D texture region between two 2D textures. --- --- @attention Destination texture must be created with `BGFX_TEXTURE_BLIT_DST` flag. --- @attention Availability depends on: `BGFX_CAPS_TEXTURE_BLIT`. --- func.Encoder.blit { cpponly, section = "Blit" } "void" .id "ViewId" --- View id. .dst "TextureHandle" --- Destination texture handle. .dstX "uint16_t" --- Destination texture X position. .dstY "uint16_t" --- Destination texture Y position. .src "TextureHandle" --- Source texture handle. .srcX "uint16_t" --- Source texture X position. { default = 0 } .srcY "uint16_t" --- Source texture Y position. { default = 0 } .width "uint16_t" --- Width of region. { default = UINT16_MAX } .height "uint16_t" --- Height of region. { default = UINT16_MAX } --- Blit 2D texture region between two 2D textures. --- --- @attention Destination texture must be created with `BGFX_TEXTURE_BLIT_DST` flag. --- @attention Availability depends on: `BGFX_CAPS_TEXTURE_BLIT`. --- func.Encoder.blit { section = "Blit" } "void" .id "ViewId" --- View id. .dst "TextureHandle" --- Destination texture handle. .dstMip "uint8_t" --- Destination texture mip level. .dstX "uint16_t" --- Destination texture X position. .dstY "uint16_t" --- Destination texture Y position. .dstZ "uint16_t" --- If texture is 2D this argument should be 0. If destination texture is cube --- this argument represents destination texture cube face. For 3D texture this argument --- represents destination texture Z position. .src "TextureHandle" --- Source texture handle. .srcMip "uint8_t" --- Source texture mip level. { default = 0 } .srcX "uint16_t" --- Source texture X position. { default = 0 } .srcY "uint16_t" --- Source texture Y position. { default = 0 } .srcZ "uint16_t" --- If texture is 2D this argument should be 0. If source texture is cube --- this argument represents source texture cube face. For 3D texture this argument --- represents source texture Z position. { default = 0 } .width "uint16_t" --- Width of region. { default = UINT16_MAX } .height "uint16_t" --- Height of region. { default = UINT16_MAX } .depth "uint16_t" --- If texture is 3D this argument represents depth of region, otherwise it's --- unused. { default = UINT16_MAX } --- Request screen shot of window back buffer. --- --- @remarks --- `bgfx::CallbackI::screenShot` must be implemented. --- @attention Frame buffer handle must be created with OS' target native window handle. --- func.requestScreenShot { section = "Miscellaneous" } "void" .handle "FrameBufferHandle" --- Frame buffer handle. If handle is `BGFX_INVALID_HANDLE` request will be --- made for main window back buffer. .filePath "const char*" --- Will be passed to `bgfx::CallbackI::screenShot` callback. --- Render frame. Executes the actual GPU rendering work for one frame. --- --- In the default **multithreaded** configuration, `bgfx::renderFrame` runs --- on the **render thread** while `bgfx::frame` runs on the **API thread**. --- Their interaction is as follows: --- --- 1. The render thread calls `bgfx::renderFrame`, which blocks waiting --- for the API thread to signal that a new frame is ready. --- 2. On the API thread, `bgfx::frame` finishes building the frame, --- swaps internal submit/render buffers, and signals the render thread. --- 3. `bgfx::renderFrame` wakes up, executes pre-render commands, --- submits GPU draw calls, executes post-render commands, flips the --- back buffer, then signals back to the API thread that rendering --- is complete. --- 4. The API thread's next `bgfx::frame` call waits for this completion --- signal before swapping buffers again. --- --- This double-buffered semaphore handshake allows the API thread and --- render thread to run in parallel, overlapping CPU frame building with --- GPU rendering. --- --- @attention `bgfx::renderFrame` is a blocking call. It waits for --- `bgfx::frame` to be called from the API thread to process the frame. --- If a timeout value is passed, the call will return --- `RenderFrame::Timeout` even if `bgfx::frame` has not been called. --- A value of -1 (default) means wait indefinitely (up to --- `BGFX_CONFIG_API_SEMAPHORE_TIMEOUT`). --- --- @warning This call should only be used on platforms that don't allow --- creating a separate rendering thread. If it is called before --- `bgfx::init`, the internal render thread won't be created by the --- `bgfx::init` call, and the user is responsible for calling --- `bgfx::renderFrame` on the render thread each frame. If both --- `bgfx::renderFrame` and `bgfx::init` are called from the same --- thread, bgfx operates in single-threaded mode and `bgfx::frame` --- will internally invoke `bgfx::renderFrame` automatically. --- See also: `bgfx::frame`. --- func.renderFrame { section = "Platform specific" } "RenderFrame::Enum" --- Current renderer context state. See: `bgfx::RenderFrame`. .msecs "int32_t" --- Timeout in milliseconds. { default = -1 } --- Set platform data. --- --- @warning Must be called before `bgfx::init`. --- func.setPlatformData { section = "Platform specific" } "void" .data "const PlatformData &" --- Platform data. --- Get internal data for interop. --- --- @attention It's expected you understand some bgfx internals before you --- use this call. --- --- @warning Must be called only on render thread. --- func.getInternalData { section = "Platform specific" } "const InternalData*" --- Internal data. --- Override internal texture with externally created texture. Previously --- created internal texture will released. --- --- @attention It's expected you understand some bgfx internals before you --- use this call. --- --- @warning Must be called only on render thread. --- func.overrideInternal { cname = "override_internal_texture_ptr", section = "Platform specific" } "uintptr_t" --- Native API pointer to texture. If result is 0, texture is not created --- yet from the main thread. .handle "TextureHandle" --- Texture handle. .ptr "uintptr_t" --- Native API pointer to texture. .layerIndex "uint16_t" --- Layer index for texture arrays (only implemented for D3D11). { default = 0 } --- Override internal texture by creating new texture. Previously created --- internal texture will released. --- --- @attention It's expected you understand some bgfx internals before you --- use this call. --- --- @returns Native API pointer to texture. If result is 0, texture is not created yet from the --- main thread. --- --- @warning Must be called only on render thread. --- func.overrideInternal { cname = "override_internal_texture", section = "Platform specific" } "uintptr_t" --- Native API pointer to texture. If result is 0, texture is not created --- yet from the main thread. .handle "TextureHandle" --- Texture handle. .width "uint16_t" --- Width. .height "uint16_t" --- Height. .numMips "uint8_t" --- Number of mip-maps. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. .flags "uint64_t" --- Texture creation (see `BGFX_TEXTURE_*`.), and sampler (see `BGFX_SAMPLER_*`) --- flags. Default texture sampling mode is linear, and wrap mode is repeat. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. { default = "BGFX_TEXTURE_NONE | BGFX_SAMPLER_NONE" } -- Legacy API: --- Sets a debug marker. This allows you to group graphics calls together for easy browsing in --- graphics debugging tools. func.setMarker { section = "Debug" } "void" .name "const char*" --- Marker name. .len "int32_t" --- Marker name length (if length is INT32_MAX, it's expected { default = INT32_MAX } --- that _name is zero terminated string. --- Set render states for draw primitive. --- --- @remarks --- 1. To set up more complex states use: --- `BGFX_STATE_ALPHA_REF(_ref)`, --- `BGFX_STATE_POINT_SIZE(_size)`, --- `BGFX_STATE_BLEND_FUNC(_src, _dst)`, --- `BGFX_STATE_BLEND_FUNC_SEPARATE(_srcRGB, _dstRGB, _srcA, _dstA)`, --- `BGFX_STATE_BLEND_EQUATION(_equation)`, --- `BGFX_STATE_BLEND_EQUATION_SEPARATE(_equationRGB, _equationA)` --- 2. `BGFX_STATE_BLEND_EQUATION_ADD` is set when no other blend --- equation is specified. --- func.setState { section = "State" } "void" .state "uint64_t" --- State flags. Default state for primitive type is --- triangles. See: `BGFX_STATE_DEFAULT`. --- - `BGFX_STATE_DEPTH_TEST_*` - Depth test function. --- - `BGFX_STATE_BLEND_*` - See remark 1 about BGFX_STATE_BLEND_FUNC. --- - `BGFX_STATE_BLEND_EQUATION_*` - See remark 2. --- - `BGFX_STATE_CULL_*` - Backface culling mode. --- - `BGFX_STATE_WRITE_*` - Enable R, G, B, A or Z write. --- - `BGFX_STATE_MSAA` - Enable hardware multisample antialiasing. --- - `BGFX_STATE_PT_[TRISTRIP/LINES/POINTS]` - Primitive type. .rgba "uint32_t" --- Sets blend factor used by `BGFX_STATE_BLEND_FACTOR` and --- `BGFX_STATE_BLEND_INV_FACTOR` blend modes. { default = 0 } --- Set condition for rendering. func.setCondition { section = "Conditional Rendering" } "void" .handle "OcclusionQueryHandle" --- Occlusion query handle. .visible "bool" --- Render if occlusion query is visible. --- Set stencil test state. func.setStencil { section = "Stencil" } "void" .fstencil "uint32_t" --- Front stencil state. .bstencil "uint32_t" --- Back stencil state. If back is set to `BGFX_STENCIL_NONE` --- _fstencil is applied to both front and back facing primitives. { default = "BGFX_STENCIL_NONE" } --- Set scissor for draw primitive. --- --- @remark --- To scissor for all primitives in view see `bgfx::setViewScissor`. --- func.setScissor { section = "Scissor" } "uint16_t" --- Scissor cache index. .x "uint16_t" --- Position x from the left corner of the window. .y "uint16_t" --- Position y from the top corner of the window. .width "uint16_t" --- Width of view scissor region. .height "uint16_t" --- Height of view scissor region. --- Set scissor from cache for draw primitive. --- --- @remark --- To scissor for all primitives in view see `bgfx::setViewScissor`. --- func.setScissor { cname = "set_scissor_cached", section = "Scissor" } "void" .cache "uint16_t" --- Index in scissor cache. { default = UINT16_MAX } --- Set model matrix for draw primitive. If it is not called, --- the model will be rendered with an identity model matrix. func.setTransform { section = "Transform" } "uint32_t" --- Index into matrix cache in case the same model matrix has --- to be used for other draw primitive call. .mtx "const void*" --- Pointer to first matrix in array. .num "uint16_t" --- Number of matrices in array. { default = 1 } --- Set model matrix from matrix cache for draw primitive. func.setTransform { cname = "set_transform_cached", section = "Transform" } "void" .cache "uint32_t" --- Index in matrix cache. .num "uint16_t" --- Number of matrices from cache. { default = 1 } --- Reserve matrices in internal matrix cache. --- --- @attention Pointer returned can be modified until `bgfx::frame` is called. --- func.allocTransform { section = "Transform" } "uint32_t" --- Index in matrix cache. .transform "Transform*" { out } --- Pointer to `Transform` structure. .num "uint16_t" --- Number of matrices. --- Set shader uniform parameter for draw primitive. func.setUniform { section = "Draw/Uniforms" } "void" .handle "UniformHandle" --- Uniform. .value "const void*" --- Pointer to uniform data. .num "uint16_t" --- Number of elements. Passing `UINT16_MAX` will --- use the _num passed on uniform creation. { default = 1 } --- Set index buffer for draw primitive. func.setIndexBuffer { cpponly, section = "Draw/Buffers" } "void" .handle "IndexBufferHandle" --- Index buffer. --- Set index buffer for draw primitive. func.setIndexBuffer { section = "Draw/Buffers" } "void" .handle "IndexBufferHandle" --- Index buffer. .firstIndex "uint32_t" --- First index to render. .numIndices "uint32_t" --- Number of indices to render. --- Set index buffer for draw primitive. func.setIndexBuffer { cpponly, section = "Draw/Buffers" } "void" .handle "DynamicIndexBufferHandle" --- Dynamic index buffer. --- Set index buffer for draw primitive. func.setIndexBuffer { cname = "set_dynamic_index_buffer", section = "Draw/Buffers" } "void" .handle "DynamicIndexBufferHandle" --- Dynamic index buffer. .firstIndex "uint32_t" --- First index to render. .numIndices "uint32_t" --- Number of indices to render. --- Set index buffer for draw primitive. func.setIndexBuffer { cpponly, section = "Draw/Buffers" } "void" .tib "const TransientIndexBuffer*" --- Transient index buffer. --- Set index buffer for draw primitive. func.setIndexBuffer { cname = "set_transient_index_buffer", section = "Draw/Buffers" } "void" .tib "const TransientIndexBuffer*" --- Transient index buffer. .firstIndex "uint32_t" --- First index to render. .numIndices "uint32_t" --- Number of indices to render. --- Set vertex buffer for draw primitive. func.setVertexBuffer { cpponly } "void" .stream "uint8_t" --- Vertex stream. .handle "VertexBufferHandle" --- Vertex buffer. --- Set vertex buffer for draw primitive. func.setVertexBuffer { conly } "void" .stream "uint8_t" --- Vertex stream. .handle "VertexBufferHandle" --- Vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. --- Set vertex buffer for draw primitive. func.setVertexBuffer { cname = "set_vertex_buffer_with_layout", section = "Draw/Buffers" } "void" .stream "uint8_t" --- Vertex stream. .handle "VertexBufferHandle" --- Vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. If invalid --- handle is used, vertex layout used for creation --- of vertex buffer will be used. { default = "BGFX_INVALID_HANDLE" } --- Set vertex buffer for draw primitive. func.setVertexBuffer { cpponly } "void" .stream "uint8_t" --- Vertex stream. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. --- Set vertex buffer for draw primitive. func.setVertexBuffer { conly, cname = "set_dynamic_vertex_buffer" } "void" .stream "uint8_t" --- Vertex stream. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. --- Set vertex buffer for draw primitive. func.setVertexBuffer { cname = "set_dynamic_vertex_buffer_with_layout", section = "Draw/Buffers" } "void" .stream "uint8_t" --- Vertex stream. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. If invalid --- handle is used, vertex layout used for creation --- of vertex buffer will be used. { default = "BGFX_INVALID_HANDLE" } --- Set vertex buffer for draw primitive. func.setVertexBuffer { cpponly } "void" .stream "uint8_t" --- Vertex stream. .tvb "const TransientVertexBuffer*" --- Transient vertex buffer. --- Set vertex buffer for draw primitive. func.setVertexBuffer { conly, cname = "set_transient_vertex_buffer" } "void" .stream "uint8_t" --- Vertex stream. .tvb "const TransientVertexBuffer*" --- Transient vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. --- Set vertex buffer for draw primitive. func.setVertexBuffer { cname = "set_transient_vertex_buffer_with_layout", section = "Draw/Buffers" } "void" .stream "uint8_t" --- Vertex stream. .tvb "const TransientVertexBuffer*" --- Transient vertex buffer. .startVertex "uint32_t" --- First vertex to render. .numVertices "uint32_t" --- Number of vertices to render. .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. If invalid --- handle is used, vertex layout used for creation --- of vertex buffer will be used. { default = "BGFX_INVALID_HANDLE" } --- Set number of vertices for auto generated vertices use in conjunction --- with gl_VertexID. --- --- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. --- func.setVertexCount { section = "Draw/Buffers" } "void" .numVertices "uint32_t" --- Number of vertices. --- Set instance data buffer for draw primitive. func.setInstanceDataBuffer { cpponly, section = "Draw/Buffers" } "void" .idb "const InstanceDataBuffer*" --- Transient instance data buffer. --- Set instance data buffer for draw primitive. func.setInstanceDataBuffer { section = "Draw/Buffers" } "void" .idb "const InstanceDataBuffer*" --- Transient instance data buffer. .start "uint32_t" --- First instance data. .num "uint32_t" --- Number of data instances. --- Set instance data buffer for draw primitive. func.setInstanceDataBuffer { cname = "set_instance_data_from_vertex_buffer", section = "Draw/Buffers" } "void" .handle "VertexBufferHandle" --- Vertex buffer. .startVertex "uint32_t" --- First instance data. .num "uint32_t" --- Number of data instances. --- Set instance data buffer for draw primitive. func.setInstanceDataBuffer { cname = "set_instance_data_from_dynamic_vertex_buffer", section = "Draw/Buffers" } "void" .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. .startVertex "uint32_t" --- First instance data. .num "uint32_t" --- Number of data instances. --- Set number of instances for auto generated instances use in conjunction --- with gl_InstanceID. --- --- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. --- func.setInstanceCount { section = "Draw/Buffers" } "void" .numInstances "uint32_t" --- Number of instances. --- Set texture stage for draw primitive. func.setTexture { section = "Draw/Textures" } "void" .stage "uint8_t" --- Texture unit. .sampler "UniformHandle" --- Program sampler. .handle "TextureHandle" --- Texture handle. .flags "uint32_t" --- Texture sampling mode. Default value UINT32_MAX uses { default = UINT32_MAX } --- texture sampling settings from the texture. --- - `BGFX_SAMPLER_[U/V/W]_[MIRROR/CLAMP]` - Mirror or clamp to edge wrap --- mode. --- - `BGFX_SAMPLER_[MIN/MAG/MIP]_[POINT/ANISOTROPIC]` - Point or anisotropic --- sampling. --- Submit an empty primitive for rendering. Uniforms and draw state --- will be applied but no geometry will be submitted. --- --- @remark --- These empty draw calls will sort before ordinary draw calls. --- func.touch { section = "Miscellaneous" } "void" .id "ViewId" --- View id. --- Submit primitive for rendering. func.submit { section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Which states to discard for next draw. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Submit primitive with occlusion query for rendering. func.submit { cname = "submit_occlusion_query", section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .occlusionQuery "OcclusionQueryHandle" --- Occlusion query. .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Which states to discard for next draw. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Submit primitive for rendering with index and instance data info from --- indirect buffer. --- --- @attention Availability depends on: `BGFX_CAPS_DRAW_INDIRECT`. --- func.submit { cname = "submit_indirect", section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .indirectHandle "IndirectBufferHandle" --- Indirect buffer. .start "uint32_t" --- First element in indirect buffer. { default = 0 } .num "uint32_t" --- Number of draws. { default = 1 } .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Which states to discard for next draw. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Submit primitive for rendering with index and instance data info and --- draw count from indirect buffers. --- --- @attention Availability depends on: `BGFX_CAPS_DRAW_INDIRECT_COUNT`. --- func.submit { cname = "submit_indirect_count", section = "Submit" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Program. .indirectHandle "IndirectBufferHandle" --- Indirect buffer. .start "uint32_t" --- First element in indirect buffer. .numHandle "IndexBufferHandle" --- Buffer for number of draws. Must be --- created with `BGFX_BUFFER_INDEX32` and `BGFX_BUFFER_DRAW_INDIRECT`. .numIndex "uint32_t" --- Element in number buffer. { default = 0 } .numMax "uint32_t" --- Max number of draws. { default = UINT32_MAX } .depth "uint32_t" --- Depth for sorting. { default = 0 } .flags "uint8_t" --- Which states to discard for next draw. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Set compute index buffer. func.setBuffer { cname = "set_compute_index_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "IndexBufferHandle" --- Index buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute vertex buffer. func.setBuffer { cname = "set_compute_vertex_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "VertexBufferHandle" --- Vertex buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute dynamic index buffer. func.setBuffer { cname = "set_compute_dynamic_index_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "DynamicIndexBufferHandle" --- Dynamic index buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute dynamic vertex buffer. func.setBuffer { cname = "set_compute_dynamic_vertex_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute indirect buffer. func.setBuffer { cname = "set_compute_indirect_buffer", section = "Compute/Buffers" } "void" .stage "uint8_t" --- Compute stage. .handle "IndirectBufferHandle" --- Indirect buffer handle. .access "Access::Enum" --- Buffer access. See `Access::Enum`. --- Set compute image from texture. func.setImage { section = "Images" } "void" .stage "uint8_t" --- Compute stage. .handle "TextureHandle" --- Texture handle. .mip "uint8_t" --- Mip level. .access "Access::Enum" --- Image access. See `Access::Enum`. .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. { default = "TextureFormat::Count" } --- Dispatch compute. func.dispatch { section = "Dispatch" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Compute program. .numX "uint32_t" --- Number of groups X. { default = 1 } .numY "uint32_t" --- Number of groups Y. { default = 1 } .numZ "uint32_t" --- Number of groups Z. { default = 1 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Dispatch compute indirect. func.dispatch { cname = "dispatch_indirect", section = "Dispatch" } "void" .id "ViewId" --- View id. .program "ProgramHandle" --- Compute program. .indirectHandle "IndirectBufferHandle" --- Indirect buffer. .start "uint32_t" --- First element in indirect buffer. { default = 0 } .num "uint32_t" --- Number of dispatches. { default = 1 } .flags "uint8_t" --- Discard or preserve states. See `BGFX_DISCARD_*`. { default = "BGFX_DISCARD_ALL" } --- Discard previously set state for draw or compute call. func.discard { section = "Miscellaneous" } "void" .flags "uint8_t" --- Draw/compute states to discard. { default = "BGFX_DISCARD_ALL" } --- Blit 2D texture region between two 2D textures. --- --- @attention Destination texture must be created with `BGFX_TEXTURE_BLIT_DST` flag. --- @attention Availability depends on: `BGFX_CAPS_TEXTURE_BLIT`. --- func.blit { cpponly, section = "Blit" } "void" .id "ViewId" --- View id. .dst "TextureHandle" --- Destination texture handle. .dstX "uint16_t" --- Destination texture X position. .dstY "uint16_t" --- Destination texture Y position. .src "TextureHandle" --- Source texture handle. .srcX "uint16_t" --- Source texture X position. { default = 0 } .srcY "uint16_t" --- Source texture Y position. { default = 0 } .width "uint16_t" --- Width of region. { default = UINT16_MAX } .height "uint16_t" --- Height of region. { default = UINT16_MAX } --- Blit 2D texture region between two 2D textures. --- --- @attention Destination texture must be created with `BGFX_TEXTURE_BLIT_DST` flag. --- @attention Availability depends on: `BGFX_CAPS_TEXTURE_BLIT`. --- func.blit { section = "Blit" } "void" .id "ViewId" --- View id. .dst "TextureHandle" --- Destination texture handle. .dstMip "uint8_t" --- Destination texture mip level. .dstX "uint16_t" --- Destination texture X position. .dstY "uint16_t" --- Destination texture Y position. .dstZ "uint16_t" --- If texture is 2D this argument should be 0. If destination texture is cube --- this argument represents destination texture cube face. For 3D texture this argument --- represents destination texture Z position. .src "TextureHandle" --- Source texture handle. .srcMip "uint8_t" --- Source texture mip level. { default = 0 } .srcX "uint16_t" --- Source texture X position. { default = 0 } .srcY "uint16_t" --- Source texture Y position. { default = 0 } .srcZ "uint16_t" --- If texture is 2D this argument should be 0. If source texture is cube --- this argument represents source texture cube face. For 3D texture this argument --- represents source texture Z position. { default = 0 } .width "uint16_t" --- Width of region. { default = UINT16_MAX } .height "uint16_t" --- Height of region. { default = UINT16_MAX } .depth "uint16_t" --- If texture is 3D this argument represents depth of region, otherwise it's --- unused. { default = UINT16_MAX } -------------------------------------------------------------------------------- -- Documentation sections for RST generation -------------------------------------------------------------------------------- --- .. note:: --- --- If you're just getting started with bgfx, you might get more out of these simple walkthroughs for how to use bgfx's API: --- --- - `Hello, bgfx! (tutorial) `_ --- - `bgfx-minimal-example (repo on GitHub) `_ --- - `Using the bgfx library with C++ on Ubuntu (tutorial) `_ --- - `Getting started with BGFX (playlist on Youtube) `_ --- - `Getting started with BGFX (repo on GitHub) `_ section("API Reference", 0) --- General API for initialization, shutdown, frame management, debug, and querying renderer information. section("General", 1) --- Initialization and Shutdown section("Initialization and Shutdown", 2) --- Updating section("Updating", 2) --- Reset flags control back-buffer resolution, MSAA, vsync, and other global rendering settings. section("Reset", 3) --- Frame flags and the ``bgfx::frame`` call to advance to the next frame. section("Frame", 3) --- Debug section("Debug", 2) --- Enable or disable debug features. section("Debug Features", 3) --- Flags for ``bgfx::setDebug``. section("Debug Flags", 3) --- Functions for printing debug text on screen. section("Debug Text Display", 3) --- Querying information section("Querying information", 2) --- Query the active rendering backend. section("Renderer", 3) --- Query GPU capabilities and limits. section("Capabilities", 3) --- Individual capability flags. section("Available Caps", 4) --- Per-frame rendering statistics. section("Statistics", 3) --- Platform specific --- These are platform specific APIs. --- It is only necessary to use these APIs in conjunction with creating windows. section("Platform specific", 2) --- Miscellaneous section("Miscellaneous", 2) --- Views --- --- Views are the primary sorting mechanism in bgfx. --- They represent buckets of draw and compute calls, or what are often known as 'passes'. --- --- When compute calls and draw calls occupy the same bucket, the compute calls will be sorted to execute first. --- Compute calls are always executed in order of submission, while draw calls are sorted by internal state if --- the View is not in sequential mode. --- In most cases where the z-buffer is used, this change in order does not affect the desired output. --- When draw call order needs to be preserved (e.g. when rendering GUIs), Views can be set to use sequential mode with ``bgfx::setViewMode``. --- Sequential order is less efficient, because it doesn't allow state change optimization, and should be avoided when possible. --- --- By default, Views are sorted by their View ID, in ascending order. --- For dynamic renderers where the right order might not be known until the last moment, --- View IDs can be changed to use arbitrary ordering with ``bgfx::setViewOrder``. --- --- A View's state is preserved between frames. section("Views", 1) --- Encoder section("Encoder", 1) --- API for multi-threaded submission. section("Encoder", 2) --- Draw --- --- Draw state is not preserved between two draw calls. --- All state is cleared after calling ``bgfx::submit``. section("Draw", 2) --- Debug markers for grouping draw calls in graphics debugging tools. section("Debug", 3) --- Configure render state for draw calls. section("State", 3) --- Render state flags for depth test, blending, culling, etc. section("State Flags", 3) --- Configure stencil test for draw calls. section("Stencil", 3) --- Stencil test configuration flags. section("Stencil Flags", 3) --- Scissor --- --- If the Scissor rectangle needs to be changed for --- every draw call in a View, use ``bgfx::setScissor``. --- Otherwise, use ``bgfx::setViewScissor``. section("Scissor", 3) --- Set model transform matrices for draw calls. section("Transform", 3) --- Conditionally render based on occlusion query results. section("Conditional Rendering", 3) --- Set vertex, index, and instance data buffers for draw calls. section("Buffers", 3) --- Bind textures to texture stages for draw calls. section("Textures", 3) --- Set shader uniform parameters for draw calls. section("Uniforms", 3) --- Submit --- --- In Views, all draw commands are executed **after** blit and compute commands. section("Submit", 3) --- Compute --- --- Compute state is not preserved between compute dispatches; all state is cleared after calling ``bgfx::dispatch``. section("Compute", 2) --- Bind buffers to compute stages. section("Buffers", 3) --- Bind texture images to compute stages. section("Images", 3) --- Dispatch --- --- In Views, all draw commands are executed **after** blit and compute commands. section("Dispatch", 3) --- Blit --- --- In Views, all draw commands are executed **after** blit and compute commands. section("Blit", 2) --- Resources section("Resources", 1) --- Shaders and Programs --- --- @remarks Shaders must be compiled with offline command line tool shaderc. section("Shaders and Programs", 2) --- Uniforms section("Uniforms", 2) --- Vertex Buffers section("Vertex Buffers", 2) --- Index Buffers section("Index Buffers", 2) --- Textures section("Textures", 2) --- Frame Buffers section("Frame Buffers", 2) --- Instance Buffer section("Instance Buffer", 2) --- Indirect Buffer section("Indirect Buffer", 2) --- Occlusion Query section("Occlusion Query", 2)