diff options
Diffstat (limited to '3rdparty/bgfx/scripts')
22 files changed, 6040 insertions, 246 deletions
diff --git a/3rdparty/bgfx/scripts/bgfx-codegen.lua b/3rdparty/bgfx/scripts/bgfx-codegen.lua new file mode 100644 index 00000000000..4069b933f8a --- /dev/null +++ b/3rdparty/bgfx/scripts/bgfx-codegen.lua @@ -0,0 +1,330 @@ +-- Copyright 2019 云风 https://github.com/cloudwu . All rights reserved. +-- License (the same with bgfx) : https://github.com/bkaradzic/bgfx/blob/master/LICENSE + +local codegen = require "codegen" +local idl = codegen.idl "bgfx.idl" + +local func_actions = { + + c99 = "\n", + c99decl = "\n", + cppdecl = "\n", + interface_struct = "\n\t", + interface_import = ",\n\t\t\t", + c99_interface = "\n", + cpp_interface = "\n", + c99_functionid = "\n\t", + cpp_functionid = "\n\t\t", +} + +local type_actions = { + + cflags = "\n", + enums = "\n", + cenums = "\n", + structs = "\n", + cstructs = "\n", + handles = "\n", + chandles = "\n", + funcptrs = "\n", + cfuncptrs = "\n", +} + +local function cfunc(f) + return function(func) + if not func.cpponly then + return f(func) + end + end +end + +local funcgen = {} + +local functemp = {} + +functemp.interface_struct = "$CRET (*$CFUNCNAME)($CARGS);" +functemp.interface_import = "bgfx_$CFUNCNAME" +functemp.c99_interface = [[ +BGFX_C_API $CRET bgfx_$CFUNCNAME($CARGS) +{ + $CONVERSIONCTOC + $PRERETCTOCg_interface->$CFUNCNAME($CALLARGS); + $POSTRETCTOC +} +]] +functemp.c99_functionid = "BGFX_FUNCTION_ID_$CFUNCNAMEUPPER," +functemp.cpp_functionid = "$CFUNCNAMECAML," + +for action,temp in pairs(functemp) do + funcgen[action] = cfunc(function(func) + return codegen.apply_functemp(func, temp) + end) +end + +funcgen.cpp_interface= cfunc(function(func) + if not func.cfunc and not func.conly then + return codegen.apply_functemp(func, [[ +$RET $CLASSNAME$FUNCNAME($CPPARGS)$CONST +{ + $CONVERSIONCTOCPP + $PRERETCPPTOCg_interface->$CFUNCNAME($CALLARGSCPPTOC); + $POSTRETCPPTOC +} +]]) + end +end) + +funcgen.c99 = cfunc(function(func) + local temp + if func.cfunc then + temp = "/* BGFX_C_API $CRET bgfx_$CFUNCNAME($CARGS) */\n" + else + temp = [[ +BGFX_C_API $CRET bgfx_$CFUNCNAME($CARGS) +{ + $CONVERSION + $PRERET$CPPFUNC($CALLARGSCTOCPP); + $POSTRET +} +]] + end + return codegen.apply_functemp(func, temp) +end) + +local function cppdecl(func) + local doc = func.comments + if not doc and func.comment then + doc = { func.comment } + end + if doc then + local cname + if not func.cpponly then + if func.multicfunc then + cname = {} + for _, name in ipairs(func.multicfunc) do + cname[#cname+1] = "bgfx_" .. name + end + else + cname = "bgfx_" .. func.cname + end + end + doc = codegen.doxygen_type(doc, func, cname) + end + local funcdecl = codegen.apply_functemp(func, "$RET $FUNCNAME($ARGS)$CONST;\n") + if doc then + return doc .. "\n" .. funcdecl + else + return funcdecl + end +end + +function funcgen.cppdecl(func) + -- Don't generate member functions here + if not func.class and not func.conly then + return cppdecl(func) + end +end + +funcgen.c99decl = cfunc(function(func) + local doc = func.comments + if not doc and func.comment then + doc = { func.comment } + end + if doc then + doc = codegen.doxygen_ctype(doc, func) + end + local funcdecl = codegen.apply_functemp(func, "BGFX_C_API $CRET bgfx_$CFUNCNAME($CARGS);") + if doc then + return "\n" .. doc .. "\n" .. funcdecl + else + return funcdecl + end +end) + +local typegen = {} + +local function add_doxygen(typedef, define, cstyle, cname) + local func = cstyle and codegen.doxygen_ctype or codegen.doxygen_type + local doc = func(typedef.comments, typedef, cname or typedef.cname) + if doc then + return doc .. "\n" .. define + else + return define + end +end + +function typegen.enums(typedef) + if typedef.enum then + return add_doxygen(typedef, codegen.gen_enum_define(typedef), false, "bgfx_" .. typedef.cname) + end +end + +function typegen.cenums(typedef) + if typedef.enum then + return add_doxygen(typedef, codegen.gen_enum_cdefine(typedef), true) + end +end + +function typegen.cflags(typedef) + if typedef.flag then + return add_doxygen(typedef, codegen.gen_flag_cdefine(typedef), true) + end +end + +function typegen.structs(typedef) + if typedef.struct and not typedef.namespace then + local methods = typedef.methods + if methods then + local m = {} + for _, func in ipairs(methods) do + m[#m+1] = cppdecl(func) + end + methods = m + end + return add_doxygen(typedef, codegen.gen_struct_define(typedef, methods)) + end +end + +function typegen.cstructs(typedef) + if typedef.struct then + return add_doxygen(typedef, codegen.gen_struct_cdefine(typedef), true) + end +end + +function typegen.handles(typedef) + if typedef.handle then + return codegen.gen_handle(typedef) + end +end + +function typegen.chandles(typedef) + if typedef.handle then + return codegen.gen_chandle(typedef) + end +end + +function typegen.funcptrs(typedef) + if typedef.args then + return add_doxygen(typedef, codegen.gen_funcptr(typedef)) + end +end + +function typegen.cfuncptrs(typedef) + if typedef.args then + return add_doxygen(typedef, codegen.gen_cfuncptr(typedef), true) + end +end + +local function codes() + local temp = {} + for k in pairs(func_actions) do + temp[k] = {} + end + + for k in pairs(type_actions) do + temp[k] = {} + end + + -- call actions with func + for _, f in ipairs(idl.funcs) do + for k in pairs(func_actions) do + local funcgen = funcgen[k] + if funcgen then + table.insert(temp[k], (funcgen(f))) + end + end + end + + -- call actions with type + + for _, typedef in ipairs(idl.types) do + for k in pairs(type_actions) do + local typegen = typegen[k] + if typegen then + table.insert(temp[k], (typegen(typedef))) + end + end + end + + for k, indent in pairs(func_actions) do + temp[k] = table.concat(temp[k], indent) + end + for k, indent in pairs(type_actions) do + temp[k] = table.concat(temp[k], indent) + end + + temp.version = string.format("#define BGFX_API_VERSION UINT32_C(%d)", idl._version or 0) + + return temp +end + +local codes_tbl = codes() + +local function add_path(filename) + local path + if type(paths) == "string" then + path = paths + else + path = assert(paths[filename]) + end + return path .. "/" .. filename +end + +local function change_indent(str, indent) + if indent == "\t" then + -- strip trailing space only + return (str:gsub("(.-)\n", function (line) + return line:gsub("([ \t]*)$","\n") end)) + else + return (str:gsub("(.-)\n", function (line) + return line:gsub("^(\t*)(.-)[ \t]*$", + function (tabs, content) + return indent:rep(#tabs) .. content .. "\n" + end) + end)) + end +end + +local gen = {} + +function gen.apply(tempfile) + local f = assert(io.open(tempfile, "rb")) + local temp = f:read "a" + f:close() + codes_tbl.source = tempfile + return (temp:gsub("$([%l%d_]+)", codes_tbl)) +end + +function gen.format(codes, f) + return change_indent(codes, f.indent) +end + +function gen.changed(codes, outputfile) + local out = io.open(outputfile, "rb") + if out then + local origin = out:read "a" + out:close() + return origin ~= codes + end + return true +end + +function gen.write(codes, outputfile) + local out = assert(io.open(outputfile, "wb")) + out:write(codes) + out:close() +end + +function gen.gen(tempfile, outputfile, indent) + print ("Generate", outputfile, "from", tempfile) + local codes = gen.apply(tempfile) + codes = change_indent(codes, indent) + + if not gen.changed(codes, outputfile) then + print("No change") + end + + gen.write(codes, outputfile) +end + +return gen diff --git a/3rdparty/bgfx/scripts/bgfx.idl b/3rdparty/bgfx/scripts/bgfx.idl new file mode 100644 index 00000000000..23a1ecee285 --- /dev/null +++ b/3rdparty/bgfx/scripts/bgfx.idl @@ -0,0 +1,2998 @@ +-- vim: syntax=lua +-- bgfx interface + +version(100) + +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 } + .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" } + .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" } + .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" } + .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" } + .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" } + .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" } + .Msaa (57) --- Enable MSAA rasterization. + .Lineaa (58) --- Enable line AA rasterization. + .ConservativeRaster (59) --- Enable conservative rasterization. + .None (0) --- No state. + .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" } + .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" + } + +flag.Debug { bits = 32 } + .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. + () + +flag.BufferComputeFormat { bits = 16, shift = 0, range = 4, base = 1 } + ._8x1 --- 1 8-bit value + ._8x2 --- 2 8-bit values + ._8x4 --- 4 8-bit values + ._16x1 --- 1 16-bit value + ._16x2 --- 2 16-bit values + ._16x4 --- 4 16-bit values + ._32x1 --- 1 32-bit value + ._32x2 --- 2 32-bit values + ._32x4 --- 4 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 } + .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. + () + +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 } + .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 } + .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 behavior 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. + () + +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" } + .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. + .FragmentDepth --- Fragment depth is accessible in fragment shader. + .FragmentOrdering --- Fragment ordering is available in fragment shader. + .FramebufferRw --- Read/Write frame buffer attachments are supported. + .GraphicsDebugger --- Graphics debugger is present. + .Reserved + .Hdr10 --- HDR10 rendering is supported. + .Hidpi --- HiDPI rendering is supported. + .Index32 --- 32-bit indices are supported. + .Instancing --- Instancing is supported. + .OcclusionQuery --- Occlusion query is supported. + .RendererMultithreaded --- Renderer is on separate thread. + .SwapChain --- Multiple windows are supported. + .Texture_2dArray --- 2D texture array is supported. + .Texture_3d --- 3D textures are supported. + .TextureBlit --- Texture blit is supported. + .TextureCompareReserved --- All texture compare modes are supported. + .TextureCompareLequal --- Texture compare less equal mode is supported. + .TextureCubeArray --- Cubemap texture array is supported. + .TextureDirectAccess --- CPU direct access to GPU texture memory. + .TextureReadBack --- Read-back texture is supported. + .VertexAttribHalf --- Vertex attribute half-float is supported. + .VertexAttribUint10 --- Vertex attribute 10_10_10_2 is supported. + .VertexId --- Rendering with VertexID only is supported. + .TextureCompareAll { "TextureCompareReserved", "TextureCompareLequal" } --- All texture compare modes are supported. + () + +flag.CapsFormat { bits = 16 } + .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. + .TextureImage --- Texture format can be used as image from compute shader. + .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. + () + +flag.Resolve { bits = 8 } + .None --- No resolve flags. + .AutoGenMips --- Auto-generate mip maps on resolve. + () + +flag.PciId { bits = 16 , const } + .None (0x0000) --- Autoselect adapter. + .SoftwareRasterizer (0x0001) --- Software rasterizer. + .Amd (0x1002) --- AMD adapter. + .Intel (0x8086) --- Intel adapter. + .Nvidia (0x10de) --- nVidia 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. + () + +--- Fatal error enum. +enum.Fatal { underscore, comment = "" } + .DebugCheck + .InvalidShader + .UnableToInitialize + .UnableToCreateTexture + .DeviceLost + () -- end of enum + +--- Renderer backend type enum. +enum.RendererType { comment = "Renderer types:" } + .Noop --- No rendering. + .Direct3D9 --- Direct3D 9.0 + .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 + () + +--- Access mode enum. +enum.Access { comment = "Access:" } + .Read --- Read. + .Write --- Write. + .ReadWrite --- Read and write. + () + +--- Vertex attribute enum. +enum.Attrib { comment = "Corresponds to vertex shader attribute." } + .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:" } + .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:" } + .BC1 --- DXT1 R5G6B5A1 + .BC2 --- DXT3 R5G6B5A4 + .BC3 --- DXT5 R5G6B5A8 + .BC4 --- LATC1/ATI1 R8 + .BC5 --- LATC2/ATI2 RG8 + .BC6H --- BC6H RGB16F + .BC7 --- BC7 RGB 4-7 bits per color channel, 0-8 bits alpha + .ETC1 --- ETC1 RGB8 + .ETC2 --- ETC2 RGB8 + .ETC2A --- ETC2 RGBA8 + .ETC2A1 --- ETC2 RGB8A1 + .PTC12 --- PVRTC1 RGB 2BPP + .PTC14 --- PVRTC1 RGB 4BPP + .PTC12A --- PVRTC1 RGBA 2BPP + .PTC14A --- PVRTC1 RGBA 4BPP + .PTC22 --- PVRTC2 RGBA 2BPP + .PTC24 --- PVRTC2 RGBA 4BPP + .ATC --- ATC RGB 4BPP + .ATCE --- ATCE RGBA 8 BPP explicit alpha + .ATCI --- ATCI RGBA 8 BPP interpolated alpha + .ASTC4x4 --- ASTC 4x4 8.0 BPP + .ASTC5x5 --- ASTC 5x5 5.12 BPP + .ASTC6x6 --- ASTC 6x6 3.56 BPP + .ASTC8x5 --- ASTC 8x5 3.20 BPP + .ASTC8x6 --- ASTC 8x6 2.67 BPP + .ASTC10x5 --- ASTC 10x5 2.56 BPP + .Unknown --- Compressed formats above. + .R1 + .A8 + .R8 + .R8I + .R8U + .R8S + .R16 + .R16I + .R16U + .R16F + .R16S + .R32I + .R32U + .R32F + .RG8 + .RG8I + .RG8U + .RG8S + .RG16 + .RG16I + .RG16U + .RG16F + .RG16S + .RG32I + .RG32U + .RG32F + .RGB8 + .RGB8I + .RGB8U + .RGB8S + .RGB9E5F + .BGRA8 + .RGBA8 + .RGBA8I + .RGBA8U + .RGBA8S + .RGBA16 + .RGBA16I + .RGBA16U + .RGBA16F + .RGBA16S + .RGBA32I + .RGBA32U + .RGBA32F + .R5G6B5 + .RGBA4 + .RGB5A1 + .RGB10A2 + .RG11B10F + .UnknownDepth --- Depth formats below. + .D16 + .D24 + .D24S8 + .D32 + .D16F + .D24F + .D32F + .D0S8 + () + +--- Uniform type enum. +enum.UniformType { comment = "Uniform types:" } + .Sampler [[Sampler.]] + .End [[Reserved, do not use.]] + .Vec4 [[4 floats vector.]] + .Mat3 [[3x3 matrix.]] + .Mat4 [[4x4 matrix.]] + +--- 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:" } + .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:" } + .TriListFlipWinding [[Flip winding order of triangle list.]] + .TriStripFlipWinding [[Flip winding order of trinagle 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:" , } + .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:" } + .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.]] + +--- Render frame enum. +enum.RenderFrame { underscore, comment = "" } + .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 capabilities 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. + .transientVbSize "uint32_t" --- Maximum transient vertex buffer size. + .transientIbSize "uint32_t" --- Maximum transient index buffer size. + +--- Renderer capabilities. +struct.Caps + .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" + .formats "uint16_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` - Texture format can be used as image from compute + --- shader. + --- - `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. + +--- Internal data. +struct.InternalData + .caps "const Caps*" --- Renderer capabilities. + .context "void*" --- GL context, or D3D device. + +--- Platform data. +struct.PlatformData { ctor } + .ndt "void*" --- Native display type. + .nwh "void*" --- Native window handle. + .context "void*" --- GL context, or D3D device. + .backBuffer "void*" --- GL backbuffer, or D3D render target view. + .backBufferDS "void*" --- Backbuffer depth/stencil. + +--- Backbuffer resolution and reset parameters. +struct.Resolution { ctor } + .format "TextureFormat::Enum" --- Backbuffer 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. + +struct.Limits { namespace = "Init" } + .maxEncoders "uint16_t" --- Maximum number of encoder threads. + .transientVbSize "uint32_t" --- Maximum transient vertex buffer size. + .transientIbSize "uint32_t" --- Maximum transient index buffer size. + +--- Initialization parameters used by `bgfx::init`. +struct.Init { ctor } + .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` it will select the first + --- device. + --- - `BGFX_PCI_ID_NONE` - Autoselect adapter. + --- - `BGFX_PCI_ID_SOFTWARE_RASTERIZER` - Software rasterizer. + --- - `BGFX_PCI_ID_AMD` - AMD adapter. + --- - `BGFX_PCI_ID_INTEL` - Intel adapter. + --- - `BGFX_PCI_ID_NVIDIA` - nVidia adapter. + + .deviceId "uint16_t" --- Device id. If set to 0 it will select first device, or device with + --- matching id. + + .debug "bool" --- Enable device for debuging. + .profile "bool" --- Enable device for profiling. + .platformData "PlatformData" --- Platform data. + .resolution "Resolution" --- Backbuffer resolution and reset parameters. See: `bgfx::Resolution`. + .limits "Limits" + .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 + .data "uint8_t*" [[Pointer to data.]] + .size "uint32_t" [[Data size.]] + +--- Transient index buffer. +struct.TransientIndexBuffer + .data "uint8_t*" --- Pointer to data. + .size "uint32_t" --- Data size. + .startIndex "uint32_t" --- First index. + .handle "IndexBufferHandle" --- Index buffer handle. + +--- Transient vertex buffer. +struct.TransientVertexBuffer + .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 + .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 + .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 + .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 } + .access "Access::Enum" --- Attachement access. See `Access::Enum`. + .handle "TextureHandle" --- Render target texture handle. + .mip "uint16_t" --- Mip level. + .layer "uint16_t" --- Cubemap side or depth layer/slice. + .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. + { default = 0 } + .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 + .name "char[256]" --- View name. + .view "ViewId" --- View id. + .cpuTimeElapsed "int64_t" --- CPU (submit) time elapsed. + .gpuTimeElapsed "int64_t" --- GPU time elapsed. + +--- Encoder stats. +struct.EncoderStats + .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 + .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. + + .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 } + .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 {} + +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&" + .rendererType "RendererType::Enum" + { default = "RendererType::Noop" } + +--- Add attribute to VertexLayout. +--- +--- @remarks Must be called between begin/end. +--- +func.VertexLayout.add + "VertexLayout&" + .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 } + "bool" + .attrib "Attrib::Enum" --- Attribute semantics. See: `bgfx::Attrib` + +--- Skip `_num` bytes in vertex stream. +func.VertexLayout.skip + "VertexLayout&" + .num "uint8_t" + +-- Notice: `end` is a keyword in lua. +--- End VertexLayout. +func.VertexLayout["end"] + "void" + +--- Returns relative attribute offset from the vertex. +func.VertexLayout.getOffset { const , cpponly } + "uint16_t" + .attrib "Attrib::Enum" --- Attribute semantics. See: `bgfx::Attrib` + +--- Returns vertex stride. +func.VertexLayout.getStride { const , cpponly } + "uint16_t" + +--- Returns size of vertex buffer for number of vertices. +func.VertexLayout.getSize { const, cpponly } + "uint32_t" + .num "uint32_t" + +--- Pack vertex attribute into vertex stream format. +func.vertexPack + "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 + "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 + "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. +func.weldVertices + "uint16_t" --- Number of unique vertices after vertex welding. + .output "uint16_t*" --- 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 "uint16_t" --- Number of vertices in vertex stream. + .epsilon "float" --- Error tolerance for vertex position comparison. + { default = "0.001f" } + +--- Convert index buffer for use with different primitive topologies. +func.topologyConvert + "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 + "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 + "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` + +func.initCtor { cfunc } + "void" + .init "Init*" + +--- Initialize bgfx library. +func.init { cfunc } + "bool" --- `true` if initialization was successful. + .init "const Init &" --- Initialization parameters. See: `bgfx::Init` for more info. + +--- Shutdown bgfx library. +func.shutdown + "void" + +--- Reset graphic settings and back-buffer size. +--- +--- @attention This call doesn't actually change window size, it just +--- resizes back-buffer. Windowing code has to change window size. +--- +func.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 behavior is that flip occurs before rendering new + --- frame. This flag only has effect when `BGFX_CONFIG_MULTITHREADED=0`. + --- - `BGFX_RESET_SRGB_BACKBUFFER` - Enable sRGB backbuffer. + .format "TextureFormat::Enum" --- Texture format. See: `TextureFormat::Enum`. + { default = "TextureFormat::Count" } + +--- Advance to next frame. When using multithreaded renderer, this call +--- just swaps internal buffers, kicks render thread, and returns. In +--- singlethreaded renderer this call does frame rendering. +func.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. + .capture "bool" --- Capture frame with graphics debugger. + { default = false } + +--- Returns current renderer backend API type. +--- +--- @remarks +--- Library must be initialized. +--- +func.getRendererType + "RendererType::Enum" --- Renderer backend type. See: `bgfx::RendererType` + +--- Returns renderer capabilities. +--- +--- @remarks +--- Library must be initialized. +--- +func.getCaps + "const Caps*" --- Pointer to static `bgfx::Caps` structure. + +--- Returns performance counters. +--- +--- @attention Pointer returned is valid until `bgfx::frame` is called. +--- +func.getStats + "const Stats*" -- Performance counters. + +--- Allocate buffer to pass to bgfx calls. Data will be freed inside bgfx. +func.alloc + "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 + "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" } + "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 + "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 + "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" } + "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" } + "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 + "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 + "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" } + "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" } + "void" + .handle "IndexBufferHandle" --- Static index buffer handle. + +--- Create vertex layout. +func.createVertexLayout + "VertexLayoutHandle" + .layout "const VertexLayout &" --- Vertex layout. + +--- Destroy vertex layout. +func.destroy { cname = "destroy_vertex_layout" } + "void" + .layoutHandle "VertexLayoutHandle" --- Vertex layout handle. + +--- Create static vertex buffer. +func.createVertexBuffer + "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" } + "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" } + "void" + .handle "VertexBufferHandle" --- Static vertex buffer handle. + +--- Create empty dynamic index buffer. +func.createDynamicIndexBuffer + "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 dynamic index buffer and initialized it. +func.createDynamicIndexBuffer { cname = "create_dynamic_index_buffer_mem" } + "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" } + "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" } + "void" + .handle "DynamicIndexBufferHandle" --- Dynamic index buffer handle. + +--- Create empty dynamic vertex buffer. +func.createDynamicVertexBuffer + "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" } + "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" } + "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" } + "void" + .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer handle. + +--- Returns number of requested or maximum available indices. +func.getAvailTransientIndexBuffer + "uint32_t" --- Number of requested or maximum available indices. + .num "uint32_t" --- Number of required indices. + +--- Returns number of requested or maximum available vertices. +func.getAvailTransientVertexBuffer + "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 + "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. +--- +--- @remarks +--- Only 16-bit index buffer is supported. +--- +func.allocTransientIndexBuffer + "void" + .tib "TransientIndexBuffer*" { out } --- TransientIndexBuffer structure is filled and is valid + --- for the duration of frame, and it can be reused for multiple draw + --- calls. + .num "uint32_t" --- Number of indices to allocate. + +--- Allocate transient vertex buffer. +func.allocTransientVertexBuffer + "void" + .tvb "TransientVertexBuffer*" { out } --- TransientVertexBuffer structure is filled and is valid + --- for the duration of frame, and it 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. +--- +--- @remarks +--- Only 16-bit index buffer is supported. +--- +func.allocTransientBuffers + "bool" + .tvb "TransientVertexBuffer*" { out } --- TransientVertexBuffer structure is filled and is valid + --- for the duration of frame, and it 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 is filled and is valid + --- for the duration of frame, and it can be reused for multiple draw + --- calls. + .numIndices "uint32_t" --- Number of indices to allocate. + +--- Allocate instance data buffer. +func.allocInstanceDataBuffer + "void" + .idb "InstanceDataBuffer*" { out } --- InstanceDataBuffer structure is filled and is valid + --- for duration of frame, and it 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 + "IndirectBufferHandle" --- Indirect buffer handle. + .num "uint32_t" --- Number of indirect calls. + +--- Destroy draw indirect buffer. +func.destroy { cname = "destroy_indirect_buffer" } + "void" + .handle "IndirectBufferHandle" --- Indirect buffer handle. + +--- Create shader from memory buffer. +func.createShader + "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 + "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" } + "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" } + "void" + .handle "ShaderHandle" --- Shader handle. + +--- Create program with vertex and fragment shaders. +func.createProgram + "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" } + "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" } + "void" + .handle "ProgramHandle" --- Program handle. + +--- Validate texture parameters. +func.isTextureValid + "bool" --- True if texture can be successfully 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_*`. + +--- Calculate amount of memory required for texture. +func.calcTextureSize + "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 + "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_*`) + { "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 + "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_*`) + { "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. + +--- Create texture with size based on backbuffer ratio. Texture will maintain ratio +--- if back buffer resolution changes. +func.createTexture2D { cname = "create_texture_2d_scaled" } + "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 + "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. + +--- Create Cube texture. +func.createTextureCube + "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 + --- 1, expected memory layout is texture and all mips together for each array element. + +--- Update 2D texture. +--- +--- @attention It's valid to update only mutable texture. See `bgfx::createTexture2D` for more info. +--- +func.updateTexture2D + "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 + "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 + "void" + .handle "TextureHandle" --- Texture handle. + .layer "uint16_t" --- Layer in texture array. + .side "uint8_t" --- Cubemap side `BGFX_CUBE_MAP_<POSITIVE or NEGATIVE>_<X, Y or Z>`, + --- 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 + "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" } + "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 + "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" } + "void" + .handle "TextureHandle" --- Texture handle. + +--- Create frame buffer (simple). +func.createFrameBuffer + "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 backbuffer ratio. Frame buffer will maintain ratio +--- if back buffer resolution changes. +func.createFrameBuffer { cname = "create_frame_buffer_scaled" } + "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" } + "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" } + "FrameBufferHandle" --- Frame buffer handle. + .num "uint8_t" --- Number of attachements. + .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" } + "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" } + "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 + "TextureHandle" + .handle "FrameBufferHandle" --- Frame buffer handle. + .attachment "uint8_t" + { default = 0 } + +--- Destroy frame buffer. +func.destroy { cname = "destroy_frame_buffer" } + "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_modelViewProj mat4` - concatenated model view projection matrix. +--- - `u_alphaRef float` - alpha reference value for alpha test. +--- +func.createUniform + "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 } + +--- Retrieve uniform info. +func.getUniformInfo + "void" + .handle "UniformHandle" --- Handle to uniform object. + .info "UniformInfo &" { out } --- Uniform info. + +--- Destroy shader uniform parameter. +func.destroy { cname = "destroy_uniform" } + "void" + .handle "UniformHandle" --- Handle to uniform object. + +--- Create occlusion query. +func.createOcclusionQuery + "OcclusionQueryHandle" --- Handle to occlusion query object. + +--- Retrieve occlusion query result from previous frame. +func.getResult + "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" } + "void" + .handle "OcclusionQueryHandle" --- Handle to occlusion query object. + +--- Set palette color value. +func.setPaletteColor + "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_rgba8" } + "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 <view name>" +--- ^ ^ ^ +--- | +--- compute (C) +--- +------ view id +--- +func.setViewName + "void" + .id "ViewId" --- View id. + .name "const char*" --- View name. + +--- Set view rectangle. Draw primitive outside view will be clipped. +func.setViewRect + "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" } + "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 + "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 + "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. Must use `bgfx::setPaletteColor` to setup clear color +--- palette. +func.setViewClear { cname = "set_view_clear_mrt" } + "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 + "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 + "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 view and projection matrices, all draw primitives in this +--- view will use these matrices. +func.setViewTransform + "void" + .id "ViewId" --- View id. + .view "const void*" --- View matrix. + .proj "const void*" --- Projection matrix. + +--- Post submit view reordering. +func.setViewOrder + "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 } + +--- Begin submitting draw calls from thread. +func.begin { cname = "encoder_begin" } + "Encoder*" --- Encoder. + .forThread "bool" --- Explicitly request an encoder for a worker thread. + +--- End submitting draw calls from thread. +func["end"] { cname = "encoder_end" } + "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 + "void" + .marker "const char*" --- Marker string. + +--- Set render states for draw primitive. +--- +--- @remarks +--- 1. To setup 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 + "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 + "void" + .handle "OcclusionQueryHandle" --- Occlusion query handle. + .visible "bool" --- Render if occlusion query is visible. + +--- Set stencil test state. +func.Encoder.setStencil + "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 + "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" } + "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 + "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. + +--- Set model matrix from matrix cache for draw primitive. +func.Encoder.setTransform { cname = "set_transform_cached" } + "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 modifed until `bgfx::frame` is called. +--- +func.Encoder.allocTransform + "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 + "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 } + "void" + .handle "IndexBufferHandle" --- Index buffer. + +--- Set index buffer for draw primitive. +func.Encoder.setIndexBuffer + "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 } + "void" + .handle "DynamicIndexBufferHandle" --- Dynamic index buffer. + +--- Set index buffer for draw primitive. +func.Encoder.setIndexBuffer { cname = "set_dynamic_index_buffer" } + "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 } + "void" + .tib "const TransientIndexBuffer*" --- Transient index buffer. + +--- Set index buffer for draw primitive. +func.Encoder.setIndexBuffer { cname = "set_transient_index_buffer" } + "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 + "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. + { 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 { 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. + .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. + { 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 { 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. + .layoutHandle "VertexLayoutHandle" --- Vertex layout for aliasing vertex buffer. + { default = "BGFX_INVALID_HANDLE" } + +--- Set number of vertices for auto generated vertices use in conjuction +--- with gl_VertexID. +--- +--- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. +--- +func.Encoder.setVertexCount + "void" + .numVertices "uint32_t" --- Number of vertices. + +--- Set instance data buffer for draw primitive. +func.Encoder.setInstanceDataBuffer { cpponly } + "void" + .idb "const InstanceDataBuffer*" --- Transient instance data buffer. + +--- Set instance data buffer for draw primitive. +func.Encoder.setInstanceDataBuffer + "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 { cpponly } + "void" + .handle "VertexBufferHandle" --- Vertex buffer. + +--- Set instance data buffer for draw primitive. +func.Encoder.setInstanceDataBuffer { cname = "set_instance_data_from_vertex_buffer" } + "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 { cpponly } + "void" + .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. + +--- Set instance data buffer for draw primitive. +func.Encoder.setInstanceDataBuffer { cname = "set_instance_data_from_dynamic_vertex_buffer" } + "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 conjuction +--- with gl_InstanceID. +--- +--- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. +--- +func.Encoder.setInstanceCount + "void" + .numInstances "uint32_t" -- Number of instances. + +--- Set texture stage for draw primitive. +func.Encoder.setTexture + "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.Encoder.touch + "void" + .id "ViewId" --- View id. + +--- Submit primitive for rendering. +func.Encoder.submit + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Program. + .depth "uint32_t" --- Depth for sorting. + { default = 0 } + .preserveState "bool" --- Preserve internal draw state for next draw call submit. + { default = false } + +--- Submit primitive with occlusion query for rendering. +func.Encoder.submit { cname = "submit_occlusion_query" } + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Program. + .occlusionQuery "OcclusionQueryHandle" --- Occlusion query. + .depth "uint32_t" --- Depth for sorting. + { default = 0 } + .preserveState "bool" --- Preserve internal draw state for next draw call submit. + { default = false } + +--- Submit primitive for rendering with index and instance data info from +--- indirect buffer. +func.Encoder.submit { cname = "submit_indirect" } + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Program. + .indirectHandle "IndirectBufferHandle" --- Indirect buffer. + .start "uint16_t" --- First element in indirect buffer. + { default = 0 } + .num "uint16_t" --- Number of dispatches. + { default = 1 } + .depth "uint32_t" --- Depth for sorting. + { default = 0 } + .preserveState "bool" --- Preserve internal draw state for next draw call submit. + { default = false } + +--- Set compute index buffer. +func.Encoder.setBuffer { cname = "set_compute_index_buffer" } + "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" } + "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" } + "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" } + "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" } + "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 + "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 + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Compute program. + .numX "uint32_t" --- Number of groups X. + { deafult = 1 } + .numY "uint32_t" --- Number of groups Y. + { deafult = 1 } + .numZ "uint32_t" --- Number of groups Z. + { deafult = 1 } + +--- Dispatch compute indirect. +func.Encoder.dispatch { cname = "dispatch_indirect" } + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Compute program. + .indirectHandle "IndirectBufferHandle" --- Indirect buffer. + .start "uint16_t" --- First element in indirect buffer. + { deafult = 0 } + .num "uint16_t" --- Number of dispatches. + { deafult = 1 } + +--- Discard all previously set state for draw or compute call. +func.Encoder.discard + "void" + +--- 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 } + "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 + "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 + "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. +--- +--- @attention `bgfx::renderFrame` is blocking call. It waits for +--- `bgfx::frame` to be called from API thread to process frame. +--- If timeout value is passed call will timeout and return even +--- if `bgfx::frame` is not called. +--- +--- @warning This call should be only used on platforms that don't +--- allow creating separate rendering thread. If it is called before +--- to bgfx::init, render thread won't be created by bgfx::init call. +--- +func.renderFrame + "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 + "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 + "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" } + "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. + +--- 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" } + "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. + +-- Legacy API: + +--- Sets a debug marker. This allows you to group graphics calls together for easy browsing in +--- graphics debugging tools. +func.setMarker + "void" + .marker "const char*" --- Marker string. + +--- Set render states for draw primitive. +--- +--- @remarks +--- 1. To setup 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 + "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 + "void" + .handle "OcclusionQueryHandle" --- Occlusion query handle. + .visible "bool" --- Render if occlusion query is visible. + +--- Set stencil test state. +func.setStencil + "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 + "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" } + "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 + "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. + +--- Set model matrix from matrix cache for draw primitive. +func.setTransform { cname = "set_transform_cached" } + "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 modifed until `bgfx::frame` is called. +--- +func.allocTransform + "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 + "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 } + "void" + .handle "IndexBufferHandle" --- Index buffer. + +--- Set index buffer for draw primitive. +func.setIndexBuffer + "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 } + "void" + .handle "DynamicIndexBufferHandle" --- Dynamic index buffer. + +--- Set index buffer for draw primitive. +func.setIndexBuffer { cname = "set_dynamic_index_buffer" } + "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 } + "void" + .tib "const TransientIndexBuffer*" --- Transient index buffer. + +--- Set index buffer for draw primitive. +func.setIndexBuffer { cname = "set_transient_index_buffer" } + "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 + "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 { cpponly } + "void" + .stream "uint8_t" --- Vertex stream. + .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. + +--- Set vertex buffer for draw primitive. +func.setVertexBuffer { 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 { cpponly } + "void" + .stream "uint8_t" --- Vertex stream. + .tvb "const TransientVertexBuffer*" --- Transient vertex buffer. + +--- Set vertex buffer for draw primitive. +func.setVertexBuffer { 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 number of vertices for auto generated vertices use in conjuction +--- with gl_VertexID. +--- +--- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. +--- +func.setVertexCount + "void" + .numVertices "uint32_t" --- Number of vertices. + +--- Set instance data buffer for draw primitive. +func.setInstanceDataBuffer { cpponly } + "void" + .idb "const InstanceDataBuffer*" --- Transient instance data buffer. + +--- Set instance data buffer for draw primitive. +func.setInstanceDataBuffer + "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 { cpponly } + "void" + .handle "VertexBufferHandle" --- Vertex buffer. + +--- Set instance data buffer for draw primitive. +func.setInstanceDataBuffer { cname = "set_instance_data_from_vertex_buffer" } + "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 { cpponly } + "void" + .handle "DynamicVertexBufferHandle" --- Dynamic vertex buffer. + +--- Set instance data buffer for draw primitive. +func.setInstanceDataBuffer { cname = "set_instance_data_from_dynamic_vertex_buffer" } + "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 conjuction +--- with gl_InstanceID. +--- +--- @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. +--- +func.setInstanceCount + "void" + .numInstances "uint32_t" -- Number of instances. + +--- Set texture stage for draw primitive. +func.setTexture + "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 + "void" + .id "ViewId" --- View id. + +--- Submit primitive for rendering. +func.submit + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Program. + .depth "uint32_t" --- Depth for sorting. + { default = 0 } + .preserveState "bool" --- Preserve internal draw state for next draw call submit. + { default = false } + +--- Submit primitive with occlusion query for rendering. +func.submit { cname = "submit_occlusion_query" } + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Program. + .occlusionQuery "OcclusionQueryHandle" --- Occlusion query. + .depth "uint32_t" --- Depth for sorting. + { default = 0 } + .preserveState "bool" --- Preserve internal draw state for next draw call submit. + { default = false } + +--- Submit primitive for rendering with index and instance data info from +--- indirect buffer. +func.submit { cname = "submit_indirect" } + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Program. + .indirectHandle "IndirectBufferHandle" --- Indirect buffer. + .start "uint16_t" --- First element in indirect buffer. + { default = 0 } + .num "uint16_t" --- Number of dispatches. + { default = 1 } + .depth "uint32_t" --- Depth for sorting. + { default = 0 } + .preserveState "bool" --- Preserve internal draw state for next draw call submit. + { default = false } + +--- Set compute index buffer. +func.setBuffer { cname = "set_compute_index_buffer" } + "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" } + "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" } + "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" } + "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" } + "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 + "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 + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Compute program. + .numX "uint32_t" --- Number of groups X. + { deafult = 1 } + .numY "uint32_t" --- Number of groups Y. + { deafult = 1 } + .numZ "uint32_t" --- Number of groups Z. + { deafult = 1 } + +--- Dispatch compute indirect. +func.dispatch { cname = "dispatch_indirect" } + "void" + .id "ViewId" --- View id. + .program "ProgramHandle" --- Compute program. + .indirectHandle "IndirectBufferHandle" --- Indirect buffer. + .start "uint16_t" --- First element in indirect buffer. + { deafult = 0 } + .num "uint16_t" --- Number of dispatches. + { deafult = 1 } + +--- Discard all previously set state for draw or compute call. +func.discard + "void" + +--- 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 } + "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 + "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 } diff --git a/3rdparty/bgfx/scripts/bgfx.lua b/3rdparty/bgfx/scripts/bgfx.lua index ed06cf7e564..69335c67964 100644 --- a/3rdparty/bgfx/scripts/bgfx.lua +++ b/3rdparty/bgfx/scripts/bgfx.lua @@ -1,5 +1,5 @@ -- --- Copyright 2010-2018 Branimir Karadzic. All rights reserved. +-- Copyright 2010-2019 Branimir Karadzic. All rights reserved. -- License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause -- @@ -35,181 +35,203 @@ function overridefiles(_srcPath, _dstPath, _files) } end -function bgfxProject(_name, _kind, _defines) - project ("bgfx" .. _name) - uuid (os.uuid("bgfx" .. _name)) - bgfxProjectBase(_kind, _defines) - copyLib() -end - function bgfxProjectBase(_kind, _defines) - kind (_kind) - if _kind == "SharedLib" then - defines { - "BGFX_SHARED_LIB_BUILD=1", - } + kind (_kind) + + if _kind == "SharedLib" then + defines { + "BGFX_SHARED_LIB_BUILD=1", + } + links { + "bimg", + "bx", + } + + configuration { "vs20* or mingw*" } links { - "bimg", - "bx", + "gdi32", + "psapi", } - configuration { "vs20* or mingw*" } - links { - "gdi32", - "psapi", - } + configuration { "mingw*" } + linkoptions { + "-shared", + } - configuration { "mingw*" } - linkoptions { - "-shared", - } + configuration { "linux-*" } + buildoptions { + "-fPIC", + } - configuration { "linux-*" } - buildoptions { - "-fPIC", - } + configuration {} + end - configuration {} - end + includedirs { + path.join(BGFX_DIR, "3rdparty"), + path.join(BX_DIR, "include"), + path.join(BIMG_DIR, "include"), + } - includedirs { - path.join(BGFX_DIR, "3rdparty"), - path.join(BX_DIR, "include"), - path.join(BIMG_DIR, "include"), + defines { + _defines, + } + + links { + "bx", + } + + if _OPTIONS["with-glfw"] then + defines { + "BGFX_CONFIG_MULTITHREADED=0", } + end + configuration { "Debug" } defines { - _defines, + "BGFX_CONFIG_DEBUG=1", + } + + configuration { "vs* or mingw*", "not durango" } + includedirs { + path.join(BGFX_DIR, "3rdparty/dxsdk/include"), } + configuration { "android*" } links { - "bx", + "EGL", + "GLESv2", } - if _OPTIONS["with-glfw"] then - defines { - "BGFX_CONFIG_MULTITHREADED=0", - } - end + configuration { "winstore*" } + linkoptions { + "/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata + } - configuration { "Debug" } - defines { - "BGFX_CONFIG_DEBUG=1", - } + configuration { "*clang*" } + buildoptions { + "-Wno-microsoft-enum-value", -- enumerator value is not representable in the underlying type 'int' + "-Wno-microsoft-const-init", -- default initialization of an object of const type '' without a user-provided default constructor is a Microsoft extension + } - configuration { "vs* or mingw*", "not durango" } - includedirs { - path.join(BGFX_DIR, "3rdparty/dxsdk/include"), - } + configuration { "osx" } + buildoptions { "-x objective-c++" } -- additional build option for osx + linkoptions { + "-framework Cocoa", + "-framework QuartzCore", + "-framework OpenGL", + "-weak_framework Metal", + "-weak_framework MetalKit", + } - configuration { "android*" } - links { - "EGL", - "GLESv2", - } + configuration { "not linux-steamlink", "not NX32", "not NX64" } + includedirs { + -- steamlink has EGL headers modified... + -- NX has EGL headers modified... + path.join(BGFX_DIR, "3rdparty/khronos"), + } - configuration { "winstore*" } - linkoptions { - "/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata - } + configuration { "linux-steamlink" } + defines { + "EGL_API_FB", + } - configuration { "*clang*" } - buildoptions { - "-Wno-microsoft-enum-value", -- enumerator value is not representable in the underlying type 'int' - "-Wno-microsoft-const-init", -- default initialization of an object of const type '' without a user-provided default constructor is a Microsoft extension - } + configuration {} - configuration { "osx" } - linkoptions { - "-framework Cocoa", - "-framework QuartzCore", - "-framework OpenGL", - "-weak_framework Metal", - "-weak_framework MetalKit", + includedirs { + path.join(BGFX_DIR, "include"), + } + + files { + path.join(BGFX_DIR, "include/**.h"), + path.join(BGFX_DIR, "src/**.cpp"), + path.join(BGFX_DIR, "src/**.h"), + path.join(BGFX_DIR, "scripts/**.natvis"), + } + + removefiles { + path.join(BGFX_DIR, "src/**.bin.h"), + } + + overridefiles(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-gnm"), { + path.join(BGFX_DIR, "src/renderer_gnm.cpp"), + path.join(BGFX_DIR, "src/renderer_gnm.h"), + }) + + overridefiles(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-nvn"), { + path.join(BGFX_DIR, "src/renderer_nvn.cpp"), + path.join(BGFX_DIR, "src/renderer_nvn.h"), + }) + + if _OPTIONS["with-amalgamated"] then + excludes { + path.join(BGFX_DIR, "src/bgfx.cpp"), + path.join(BGFX_DIR, "src/debug_**.cpp"), + path.join(BGFX_DIR, "src/dxgi.cpp"), + path.join(BGFX_DIR, "src/glcontext_**.cpp"), + path.join(BGFX_DIR, "src/hmd**.cpp"), + path.join(BGFX_DIR, "src/image.cpp"), + path.join(BGFX_DIR, "src/nvapi.cpp"), + path.join(BGFX_DIR, "src/renderer_**.cpp"), + path.join(BGFX_DIR, "src/shader**.cpp"), + path.join(BGFX_DIR, "src/topology.cpp"), + path.join(BGFX_DIR, "src/vertexdecl.cpp"), + } + + configuration { "xcode* or osx or ios*" } + files { + path.join(BGFX_DIR, "src/amalgamated.mm"), } - configuration { "not linux-steamlink", "not NX32", "not NX64" } - includedirs { - -- steamlink has EGL headers modified... - -- NX has EGL headers modified... - path.join(BGFX_DIR, "3rdparty/khronos"), + excludes { + path.join(BGFX_DIR, "src/glcontext_**.mm"), + path.join(BGFX_DIR, "src/renderer_**.mm"), + path.join(BGFX_DIR, "src/amalgamated.cpp"), } - configuration { "linux-steamlink" } - defines { - "EGL_API_FB", + configuration { "not (xcode* or osx or ios*)" } + excludes { + path.join(BGFX_DIR, "src/**.mm"), } configuration {} - includedirs { - path.join(BGFX_DIR, "include"), - } + else + configuration { "xcode* or osx or ios*" } + files { + path.join(BGFX_DIR, "src/glcontext_**.mm"), + path.join(BGFX_DIR, "src/renderer_**.mm"), + } - files { - path.join(BGFX_DIR, "include/**.h"), - path.join(BGFX_DIR, "src/**.cpp"), - path.join(BGFX_DIR, "src/**.h"), - path.join(BGFX_DIR, "scripts/**.natvis"), - } + configuration {} - removefiles { - path.join(BGFX_DIR, "src/**.bin.h"), + excludes { + path.join(BGFX_DIR, "src/amalgamated.**"), } + end - overridefiles(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-ext"), { - path.join(BGFX_DIR, "src/renderer_gnm.cpp"), - path.join(BGFX_DIR, "src/renderer_gnm.h"), - }) + if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-gnm"), { + path.join(BGFX_DIR, "scripts/bgfx.lua"), }) then - if _OPTIONS["with-amalgamated"] then - excludes { - path.join(BGFX_DIR, "src/bgfx.cpp"), - path.join(BGFX_DIR, "src/debug_**.cpp"), - path.join(BGFX_DIR, "src/dxgi.cpp"), - path.join(BGFX_DIR, "src/glcontext_**.cpp"), - path.join(BGFX_DIR, "src/hmd**.cpp"), - path.join(BGFX_DIR, "src/image.cpp"), - path.join(BGFX_DIR, "src/nvapi.cpp"), - path.join(BGFX_DIR, "src/renderer_**.cpp"), - path.join(BGFX_DIR, "src/shader**.cpp"), - path.join(BGFX_DIR, "src/topology.cpp"), - path.join(BGFX_DIR, "src/vertexdecl.cpp"), - } - - configuration { "xcode* or osx or ios*" } - files { - path.join(BGFX_DIR, "src/amalgamated.mm"), - } + dofile(path.join(BGFX_DIR, "../bgfx-gnm/scripts/bgfx.lua") ) + end - excludes { - path.join(BGFX_DIR, "src/glcontext_**.mm"), - path.join(BGFX_DIR, "src/renderer_**.mm"), - path.join(BGFX_DIR, "src/amalgamated.cpp"), - } + if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-nvn"), { + path.join(BGFX_DIR, "scripts/bgfx.lua"), }) then - configuration { "not (xcode* or osx or ios*)" } - excludes { - path.join(BGFX_DIR, "src/**.mm"), - } + dofile(path.join(BGFX_DIR, "../bgfx-nvn/scripts/bgfx.lua") ) + end - configuration {} + configuration {} +end - else - configuration { "xcode* or osx or ios*" } - files { - path.join(BGFX_DIR, "src/glcontext_**.mm"), - path.join(BGFX_DIR, "src/renderer_**.mm"), - } +function bgfxProject(_name, _kind, _defines) - configuration {} + project ("bgfx" .. _name) + uuid (os.uuid("bgfx" .. _name)) - excludes { - path.join(BGFX_DIR, "src/amalgamated.**"), - } - end + bgfxProjectBase(_kind, _defines) - configuration {} + copyLib() end diff --git a/3rdparty/bgfx/scripts/bgfx.natvis b/3rdparty/bgfx/scripts/bgfx.natvis index b82280af29d..2201f415aef 100644 --- a/3rdparty/bgfx/scripts/bgfx.natvis +++ b/3rdparty/bgfx/scripts/bgfx.natvis @@ -54,7 +54,7 @@ </Expand> </Type> - <Type Name="bgfx::Context::ShaderRef"> + <Type Name="bgfx::ShaderRef"> <Expand> <Item Name="m_uniforms">m_uniforms,[m_num]</Item> <Item Name="m_name">m_name</Item> @@ -82,7 +82,7 @@ </Expand> </Type> - <Type Name="bgfx::Context::TextureRef"> + <Type Name="bgfx::TextureRef"> <Expand> <Item Name="m_name">m_name</Item> <Item Name="m_ptr">m_ptr</Item> @@ -106,12 +106,12 @@ </Expand> </Type> - <Type Name="bgfx::VertexDeclHandle"> + <Type Name="bgfx::VertexLayoutHandle"> <DisplayString Condition="idx == bgfx::kInvalidHandle">{{ idx={idx} (INVALID) }}</DisplayString> <DisplayString>{{ idx={idx} }}</DisplayString> <Expand> <ExpandedItem>this,!</ExpandedItem> - <ExpandedItem>bgfx::s_ctx->m_declRef[idx]</ExpandedItem> + <ExpandedItem>bgfx::s_ctx->m_vertexLayoutRef[idx]</ExpandedItem> </Expand> </Type> diff --git a/3rdparty/bgfx/scripts/bindings-cs.lua b/3rdparty/bgfx/scripts/bindings-cs.lua new file mode 100644 index 00000000000..8e6bfc47b1a --- /dev/null +++ b/3rdparty/bgfx/scripts/bindings-cs.lua @@ -0,0 +1,425 @@ +local codegen = require "codegen" +local idl = codegen.idl "bgfx.idl" + +local csharp_template = [[ +/* + * Copyright 2011-2019 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE + */ + +/* + * + * AUTO GENERATED! DO NOT EDIT! + * + */ + +using System; +using System.Runtime.InteropServices; + +namespace Bgfx +{ +public static partial class bgfx +{ + $types + + $funcs + +#if !BGFX_CSHARP_CUSTOM_DLLNAME +#if DEBUG + const string DllName = "bgfx_debug.dll"; +#else + const string DllName = "bgfx.dll"; +#endif +#endif +} +} +]] + +local function hasPrefix(str, prefix) + return prefix == "" or str:sub(1, #prefix) == prefix +end + +local function hasSuffix(str, suffix) + return suffix == "" or str:sub(-#suffix) == suffix +end + +local function convert_type_0(arg) + + if hasPrefix(arg.ctype, "uint64_t") then + return arg.ctype:gsub("uint64_t", "ulong") + elseif hasPrefix(arg.ctype, "int64_t") then + return arg.ctype:gsub("int64_t", "long") + elseif hasPrefix(arg.ctype, "uint32_t") then + return arg.ctype:gsub("uint32_t", "uint") + elseif hasPrefix(arg.ctype, "int32_t") then + return arg.ctype:gsub("int32_t", "int") + elseif hasPrefix(arg.ctype, "uint16_t") then + return arg.ctype:gsub("uint16_t", "ushort") + elseif hasPrefix(arg.ctype, "bgfx_view_id_t") then + return arg.ctype:gsub("bgfx_view_id_t", "ushort") + elseif hasPrefix(arg.ctype, "uint8_t") then + return arg.ctype:gsub("uint8_t", "byte") + elseif hasPrefix(arg.ctype, "uintptr_t") then + return arg.ctype:gsub("uintptr_t", "UIntPtr") + elseif arg.ctype == "bgfx_caps_gpu_t" then + return arg.ctype:gsub("bgfx_caps_gpu_t", "uint") + elseif arg.ctype == "const char*" then + return "[MarshalAs(UnmanagedType.LPStr)] string" + elseif hasPrefix(arg.ctype, "char") then + return arg.ctype:gsub("char", "byte") + elseif hasSuffix(arg.fulltype, "Handle") then + return arg.fulltype + elseif arg.ctype == "..." then + return "[MarshalAs(UnmanagedType.LPStr)] string args" + elseif arg.ctype == "va_list" + or arg.fulltype == "bx::AllocatorI*" + or arg.fulltype == "CallbackI*" + or arg.fulltype == "ReleaseFn" then + return "IntPtr" + elseif arg.fulltype == "const ViewId*" then + return "ushort*" + end + + return arg.fulltype +end + +local function convert_type(arg) + local ctype = convert_type_0(arg) + ctype = ctype:gsub("::Enum", "") + ctype = ctype:gsub("const ", "") + ctype = ctype:gsub(" &", "*") + ctype = ctype:gsub("&", "*") + return ctype +end + +local function convert_struct_type(arg) + local ctype = convert_type(arg) + if hasPrefix(arg.ctype, "bool") then + ctype = ctype:gsub("bool", "byte") + end + return ctype +end + +local function convert_ret_type(arg) + local ctype = convert_type(arg) + if hasPrefix(ctype, "[MarshalAs(UnmanagedType.LPStr)]") then + return "IntPtr" + end + return ctype +end + +local converter = {} +local yield = coroutine.yield +local indent = "" + +local gen = {} + +function gen.gen() + local r = csharp_template:gsub("$(%l+)", function(what) + local tmp = {} + for _, object in ipairs(idl[what]) do + local co = coroutine.create(converter[what]) + local any + while true do + local ok, v = coroutine.resume(co, object) + assert(ok, debug.traceback(co, v)) + if not v then + break + end + table.insert(tmp, v) + any = true + end + if any and tmp[#tmp] ~= "" then + table.insert(tmp, "") + end + end + return table.concat(tmp, "\n\t") + end) + return r +end + +local combined = { "State", "Stencil", "Buffer", "Texture", "Sampler", "Reset" } + +for _, v in ipairs(combined) do + combined[v] = {} +end + +local lastCombinedFlag + +local function FlagBlock(typ) + local format = "0x%08x" + local enumType = " : uint" + if typ.bits == 64 then + format = "0x%016x" + enumType = " : ulong" + elseif typ.bits == 16 then + format = "0x%04x" + enumType = " : ushort" + end + + yield("[Flags]") + yield("public enum " .. typ.name .. "Flags" .. enumType) + yield("{") + + for idx, flag in ipairs(typ.flag) do + + if flag.comment ~= nil then + if idx ~= 1 then + yield("") + end + + yield("\t/// <summary>") + for _, comment in ipairs(flag.comment) do + yield("\t/// " .. comment) + end + yield("\t/// </summary>") + end + + local flagName = flag.name:gsub("_", "") + yield("\t" + .. flagName + .. string.rep(" ", 22 - #(flagName)) + .. " = " + .. string.format(flag.format or format, flag.value) + .. "," + ) + end + + if typ.shift then + yield("\t" + .. "Shift" + .. string.rep(" ", 22 - #("Shift")) + .. " = " + .. flag.shift + ) + end + + -- generate Mask + if typ.mask then + yield("\t" + .. "Mask" + .. string.rep(" ", 22 - #("Mask")) + .. " = " + .. string.format(format, flag.mask) + ) + end + + yield("}") +end + +local function lastCombinedFlagBlock() + if lastCombinedFlag then + local typ = combined[lastCombinedFlag] + if typ then + FlagBlock(combined[lastCombinedFlag]) + yield("") + end + lastCombinedFlag = nil + end +end + +local enum = {} + +local function convert_array(member) + if string.find(member.array, "::") then + return string.format("[%d]", enum[member.array]) + else + return member.array + end +end + +local function convert_struct_member(member) + if member.array then + return "fixed " .. convert_struct_type(member) .. " " .. member.name .. convert_array(member) + else + return convert_struct_type(member) .. " " .. member.name + end +end + +local namespace = "" + +function converter.types(typ) + if typ.handle then + lastCombinedFlagBlock() + + yield("public struct " .. typ.name .. "{ public ushort idx; }") + elseif hasSuffix(typ.name, "::Enum") then + lastCombinedFlagBlock() + + yield("public enum " .. typ.typename) + yield("{") + for idx, enum in ipairs(typ.enum) do + + if enum.comment ~= nil then + if idx ~= 1 then + yield("") + end + + yield("\t/// <summary>") + for _, comment in ipairs(enum.comment) do + yield("\t/// " .. comment) + end + yield("\t/// </summary>") + end + + yield("\t" .. enum.name .. ",") + end + yield(""); + yield("\tCount") + yield("}") + + enum["[" .. typ.typename .. "::Count]"] = #typ.enum + + elseif typ.bits ~= nil then + local prefix, name = typ.name:match "(%u%l+)(.*)" + if prefix ~= lastCombinedFlag then + lastCombinedFlagBlock() + lastCombinedFlag = prefix + end + local combinedFlag = combined[prefix] + if combinedFlag then + combinedFlag.bits = typ.bits + combinedFlag.name = prefix + local flags = combinedFlag.flag or {} + combinedFlag.flag = flags + local lookup = combinedFlag.lookup or {} + combinedFlag.lookup = lookup + for _, flag in ipairs(typ.flag) do + local flagName = name .. flag.name:gsub("_", "") + local value = flag.value + if value == nil then + -- It's a combined flag + value = 0 + for _, v in ipairs(flag) do + value = value | assert(lookup[name .. v], v .. " is not defined for " .. flagName) + end + end + lookup[flagName] = value + table.insert(flags, { + name = flagName, + value = value, + comment = flag.comment, + }) + end + + if typ.shift then + table.insert(flags, { + name = name .. "Shift", + value = typ.shift, + format = "%d", + comment = typ.comment, + }) + end + + if typ.mask then + -- generate Mask + table.insert(flags, { + name = name .. "Mask", + value = typ.mask, + comment = typ.comment, + }) + lookup[name .. "Mask"] = typ.mask + end + else + FlagBlock(typ) + end + elseif typ.struct ~= nil then + + local skip = false + + if typ.namespace ~= nil then + if namespace ~= typ.namespace then + yield("public unsafe struct " .. typ.namespace) + yield("{") + namespace = typ.namespace + indent = "\t" + end + elseif namespace ~= "" then + indent = "" + namespace = "" + skip = true + end + + if not skip then + yield(indent .. "public unsafe struct " .. typ.name) + yield(indent .. "{") + end + + for _, member in ipairs(typ.struct) do + yield( + indent .. "\tpublic " .. convert_struct_member(member) .. ";" + ) + end + + yield(indent .. "}") + end +end + +function converter.funcs(func) + + if func.cpponly then + return + end + + if func.comments ~= nil then + yield("/// <summary>") + for _, line in ipairs(func.comments) do + yield("/// " .. line) + end + yield("/// </summary>") + yield("///") + + local hasParams = false + + for _, arg in ipairs(func.args) do + if arg.comment ~= nil then + local comment = table.concat(arg.comment, " ") + + yield("/// <param name=\"" + .. arg.name + .. "\">" + .. comment + .. "</param>" + ) + + hasParams = true + end + end + + if hasParams then + yield("///") + end + end + + yield("[DllImport(DllName, EntryPoint=\"bgfx_" .. func.cname .. "\", CallingConvention = CallingConvention.Cdecl)]") + + if func.ret.cpptype == "bool" then + yield("[return: MarshalAs(UnmanagedType.I1)]") + end + + local args = {} + if func.this ~= nil then + args[1] = func.this_type.type .. "* _this" + end + for _, arg in ipairs(func.args) do + table.insert(args, convert_type(arg) .. " " .. arg.name) + end + yield("public static extern unsafe " .. convert_ret_type(func.ret) .. " " .. func.cname + .. "(" .. table.concat(args, ", ") .. ");") +end + +-- printtable("idl types", idl.types) +-- printtable("idl funcs", idl.funcs) + +function gen.write(codes, outputfile) + local out = assert(io.open(outputfile, "wb")) + out:write(codes) + out:close() +end + +if (...) == nil then + -- run `lua bindings-cs.lua` in command line + print(gen.gen()) +end + +return gen diff --git a/3rdparty/bgfx/scripts/build.ninja b/3rdparty/bgfx/scripts/build.ninja index 1cfcac5c497..1f023986921 100644 --- a/3rdparty/bgfx/scripts/build.ninja +++ b/3rdparty/bgfx/scripts/build.ninja @@ -4,6 +4,10 @@ rule geometryc_pack_normal command = geometryc -f $in -o $out --packnormal 1 description = Converting geometry $in... +rule geometryc_pack_normal_compressed + command = geometryc -f $in -o $out --packnormal 1 -c + description = Converting geometry $in... + rule geometryc_pack_normal_barycentric command = geometryc -f $in -o $out --packnormal 1 --barycentric description = Converting geometry $in... diff --git a/3rdparty/bgfx/scripts/codegen.lua b/3rdparty/bgfx/scripts/codegen.lua new file mode 100644 index 00000000000..3b6a3a937ce --- /dev/null +++ b/3rdparty/bgfx/scripts/codegen.lua @@ -0,0 +1,994 @@ +-- Copyright 2019 云风 https://github.com/cloudwu . All rights reserved. +-- License (the same with bgfx) : https://github.com/bkaradzic/bgfx/blob/master/LICENSE + +local codegen = {} + +local NAMEALIGN = 20 + +local function namealign(name, align) + align = align or NAMEALIGN + return string.rep(" ", align - #name) +end + +local function camelcase_to_underscorecase(name) + local tmp = {} + for v in name:gmatch "[%u%d]+%l*" do + tmp[#tmp+1] = v:lower() + end + return table.concat(tmp, "_") +end + +local function to_underscorecase(name) + local tmp = {} + for v in name:gmatch "[_%u][%l%d]*" do + if v:byte() == 95 then -- '_' + v = v:sub(2) -- remove _ + end + tmp[#tmp+1] = v + end + return table.concat(tmp, "_") +end + +local function underscorecase_to_camelcase(name) + local tmp = {} + for v in name:gmatch "[^_]+" do + tmp[#tmp+1] = v:sub(1,1):upper() .. v:sub(2) + end + return table.concat(tmp) +end + +local function convert_funcname(name) + name = name:gsub("^%l", string.upper) -- Change to upper CamlCase + return camelcase_to_underscorecase(name) +end + +local function convert_arg(all_types, arg, namespace) + local fulltype, array = arg.fulltype:match "(.-)%s*(%[%s*[%d%a_:]*%s*%])" + if array then + arg.fulltype = fulltype + arg.array = array + local enum, value = array:match "%[%s*([%a%d]+)::([%a%d]+)%]" + if enum then + local typedef = all_types[ enum .. "::Enum" ] + if typedef == nil then + error ("Unknown Enum " .. enum) + end + arg.carray = "[BGFX_" .. camelcase_to_underscorecase(enum):upper() .. "_" .. value:upper() .. "]" + end + end + local t, postfix = arg.fulltype:match "(%a[%a%d_:]*)%s*([*&]+)%s*$" + if t then + arg.type = t + if postfix == "&" then + arg.ref = true + end + else + local prefix, t = arg.fulltype:match "^%s*(%a+)%s+(%S+)" + if prefix then + arg.type = t + else + arg.type = arg.fulltype + end + end + local ctype + local substruct = namespace.substruct + if substruct then + ctype = substruct[arg.type] + end + if not ctype then + ctype = all_types[arg.type] + end + if not ctype then + error ("Undefined type " .. arg.fulltype .. " in " .. namespace.name) + end + arg.ctype = arg.fulltype:gsub(arg.type, ctype.cname):gsub("&", "*") + if ctype.cname ~= arg.type then + arg.cpptype = arg.fulltype:gsub(arg.type, "bgfx::"..arg.type) + else + arg.cpptype = arg.fulltype + end + if arg.ref then + arg.ptype = arg.cpptype:gsub("&", "*") + end +end + +local function alternative_name(name) + if name:sub(1,1) == "_" then + return name:sub(2) + else + return name .. "_" + end +end + +local function gen_arg_conversion(all_types, arg) + if arg.ctype == arg.fulltype then + -- do not need conversion + return + end + local ctype = all_types[arg.type] + if ctype.handle and arg.type == arg.fulltype then + local aname = alternative_name(arg.name) + arg.aname = aname .. ".cpp" + arg.aname_cpp2c = aname .. ".c" + arg.conversion = string.format( + "union { %s c; bgfx::%s cpp; } %s = { %s };" , + ctype.cname, arg.type, aname, arg.name) + arg.conversion_back = string.format( + "union { bgfx::%s cpp; %s c; } %s = { %s };" , + arg.type, ctype.cname, aname, arg.name) + elseif arg.ref then + if ctype.cname == arg.type then + arg.aname = "*" .. arg.name + arg.aname_cpp2c = "&" .. arg.name + elseif arg.out and ctype.enum then + local aname = alternative_name(arg.name) + local cpptype = arg.cpptype:match "(.-)%s*&" -- remove & + local c99type = arg.ctype:match "(.-)%s*%*" -- remove * + arg.aname = aname + arg.aname_cpp2c = "&" .. aname + arg.conversion = string.format("%s %s;", cpptype, aname) + arg.conversion_back = string.format("%s %s;", c99type, aname); + arg.out_conversion = string.format("*%s = (%s)%s;", arg.name, ctype.cname, aname) + arg.out_conversion_back = string.format("%s = (%s)%s;", arg.name, c99type, aname) + else + arg.aname = alternative_name(arg.name) + arg.aname_cpp2c = string.format("(%s)&%s" , arg.ctype , arg.name) + arg.conversion = string.format( + "%s %s = *(%s)%s;", + arg.cpptype, arg.aname, arg.ptype, arg.name) + end + else + local cpptype = arg.cpptype + local ctype = arg.ctype + if arg.array then + cpptype = cpptype .. "*" + ctype = ctype .. "*" + end + arg.aname = string.format( + "(%s)%s", + cpptype, arg.name) + arg.aname_cpp2c = string.format( + "(%s)%s", + ctype, arg.name) + end +end + +local function gen_ret_conversion(all_types, func) + local postfix = { func.vararg and "va_end(argList);" } + local postfix_cpp2c = { postfix[1] } + func.ret_postfix = postfix + func.ret_postfix_cpp2c = postfix_cpp2c + + for _, arg in ipairs(func.args) do + if arg.out_conversion then + postfix[#postfix+1] = arg.out_conversion + postfix_cpp2c[#postfix_cpp2c+1] = arg.out_conversion_back + end + end + + local ctype = all_types[func.ret.type] + if ctype.handle then + func.ret_conversion = string.format( + "union { %s c; bgfx::%s cpp; } handle_ret;" , + ctype.cname, ctype.name) + func.ret_conversion_cpp2c = string.format( + "union { bgfx::%s cpp; %s c; } handle_ret;" , + ctype.name, ctype.cname) + func.ret_prefix = "handle_ret.cpp = " + func.ret_prefix_cpp2c = "handle_ret.c = " + postfix[#postfix+1] = "return handle_ret.c;" + postfix_cpp2c[#postfix_cpp2c+1] = "return handle_ret.cpp;" + elseif func.ret.fulltype ~= "void" then + local ctype_conversion = "" + local conversion_back = "" + if ctype.name ~= ctype.cname then + if func.ret.ref then + ctype_conversion = "(" .. func.ret.ctype .. ")&" + conversion_back = "*(" .. func.ret.ptype .. ")" + else + ctype_conversion = "(" .. func.ret.ctype .. ")" + conversion_back = "(" .. func.ret.cpptype .. ")" + end + end + if #postfix > 0 then + func.ret_prefix = string.format("%s retValue = %s", func.ret.ctype , ctype_conversion) + func.ret_prefix_cpp2c = string.format("%s retValue = %s", func.ret.cpptype , conversion_back) + local ret = "return retValue;" + postfix[#postfix+1] = ret + postfix_cpp2c[#postfix_cpp2c+1] = ret + else + func.ret_prefix = string.format("return %s", ctype_conversion) + func.ret_prefix_cpp2c = string.format("return %s", conversion_back) + end + end +end + +local function convert_vararg(v) + if v.vararg then + local args = v.args + local vararg = { + name = "", + fulltype = "...", + type = "...", + ctype = "...", + aname = "argList", + conversion = string.format( + "va_list argList;\n\tva_start(argList, %s);", + args[#args].name), + } + args[#args + 1] = vararg + v.alter_name = v.vararg + end +end + +local function calc_flag_values(flag) + local shift = flag.shift + local base = flag.base or 0 + local cap = 1 << (flag.range or 0) + + if flag.range then + if flag.range == 64 then + flag.mask = 0xffffffffffffffff + else + flag.mask = ((1 << flag.range) - 1) << shift + end + end + + local values = {} + for index, item in ipairs(flag.flag) do + local value = item.value + if flag.const then + -- use value directly + elseif shift then + if value then + if value > 0 then + value = value - 1 + end + else + value = index + base - 1 + end + if value >= cap then + error (string.format("Out of range for %s.%s (%d/%d)", flag.name, item.name, value, cap)) + end + value = value << shift + elseif #item == 0 then + if value then + if value > 0 then + value = 1 << (value - 1) + end + else + local s = index + base - 2 + if s >= 0 then + value = 1 << s + else + value = 0 + end + end + end + if not value then + -- It's a combine flags + value = 0 + for _, name in ipairs(item) do + local v = values[name] + if v then + value = value | v + else + -- todo : it's a undefined flag + value = nil + break + end + end + end + item.value = value + values[item.name] = value + end +end + +function codegen.nameconversion(all_types, all_funcs) + for _,v in ipairs(all_types) do + local name = v.name + local cname = v.cname + if cname == nil then + if name:match "^%u" then + cname = camelcase_to_underscorecase(name) + elseif not v.flag then + v.cname = name + end + end + if cname and not v.flag then + if v.namespace then + cname = camelcase_to_underscorecase(v.namespace) .. "_" .. cname + end + v.cname = "bgfx_".. cname .. "_t" + end + if v.enum then + v.typename = v.name + v.name = v.name .. "::Enum" + end + if v.flag then + calc_flag_values(v) + end + end + + -- make index + for _,v in ipairs(all_types) do + if not v.namespace then + if all_types[v.name] then + error ("Duplicate type " .. v.name) + elseif not v.flag then + all_types[v.name] = v + end + end + end + + -- make sub struct index + for _,v in ipairs(all_types) do + if v.namespace then + local super = all_types[v.namespace] + if not super then + error ("Define " .. v.namespace .. " first") + end + local substruct = super.substruct + if not substruct then + substruct = {} + super.substruct = substruct + end + if substruct[v.name] then + error ( "Duplicate sub struct " .. v.name .. " in " .. v.namespace) + end + v.parent_class = super + substruct[#substruct+1] = v + substruct[v.name] = v + end + end + + for _,v in ipairs(all_types) do + if v.struct then + for _, item in ipairs(v.struct) do + convert_arg(all_types, item, v) + end + elseif v.args then + -- funcptr + for _, arg in ipairs(v.args) do + convert_arg(all_types, arg, v) + end + convert_vararg(v) + convert_arg(all_types, v.ret, v) + end + end + + local funcs = {} + local funcs_conly = {} + local funcs_alter = {} + + for _,v in ipairs(all_funcs) do + if v.cname == nil then + v.cname = convert_funcname(v.name) + end + if v.class then + v.cname = convert_funcname(v.class) .. "_" .. v.cname + local classtype = all_types[v.class] + if classtype then + local methods = classtype.methods + if not methods then + methods = {} + classtype.methods = methods + end + methods[#methods+1] = v + end + elseif not v.conly then + funcs[v.name] = v + end + + if v.conly then + table.insert(funcs_conly, v) + end + + for _, arg in ipairs(v.args) do + convert_arg(all_types, arg, v) + gen_arg_conversion(all_types, arg) + end + convert_vararg(v) + if v.alter_name then + funcs_alter[#funcs_alter+1] = v + end + convert_arg(all_types, v.ret, v) + gen_ret_conversion(all_types, v) + local namespace = v.class + if namespace then + local classname = namespace + if v.const then + classname = "const " .. classname + end + local classtype = { fulltype = classname .. "*" } + convert_arg(all_types, classtype, v) + v.this = classtype.ctype + v.this_type = classtype + v.this_conversion = string.format( "%s This = (%s)_this;", classtype.cpptype, classtype.cpptype) + v.this_to_c = string.format("(%s)this", classtype.ctype) + end + end + + for _, v in ipairs(funcs_conly) do + local func = funcs[v.name] + if func then + func.multicfunc = func.multicfunc or { func.cname } + table.insert(func.multicfunc, v.cname) + end + end + + for _, v in ipairs(funcs_alter) do + local func = funcs[v.alter_name] + v.alter_cname = func.cname + end +end + +local function lines(tbl) + if not tbl or #tbl == 0 then + return "//EMPTYLINE" + else + return table.concat(tbl, "\n\t") + end +end + +local function remove_emptylines(txt) + return (txt:gsub("\t//EMPTYLINE\n", "")) +end + +local function codetemp(func) + local conversion = {} + local conversion_c2cpp = {} + local args = {} + local cargs = {} + local callargs_conversion = {} + local callargs_conversion_back = {} + local callargs = {} + local cppfunc + local classname + + if func.class then + -- It's a member function + cargs[1] = func.this .. " _this" + conversion[1] = func.this_conversion + cppfunc = "This->" .. func.name + callargs[1] = "_this" + callargs_conversion_back[1] = func.this_to_c + classname = func.class .. "::" + else + cppfunc = "bgfx::" .. tostring(func.alter_name or func.name) + classname = "" + end + for _, arg in ipairs(func.args) do + conversion[#conversion+1] = arg.conversion + conversion_c2cpp[#conversion_c2cpp+1] = arg.conversion_back + local cname = arg.ctype .. " " .. arg.name + if arg.array then + cname = cname .. (arg.carray or arg.array) + end + local name = arg.fulltype .. " " .. arg.name + if arg.array then + name = name .. arg.array + end + if arg.default ~= nil then + name = name .. " = " .. tostring(arg.default) + end + cargs[#cargs+1] = cname + args[#args+1] = name + callargs_conversion[#callargs_conversion+1] = arg.aname or arg.name + callargs_conversion_back[#callargs_conversion_back+1] = arg.aname_cpp2c or arg.name + callargs[#callargs+1] = arg.name + end + conversion[#conversion+1] = func.ret_conversion + conversion_c2cpp[#conversion_c2cpp+1] = func.ret_conversion_cpp2c + + local ARGS + local args_n = #args + if args_n == 0 then + ARGS = "" + elseif args_n == 1 then + ARGS = args[1] + else + ARGS = "\n\t " .. table.concat(args, "\n\t, ") .. "\n\t" + end + + local preret_c2c + local postret_c2c = {} + local conversion_c2c = {} + local callfunc_c2c + + if func.vararg then + postret_c2c[1] = "va_end(argList);" + local vararg = func.args[#func.args] + callargs[#callargs] = vararg.aname + callargs_conversion_back[#callargs_conversion_back] = vararg.aname + conversion_c2c[1] = vararg.conversion + conversion_c2cpp[1] = vararg.conversion + + if func.ret.fulltype == "void" then + preret_c2c = "" + else + preret_c2c = func.ret.ctype .. " retValue = " + postret_c2c[#postret_c2c+1] = "return retValue;" + end + callfunc_c2c = func.alter_cname or func.cname + else + if func.ret.fulltype == "void" then + preret_c2c = "" + else + preret_c2c = "return " + end + callfunc_c2c = func.cname + end + + outCargs = table.concat(cargs, ", ") + if outCargs == "" then + outCargs = "void" + end + + return { + RET = func.ret.fulltype, + CRET = func.ret.ctype, + CFUNCNAME = func.cname, + CFUNCNAMEUPPER = func.cname:upper(), + CFUNCNAMECAML = underscorecase_to_camelcase(func.cname), + FUNCNAME = func.name, + CARGS = outCargs, + CPPARGS = table.concat(args, ", "), + ARGS = ARGS, + CONVERSION = lines(conversion), + CONVERSIONCTOC = lines(conversion_c2c), + CONVERSIONCTOCPP = lines(conversion_c2cpp), + PRERET = func.ret_prefix or "", + PRERETCPPTOC = func.ret_prefix_cpp2c or "", + CPPFUNC = cppfunc, + CALLFUNCCTOC = callfunc_c2c, + CALLARGSCTOCPP = table.concat(callargs_conversion, ", "), + CALLARGSCPPTOC = table.concat(callargs_conversion_back, ", "), + CALLARGS = table.concat(callargs, ", "), + POSTRET = lines(func.ret_postfix), + POSTRETCPPTOC = lines(func.ret_postfix_cpp2c), + PRERETCTOC = preret_c2c, + POSTRETCTOC = lines(postret_c2c), + CLASSNAME = classname, + CONST = func.const and " const" or "", + } +end + +local function apply_template(func, temp) + func.codetemp = func.codetemp or codetemp(func) + return (temp:gsub("$(%u+)", func.codetemp)) +end + +function codegen.apply_functemp(func, temp) + return remove_emptylines(apply_template(func, temp)) +end + +function codegen.gen_funcptr(funcptr) + return apply_template(funcptr, "typedef $RET (*$FUNCNAME)($ARGS);") +end + +function codegen.gen_cfuncptr(funcptr) + return apply_template(funcptr, "typedef $CRET (*$CFUNCNAME)($CARGS);") +end + +local function doxygen_funcret(r, func, prefix) + if not func or func.ret.fulltype == "void" or func.ret.comment == nil then + return + end + r[#r+1] = prefix + r[#r+1] = string.format("%s @returns %s", prefix, func.ret.comment[1]) + for i = 2,#func.ret.comment do + r[#r+1] = string.format("%s %s", prefix, func.ret.comment[i]) + end + return r +end + +local function doxygen_func(r, func, prefix) + if not func or not func.args or #func.args == 0 then + return + end + r[#r+1] = prefix + for _, arg in ipairs(func.args) do + local inout + if arg.out then + inout = "out" + elseif arg.inout then + inout = "inout" + else + inout = "in" + end + local comment = string.format("%s @param[%s] %s", prefix, inout, arg.name) + if arg.comment then + r[#r+1] = comment .. " " .. arg.comment[1] + for i = 2,#arg.comment do + r[#r+1] = string.format("%s %s", prefix, arg.comment[i]) + end + else + r[#r+1] = comment + end + end + doxygen_funcret(r, func, prefix) + return r +end + +function codegen.doxygen_type(doxygen, func, cname) + if doxygen == nil then + return + end + local result = {} + for _, line in ipairs(doxygen) do + result[#result+1] = "/// " .. line + end + doxygen_func(result, func, "///") + if cname then + result[#result+1] = "///" + if type(cname) == "string" then + result[#result+1] = string.format("/// @attention C99 equivalent is `%s`.", cname) + else + local names = {} + for _, v in ipairs(cname) do + names[#names+1] = "`" .. v .. "`" + end + result[#result+1] = string.format("/// @attention C99 equivalent are %s.", table.concat(names, ",")) + end + end + result[#result+1] = "///" + return table.concat(result, "\n") +end + +function codegen.doxygen_ctype(doxygen, func) + if doxygen == nil then + return + end + local result = { + "/**", + } + for _, line in ipairs(doxygen) do + result[#result+1] = " * " .. line + end + doxygen_func(result, func, " *") + result[#result+1] = " *" + result[#result+1] = " */" + return table.concat(result, "\n") +end + +local enum_temp = [[ +struct $NAME +{ + $COMMENT + enum Enum + { + $ITEMS + + Count + }; +}; +]] + +function codegen.gen_enum_define(enum) + assert(type(enum.enum) == "table", "Not an enum") + local items = {} + for _, item in ipairs(enum.enum) do + local text + if not item.comment then + text = item.name .. "," + else + local comment = table.concat(item.comment, " ") + text = string.format("%s,%s //!< %s", + item.name, namealign(item.name), comment) + end + items[#items+1] = text + end + local comment = "" + if enum.comment then + comment = "/// " .. enum.comment + end + local temp = { + NAME = enum.typename, + COMMENT = comment, + ITEMS = table.concat(items, "\n\t\t"), + } + return (enum_temp:gsub("$(%u+)", temp)) +end + +local cenum_temp = [[ +typedef enum $NAME +{ + $ITEMS + + $COUNT + +} $NAME_t; +]] +function codegen.gen_enum_cdefine(enum) + assert(type(enum.enum) == "table", "Not an enum") + local cname = enum.cname:match "(.-)_t$" + local uname = cname:upper() + local items = {} + for index , item in ipairs(enum.enum) do + local comment = "" + if item.comment then + comment = table.concat(item.comment, " ") + end + local ename = item.cname + if not ename then + if enum.underscore then + ename = camelcase_to_underscorecase(item.name) + else + ename = item.name + end + ename = ename:upper() + end + local name = uname .. "_" .. ename + items[#items+1] = string.format("%s,%s /** (%2d) %s%s */", + name, + namealign(name, 40), + index - 1, + comment, + namealign(comment, 30)) + end + + local temp = { + NAME = cname, + COUNT = uname .. "_COUNT", + ITEMS = table.concat(items, "\n\t"), + } + + return (cenum_temp:gsub("$(%u+)", temp)) +end + +local function flag_format(flag) + if not flag.format then + flag.format = "%0" .. (flag.bits // 4) .. "x" + end +end + +function codegen.gen_flag_cdefine(flag) + assert(type(flag.flag) == "table", "Not a flag") + flag_format(flag) + local cname = "BGFX_" .. (flag.cname or to_underscorecase(flag.name):upper()) + local s = {} + local shift = flag.shift + for index, item in ipairs(flag.flag) do + local name + if item.cname then + name = cname .. "_" .. item.cname + else + name = cname .. "_" .. to_underscorecase(item.name):upper() + end + local value = item.value + + -- combine flags + if #item > 0 then + if item.comment then + for _, c in ipairs(item.comment) do + s[#s+1] = "/// " .. c + end + end + local sets = { "" } + for _, v in ipairs(item) do + sets[#sets+1] = cname .. "_" .. to_underscorecase(v):upper() + end + s[#s+1] = string.format("#define %s (0%s \\\n\t)\n", name, table.concat(sets, " \\\n\t| ")) + else + local comment = "" + if item.comment then + if #item.comment > 1 then + for _, c in ipairs(item.comment) do + s[#s+1] = "/// " .. c + end + else + comment = " //!< " .. item.comment[1] + end + end + value = string.format(flag.format, value) + local code = string.format("#define %s %sUINT%d_C(0x%s)%s", + name, namealign(name, 35), flag.bits, value, comment) + s[#s+1] = code + end + end + + local mask + if flag.mask then + mask = string.format(flag.format, flag.mask) + mask = string.format("UINT%d_C(0x%s)", flag.bits, mask) + end + + if shift then + local name = cname .. "_SHIFT" + local comment = flag.desc or "" + local shift_align = tostring(shift) + shift_align = shift_align .. namealign(shift_align, #mask) + local comment = "" + if flag.desc then + comment = string.format(" //!< %s bit shift", flag.desc) + end + local code = string.format("#define %s %s%s%s", name, namealign(name, 35), shift_align, comment) + s[#s+1] = code + end + if flag.range then + local name = cname .. "_MASK" + local comment = "" + if flag.desc then + comment = string.format(" //!< %s bit mask", flag.desc) + end + local code = string.format("#define %s %s%s%s", name, namealign(name, 35), mask, comment) + s[#s+1] = code + end + + if flag.helper then + s[#s+1] = string.format( + "#define %s(v) ( ( (uint%d_t)(v)<<%s )&%s)", + cname, + flag.bits, + (cname .. "_SHIFT"), + (cname .. "_MASK")) + end + + s[#s+1] = "" + + return table.concat(s, "\n") +end + +local function text_with_comments(items, item, cstyle, is_classmember) + local name = item.name + if item.array then + if cstyle then + name = name .. (item.carray or item.array) + else + name = name .. item.array + end + end + local typename + if cstyle then + typename = item.ctype + else + typename = item.fulltype + end + if is_classmember then + name = "m_" .. name + end + local text = string.format("%s%s %s;", typename, namealign(typename), name) + if item.comment then + if #item.comment > 1 then + table.insert(items, "") + if cstyle then + table.insert(items, "/**") + for _, c in ipairs(item.comment) do + table.insert(items, " * " .. c) + end + table.insert(items, " */") + else + for _, c in ipairs(item.comment) do + table.insert(items, "/// " .. c) + end + end + else + text = string.format( + cstyle and "%s %s/** %s%s */" or "%s %s//!< %s", + text, namealign(text, 40), item.comment[1], namealign(item.comment[1], 40)) + end + end + items[#items+1] = text +end + +local struct_temp = [[ +struct $NAME +{ + $METHODS + $SUBSTRUCTS + $ITEMS +}; +]] + +function codegen.gen_struct_define(struct, methods) + assert(type(struct.struct) == "table", "Not a struct") + local items = {} + for _, item in ipairs(struct.struct) do + text_with_comments(items, item, false, methods ~= nil and not struct.shortname) + end + local ctor = {} + if struct.ctor then + ctor[1] = struct.name .. "();" + ctor[2] = "" + end + if methods then + for _, m in ipairs(methods) do + if m:sub(-1) ~= "\n" then + m = m .. "\n" + end + for line in m:gmatch "(.-)\n" do + ctor[#ctor+1] = line + end + ctor[#ctor+1] = "" + end + end + local subs = {} + if struct.substruct then + for _, v in ipairs(struct.substruct) do + local s = codegen.gen_struct_define(v) + s = s:gsub("\n", "\n\t") + subs[#subs+1] = s + end + end + + local temp = { + NAME = struct.name, + SUBSTRUCTS = lines(subs), + ITEMS = table.concat(items, "\n\t"), + METHODS = lines(ctor), + } + return remove_emptylines(struct_temp:gsub("$(%u+)", temp)) +end + +local cstruct_temp = [[ +typedef struct $NAME_s +{ + $ITEMS + +} $NAME_t; +]] +local cstruct_empty_temp = [[ +struct $NAME_s; +typedef struct $NAME_s $NAME_t; +]] +function codegen.gen_struct_cdefine(struct) + assert(type(struct.struct) == "table", "Not a struct") + local cname = struct.cname:match "(.-)_t$" + local items = {} + for _, item in ipairs(struct.struct) do + text_with_comments(items, item, true) + end + local temp = { + NAME = cname, + ITEMS = table.concat(items, "\n\t"), + } + local codetemp = #struct.struct == 0 and cstruct_empty_temp or cstruct_temp + return (codetemp:gsub("$(%u+)", temp)) +end + +local chandle_temp = [[ +typedef struct $NAME_s { uint16_t idx; } $NAME_t; +]] +function codegen.gen_chandle(handle) + assert(handle.handle, "Not a handle") + return (chandle_temp:gsub("$(%u+)", { NAME = handle.cname:match "(.-)_t$" })) +end + +local handle_temp = [[ +struct $NAME { uint16_t idx; }; +inline bool isValid($NAME _handle) { return bgfx::kInvalidHandle != _handle.idx; } +]] +function codegen.gen_handle(handle) + assert(handle.handle, "Not a handle") + return (handle_temp:gsub("$(%u+)", { NAME = handle.name })) +end + +local idl = require "idl" +local doxygen = require "doxygen" +local conversion +local idlfile = {} + +function codegen.load(filename) + assert(conversion == nil, "Don't call codegen.load() after codegen.idl()") + assert(idlfile[filename] == nil, "Duplicate load " .. filename) + local source = doxygen.load(filename) + + local f = assert(load(source, filename , "t", idl)) + f() + idlfile[filename] = true +end + +function codegen.idl(filename) + if conversion == nil then + if filename and not idlfile[filename] then + codegen.load(filename) + end + assert(next(idlfile), "call codegen.load() first") + conversion = true + codegen.nameconversion(idl.types, idl.funcs) + end + return idl +end + +return codegen diff --git a/3rdparty/bgfx/scripts/doxygen.lua b/3rdparty/bgfx/scripts/doxygen.lua new file mode 100644 index 00000000000..531210e7b42 --- /dev/null +++ b/3rdparty/bgfx/scripts/doxygen.lua @@ -0,0 +1,19 @@ +local doxygen = {} + +function doxygen.load(filename) + local lines = {} + for line in io.lines(filename) do + local code, comment = line:match "(.-)%-%-%-[ \t](.*)" + if code then + if code == "" then + line = string.format("comment [[%s]]", comment) + else + line = string.format("%s [[%s]]", code, comment) + end + end + lines[#lines+1] = line + end + return table.concat(lines, "\n") +end + +return doxygen diff --git a/3rdparty/bgfx/scripts/example-common.lua b/3rdparty/bgfx/scripts/example-common.lua index 976675ee746..66f5fad8e5e 100644 --- a/3rdparty/bgfx/scripts/example-common.lua +++ b/3rdparty/bgfx/scripts/example-common.lua @@ -1,5 +1,5 @@ -- --- Copyright 2010-2018 Branimir Karadzic. All rights reserved. +-- Copyright 2010-2019 Branimir Karadzic. All rights reserved. -- License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause -- @@ -28,43 +28,34 @@ project ("example-common") } files { - path.join(BGFX_DIR, "3rdparty/ib-compress/**.cpp"), - path.join(BGFX_DIR, "3rdparty/ib-compress/**.h"), + path.join(BGFX_DIR, "3rdparty/meshoptimizer/src/**.cpp"), + path.join(BGFX_DIR, "3rdparty/meshoptimizer/src/**.h"), path.join(BGFX_DIR, "3rdparty/dear-imgui/**.cpp"), path.join(BGFX_DIR, "3rdparty/dear-imgui/**.h"), path.join(BGFX_DIR, "examples/common/**.cpp"), - path.join(BGFX_DIR, "examples/common/**.cpp"), path.join(BGFX_DIR, "examples/common/**.h"), } - removefiles { - path.join(BGFX_DIR, "examples/common/example-glue.cpp"), - } + if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-gnm"), + { path.join(BGFX_DIR, "../bgfx-gnm/examples/common/entry/entry_orbis.cpp") }) then - if _OPTIONS["with-scintilla"] then - defines { - "SCI_NAMESPACE", - "SCI_LEXER", + files { + path.join(BGFX_DIR, "../bgfx-gnm/examples/common/entry/entry_orbis.cpp"), } + end - buildoptions { --- "-Wno-missing-field-initializers", - } - - includedirs { - path.join(BGFX_DIR, "3rdparty/scintilla/include"), - path.join(BGFX_DIR, "3rdparty/scintilla/lexlib"), - } + if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-nvn"), + { path.join(BGFX_DIR, "../bgfx-gnm/examples/common/entry/entry_nx.cpp") }) then files { - path.join(BGFX_DIR, "3rdparty/scintilla/src/**.cxx"), - path.join(BGFX_DIR, "3rdparty/scintilla/src/**.h"), - path.join(BGFX_DIR, "3rdparty/scintilla/lexlib/**.cxx"), - path.join(BGFX_DIR, "3rdparty/scintilla/lexlib/**.h"), - path.join(BGFX_DIR, "3rdparty/scintilla/lexers/**.cxx"), + path.join(BGFX_DIR, "../bgfx-gnm/examples/common/entry/entry_nx.cpp"), } end + removefiles { + path.join(BGFX_DIR, "examples/common/example-glue.cpp"), + } + if _OPTIONS["with-sdl"] then defines { "ENTRY_CONFIG_USE_SDL=1", @@ -80,6 +71,12 @@ project ("example-common") } end + if _OPTIONS["with-wayland"] then + defines { + "ENTRY_CONFIG_USE_WAYLAND=1", + } + end + configuration { "linux-steamlink" } defines { "EGL_API_FB", diff --git a/3rdparty/bgfx/scripts/genie.lua b/3rdparty/bgfx/scripts/genie.lua index 05bc713595a..516833df6dc 100644 --- a/3rdparty/bgfx/scripts/genie.lua +++ b/3rdparty/bgfx/scripts/genie.lua @@ -1,5 +1,5 @@ -- --- Copyright 2010-2018 Branimir Karadzic. All rights reserved. +-- Copyright 2010-2019 Branimir Karadzic. All rights reserved. -- License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause -- @@ -19,13 +19,13 @@ newoption { } newoption { - trigger = "with-profiler", - description = "Enable build with intrusive profiler.", + trigger = "with-wayland", + description = "Use Wayland backend.", } newoption { - trigger = "with-scintilla", - description = "Enable building with Scintilla editor.", + trigger = "with-profiler", + description = "Enable build with intrusive profiler.", } newoption { @@ -48,13 +48,40 @@ newoption { description = "Enable building examples.", } +newaction { + trigger = "idl", + description = "Generate bgfx interface source code", + execute = function () + + local gen = require "bgfx-codegen" + + local function generate(tempfile, outputfile, indent) + local codes = gen.apply(tempfile) + codes = gen.format(codes, {indent = indent}) + gen.write(codes, outputfile) + print("Generating: " .. outputfile) + end + + generate("temp.bgfx.h" , "../include/bgfx/c99/bgfx.h", " ") + generate("temp.bgfx.idl.inl", "../src/bgfx.idl.inl", "\t") + generate("temp.defines.h", "../include/bgfx/defines.h", "\t") + + do + local csgen = require "bindings-cs" + csgen.write(csgen.gen(), "../bindings/cs/bgfx.cs") + end + + os.exit() + end +} + solution "bgfx" configurations { "Debug", "Release", } - if _ACTION == "xcode4" then + if _ACTION:match "xcode*" then platforms { "Universal", } @@ -107,6 +134,10 @@ end function copyLib() end +if _OPTIONS["with-wayland"] then + defines { "WL_EGL_PLATFORM=1" } +end + if _OPTIONS["with-sdl"] then if os.is("windows") then if not os.getenv("SDL2_DIR") then @@ -139,8 +170,8 @@ function exampleProjectDefaults() } links { - "example-common", "example-glue", + "example-common", "bgfx", "bimg_decode", "bimg", @@ -151,6 +182,13 @@ function exampleProjectDefaults() defines { "ENTRY_CONFIG_USE_SDL=1" } links { "SDL2" } + configuration { "linux or freebsd" } + if _OPTIONS["with-wayland"] then + links { + "wayland-egl", + } + end + configuration { "osx" } libdirs { "$(SDL2_DIR)/lib" } @@ -162,13 +200,19 @@ function exampleProjectDefaults() links { "glfw3" } configuration { "linux or freebsd" } - links { - "Xrandr", - "Xinerama", - "Xi", - "Xxf86vm", - "Xcursor", - } + if _OPTIONS["with-wayland"] then + links { + "wayland-egl", + } + else + links { + "Xrandr", + "Xinerama", + "Xi", + "Xxf86vm", + "Xcursor", + } + end configuration { "osx" } linkoptions { @@ -305,13 +349,13 @@ function exampleProjectDefaults() "-weak_framework Metal", } - configuration { "xcode4", "ios" } + configuration { "xcode*", "ios" } kind "WindowedApp" files { path.join(BGFX_DIR, "examples/runtime/iOS-Info.plist"), } - configuration { "xcode4", "tvos" } + configuration { "xcode*", "tvos" } kind "WindowedApp" files { path.join(BGFX_DIR, "examples/runtime/tvOS-Info.plist"), @@ -448,6 +492,9 @@ or _OPTIONS["with-combined-examples"] then , "36-sky" , "37-gpudrivenrendering" , "38-bloom" + , "39-assao" + , "40-svt" + , "41-tess" ) -- C99 source doesn't compile under WinRT settings @@ -467,4 +514,5 @@ if _OPTIONS["with-tools"] then dofile "texturec.lua" dofile "texturev.lua" dofile "geometryc.lua" + dofile "geometryv.lua" end diff --git a/3rdparty/bgfx/scripts/geometryc.lua b/3rdparty/bgfx/scripts/geometryc.lua index 566afb155c0..9fdd895c856 100644 --- a/3rdparty/bgfx/scripts/geometryc.lua +++ b/3rdparty/bgfx/scripts/geometryc.lua @@ -1,5 +1,5 @@ -- --- Copyright 2010-2018 Branimir Karadzic. All rights reserved. +-- Copyright 2010-2019 Branimir Karadzic. All rights reserved. -- License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause -- @@ -15,10 +15,8 @@ project "geometryc" } files { - path.join(BGFX_DIR, "3rdparty/forsyth-too/**.cpp"), - path.join(BGFX_DIR, "3rdparty/forsyth-too/**.h"), - path.join(BGFX_DIR, "3rdparty/ib-compress/**.cpp"), - path.join(BGFX_DIR, "3rdparty/ib-compress/**.h"), + path.join(BGFX_DIR, "3rdparty/meshoptimizer/src/**.cpp"), + path.join(BGFX_DIR, "3rdparty/meshoptimizer/src/**.h"), path.join(BGFX_DIR, "src/vertexdecl.**"), path.join(BGFX_DIR, "tools/geometryc/**.cpp"), path.join(BGFX_DIR, "tools/geometryc/**.h"), diff --git a/3rdparty/bgfx/scripts/geometryv.lua b/3rdparty/bgfx/scripts/geometryv.lua new file mode 100644 index 00000000000..e852342a2c3 --- /dev/null +++ b/3rdparty/bgfx/scripts/geometryv.lua @@ -0,0 +1,172 @@ +project ("geometryv") + uuid (os.uuid("geometryv") ) + kind "ConsoleApp" + + configuration {} + + includedirs { + path.join(BX_DIR, "include"), + path.join(BIMG_DIR, "include"), + path.join(BGFX_DIR, "include"), + path.join(BGFX_DIR, "3rdparty"), + path.join(BGFX_DIR, "examples/common"), + path.join(MODULE_DIR, "include"), + path.join(MODULE_DIR, "3rdparty"), + } + + files { + path.join(MODULE_DIR, "tools/geometryv/**"), + } + + links { + "example-common", + "bimg_decode", + "bimg", + "bgfx", + "bx", + } + + if _OPTIONS["with-sdl"] then + defines { "ENTRY_CONFIG_USE_SDL=1" } + links { "SDL2" } + + configuration { "x32", "windows" } + libdirs { "$(SDL2_DIR)/lib/x86" } + + configuration { "x64", "windows" } + libdirs { "$(SDL2_DIR)/lib/x64" } + + configuration {} + end + + if _OPTIONS["with-glfw"] then + defines { "ENTRY_CONFIG_USE_GLFW=1" } + links { "glfw3" } + + configuration { "linux or freebsd" } + links { + "Xrandr", + "Xinerama", + "Xi", + "Xxf86vm", + "Xcursor", + } + + configuration { "osx" } + linkoptions { + "-framework CoreVideo", + "-framework IOKit", + } + + configuration {} + end + + configuration { "vs*" } + linkoptions { + "/ignore:4199", -- LNK4199: /DELAYLOAD:*.dll ignored; no imports found from *.dll + } + links { -- this is needed only for testing with GLES2/3 on Windows with VS2008 + "DelayImp", + } + + configuration { "vs201*" } + linkoptions { -- this is needed only for testing with GLES2/3 on Windows with VS201x + "/DELAYLOAD:\"libEGL.dll\"", + "/DELAYLOAD:\"libGLESv2.dll\"", + } + + configuration { "mingw-*" } + targetextension ".exe" + + configuration { "vs20* or mingw*" } + links { + "comdlg32", + "gdi32", + "psapi", + } + + configuration { "winstore*" } + removelinks { + "DelayImp", + "gdi32", + "psapi" + } + links { + "d3d11", + "d3d12", + "dxgi" + } + linkoptions { + "/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata + } + -- WinRT targets need their own output directories are build files stomp over each other + targetdir (path.join(BGFX_BUILD_DIR, "arm_" .. _ACTION, "bin", _name)) + objdir (path.join(BGFX_BUILD_DIR, "arm_" .. _ACTION, "obj", _name)) + + configuration { "mingw-clang" } + kind "ConsoleApp" + + configuration { "android*" } + kind "ConsoleApp" + targetextension ".so" + linkoptions { + "-shared", + } + links { + "EGL", + "GLESv2", + } + + configuration { "asmjs" } + kind "ConsoleApp" + targetextension ".bc" + + configuration { "linux-* or freebsd" } + links { + "X11", + "GL", + "pthread", + } + + configuration { "rpi" } + links { + "X11", + "GLESv2", + "EGL", + "bcm_host", + "vcos", + "vchiq_arm", + "pthread", + } + + configuration { "osx" } + linkoptions { + "-framework Cocoa", + "-framework Metal", + "-framework QuartzCore", + "-framework OpenGL", + } + + configuration { "ios*" } + kind "ConsoleApp" + linkoptions { + "-framework CoreFoundation", + "-framework Foundation", + "-framework OpenGLES", + "-framework UIKit", + "-framework QuartzCore", + } + + configuration { "xcode4", "ios" } + kind "WindowedApp" + + configuration { "qnx*" } + targetextension "" + links { + "EGL", + "GLESv2", + } + + configuration {} + + strip() diff --git a/3rdparty/bgfx/scripts/idl.lua b/3rdparty/bgfx/scripts/idl.lua new file mode 100644 index 00000000000..b5bd2ae8a87 --- /dev/null +++ b/3rdparty/bgfx/scripts/idl.lua @@ -0,0 +1,247 @@ +-- Copyright 2019 云风 https://github.com/cloudwu . All rights reserved. +-- License (the same with bgfx) : https://github.com/bkaradzic/bgfx/blob/master/LICENSE + +local idl = {} + +local comments = {} + +function idl.comment(c) + comments[#comments+1] = c +end + +local all_types = {} + +local function copy_attribs(to, from) + if type(from) == "table" then + for k, v in pairs(from) do + if type(k) == "number" then + to[v] = true + end + to[k] = v + end + else + to.value = from + end +end + +local function classdef(item, def) + local function class(_, methodname) + item.class = item.name + item.name = methodname + return def + end + + return setmetatable({} , { __index = class, __call = function(_, value) return def(value) end }) +end + +local function new_type(typename) + local t = { name = typename } + if #comments > 0 then + t.comments = comments + comments = {} + end + all_types[#all_types+1] = t + return t +end + +local function typedef(_, typename) + local t = new_type(typename) + + local function type_attrib(attrib) + copy_attribs(t, attrib) + end + return function(cname) + local typ = type(cname) + if typ == "table" then + type_attrib(cname) + return + end + assert(typ == "string" , "type should be a string") + t.cname = cname + return type_attrib + end +end + +idl.typedef = setmetatable({} , { __index = typedef, __call = typedef }) +idl.types = all_types + +local function add_comment(item, comment) + -- strip space + comment = comment:match "(.-)%s*$" + if item.comment then + table.insert(item.comment, comment) + else + item.comment = { comment } + end +end + +local function enumdef(what) + local function deffunc (_, typename) + local t = new_type(typename) + t[what] = {} + + local function enum_attrib(obj, attribs) + copy_attribs(t, attribs) + return obj + end + + local function new_enum_item(_, itemname) + local item = { name = itemname } + t[what][#t[what] + 1] = item + local function add_attrib_or_comment(obj , attribs) + if type(attribs) == "string" then + add_comment(item, attribs) + elseif attribs then + copy_attribs(item, attribs) + end + return obj + end + return setmetatable({}, { __index = new_enum_item, __call = add_attrib_or_comment }) + end + + return setmetatable({}, { __index = new_enum_item , __call = enum_attrib }) + end + + return setmetatable({} , { __index = deffunc , __call = deffunc }) +end + +idl.enum = enumdef "enum" +idl.flag = enumdef "flag" + +local function structdef(_, typename) + local t = new_type(typename) + t.struct = {} + + local function struct_attrib(obj, attribs) + copy_attribs(t, attribs) + return obj + end + + local function new_struct_item(_, itemname) + local item = { name = itemname } + t.struct[#t.struct + 1] = item + + local function item_attrib(obj, attribs) + if type(attribs) == "string" then + add_comment(item, attribs) + else + copy_attribs(item, attribs) + end + return obj + end + + return function (itemtype) + item.fulltype = itemtype + return setmetatable({}, { __index = new_struct_item, __call = item_attrib }) + end + end + + return setmetatable({}, { __index = new_struct_item , __call = struct_attrib }) +end + +idl.struct = setmetatable({}, { __index = structdef , __call = structdef }) + +local function handledef(_, typename) + local t = new_type(typename) + t.handle = true + + return function (attribs) + copy_attribs(t, attribs) + return obj + end +end + +idl.handle = setmetatable({} , { __index = handledef, __call = handledef }) + +local all_funcs = {} + +local function duplicate_arg_name(_, name) + error ("Duplicate arg name " .. name) +end + +local function attribs_setter(args, arg, args_desc) + local attribs_setter + local function arg_attrib_or_comment(_, attrib_or_comment ) + if type(attrib_or_comment) == "string" then + add_comment(arg, attrib_or_comment) + else + copy_attribs(arg, attrib_or_comment) + end + return attribs_setter + end + -- next field (__index) or attrib/comment (__call) + attribs_setter = setmetatable( {} , { + __index = function(_, name) + return args_desc(args, name) + end + , __call = arg_attrib_or_comment } ) + return attribs_setter +end + +local function func(sets) + return function (_, funcname) + local f = { name = funcname , args = {} } + if #comments > 0 then + f.comments = comments + comments = {} + end + sets[#sets+1] = f + local args + local function args_desc(_, args_name) + args[args_name] = duplicate_arg_name + return function (fulltype) + local arg = { + name = "_" .. args_name, + fulltype = fulltype, + } + f.args[#f.args+1] = arg + return attribs_setter(args, arg, args_desc) + end + end + args = setmetatable({}, { __index = args_desc }) + local function rettype(value) + assert(type(value) == "string", "Need return type") + local ret = { fulltype = value } + f.ret = ret + return attribs_setter(args, ret, args_desc) + end + + local function funcdef(value) + if type(value) == "table" then + copy_attribs(f, value) + return rettype + end + return rettype(value) + end + + return classdef(f, funcdef) + end +end + +idl.funcptr = setmetatable({}, { __index = func(all_types) }) +idl.func = setmetatable({}, { __index = func(all_funcs) }) +idl.funcs = all_funcs + +function idl.version(v) + rawset(idl, "_version", v) +end + +idl.vararg = "vararg" +idl.out = "out" +idl.inout = "inout" +idl.const = "const" +idl.ctor = "ctor" +idl.cfunc = "cfunc" +idl.underscore = "underscore" +idl.conly = "conly" +idl.cpponly = "cpponly" +idl.shortname = "shortname" +idl.NULL = "NULL" +idl.UINT16_MAX = "UINT16_MAX" +idl.INT32_MAX = "INT32_MAX" +idl.UINT32_MAX = "UINT32_MAX" +idl.UINT8_MAX = "UINT8_MAX" + +return setmetatable(idl , { __index = function (_, keyword) + error (tostring(keyword) .. " is invalid") + end}) diff --git a/3rdparty/bgfx/scripts/shader-embeded.mk b/3rdparty/bgfx/scripts/shader-embeded.mk index 1d126f88ccc..fe026c17782 100644 --- a/3rdparty/bgfx/scripts/shader-embeded.mk +++ b/3rdparty/bgfx/scripts/shader-embeded.mk @@ -1,5 +1,5 @@ # -# Copyright 2011-2018 Branimir Karadzic. All rights reserved. +# Copyright 2011-2019 Branimir Karadzic. All rights reserved. # License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause # diff --git a/3rdparty/bgfx/scripts/shader.mk b/3rdparty/bgfx/scripts/shader.mk index e8ca61d33cf..d6f04229c26 100644 --- a/3rdparty/bgfx/scripts/shader.mk +++ b/3rdparty/bgfx/scripts/shader.mk @@ -1,5 +1,5 @@ # -# Copyright 2011-2018 Branimir Karadzic. All rights reserved. +# Copyright 2011-2019 Branimir Karadzic. All rights reserved. # License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause # @@ -22,7 +22,7 @@ all: @echo " TARGET=4 (glsl)" @echo " TARGET=5 (metal)" @echo " TARGET=6 (pssl)" - @echo " TARGET=7 (spriv)" + @echo " TARGET=7 (spirv)" .PHONY: rebuild rebuild: @@ -44,8 +44,8 @@ FS_FLAGS=--platform windows -p ps_3_0 -O 3 SHADER_PATH=shaders/dx9 else ifeq ($(TARGET), 1) -VS_FLAGS=--platform windows -p vs_4_0 -O 3 -FS_FLAGS=--platform windows -p ps_4_0 -O 3 +VS_FLAGS=--platform windows -p vs_5_0 -O 3 +FS_FLAGS=--platform windows -p ps_5_0 -O 3 CS_FLAGS=--platform windows -p cs_5_0 -O 1 SHADER_PATH=shaders/dx11 else @@ -116,22 +116,22 @@ CS_BIN = $(addprefix $(BUILD_INTERMEDIATE_DIR)/, $(addsuffix .bin, $(basename $( BIN = $(VS_BIN) $(FS_BIN) ASM = $(VS_ASM) $(FS_ASM) -ifeq ($(TARGET), $(filter $(TARGET),1 3 4 6)) +ifeq ($(TARGET), $(filter $(TARGET),1 3 4 5 6 7)) BIN += $(CS_BIN) ASM += $(CS_ASM) endif -$(BUILD_INTERMEDIATE_DIR)/vs_%.bin : $(SHADERS_DIR)vs_%.sc +$(BUILD_INTERMEDIATE_DIR)/vs_%.bin: $(SHADERS_DIR)vs_%.sc @echo [$(<)] $(SILENT) $(SHADERC) $(VS_FLAGS) --type vertex --depends -o $(@) -f $(<) --disasm $(SILENT) cp $(@) $(BUILD_OUTPUT_DIR)/$(@F) -$(BUILD_INTERMEDIATE_DIR)/fs_%.bin : $(SHADERS_DIR)fs_%.sc +$(BUILD_INTERMEDIATE_DIR)/fs_%.bin: $(SHADERS_DIR)fs_%.sc @echo [$(<)] $(SILENT) $(SHADERC) $(FS_FLAGS) --type fragment --depends -o $(@) -f $(<) --disasm $(SILENT) cp $(@) $(BUILD_OUTPUT_DIR)/$(@F) -$(BUILD_INTERMEDIATE_DIR)/cs_%.bin : $(SHADERS_DIR)cs_%.sc +$(BUILD_INTERMEDIATE_DIR)/cs_%.bin: $(SHADERS_DIR)cs_%.sc @echo [$(<)] $(SILENT) $(SHADERC) $(CS_FLAGS) --type compute --depends -o $(@) -f $(<) --disasm $(SILENT) cp $(@) $(BUILD_OUTPUT_DIR)/$(@F) @@ -158,6 +158,8 @@ dirs: .PHONY: rebuild rebuild: clean all +$(BIN) : | $(BUILD_INTERMEDIATE_DIR) + endif # TARGET -include $(VS_DEPS) diff --git a/3rdparty/bgfx/scripts/shaderc.lua b/3rdparty/bgfx/scripts/shaderc.lua index fd5209d66c8..95a46263470 100644 --- a/3rdparty/bgfx/scripts/shaderc.lua +++ b/3rdparty/bgfx/scripts/shaderc.lua @@ -1,29 +1,34 @@ -- --- Copyright 2010-2018 Branimir Karadzic. All rights reserved. +-- Copyright 2010-2019 Branimir Karadzic. All rights reserved. -- License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause -- group "tools/shaderc" local GLSL_OPTIMIZER = path.join(BGFX_DIR, "3rdparty/glsl-optimizer") -local FCPP_DIR = path.join(BGFX_DIR, "3rdparty/fcpp") -local GLSLANG = path.join(BGFX_DIR, "3rdparty/glslang") -local SPIRV_TOOLS = path.join(BGFX_DIR, "3rdparty/spirv-tools") +local FCPP_DIR = path.join(BGFX_DIR, "3rdparty/fcpp") +local GLSLANG = path.join(BGFX_DIR, "3rdparty/glslang") +local SPIRV_CROSS = path.join(BGFX_DIR, "3rdparty/spirv-cross") +local SPIRV_HEADERS = path.join(BGFX_DIR, "3rdparty/spirv-headers") +local SPIRV_TOOLS = path.join(BGFX_DIR, "3rdparty/spirv-tools") project "spirv-opt" kind "StaticLib" includedirs { + SPIRV_TOOLS, + path.join(SPIRV_TOOLS, "include"), path.join(SPIRV_TOOLS, "include/generated"), path.join(SPIRV_TOOLS, "source"), - path.join(SPIRV_TOOLS), - path.join(SPIRV_TOOLS, "external/SPIRV-Headers/include"), + path.join(SPIRV_HEADERS, "include"), } files { path.join(SPIRV_TOOLS, "source/opt/**.cpp"), path.join(SPIRV_TOOLS, "source/opt/**.h"), + path.join(SPIRV_TOOLS, "source/reduce/**.cpp"), + path.join(SPIRV_TOOLS, "source/reduce/**.h"), -- libspirv path.join(SPIRV_TOOLS, "source/assembly_grammar.cpp"), @@ -42,8 +47,6 @@ project "spirv-opt" path.join(SPIRV_TOOLS, "source/ext_inst.h"), path.join(SPIRV_TOOLS, "source/extensions.cpp"), path.join(SPIRV_TOOLS, "source/extensions.h"), - path.join(SPIRV_TOOLS, "source/id_descriptor.cpp"), - path.join(SPIRV_TOOLS, "source/id_descriptor.h"), path.join(SPIRV_TOOLS, "source/instruction.h"), path.join(SPIRV_TOOLS, "source/latest_version_glsl_std_450_header.h"), path.join(SPIRV_TOOLS, "source/latest_version_opencl_std_header.h"), @@ -65,6 +68,8 @@ project "spirv-opt" path.join(SPIRV_TOOLS, "source/spirv_definition.h"), path.join(SPIRV_TOOLS, "source/spirv_endian.cpp"), path.join(SPIRV_TOOLS, "source/spirv_endian.h"), + path.join(SPIRV_TOOLS, "source/spirv_optimizer_options.cpp"), + path.join(SPIRV_TOOLS, "source/spirv_reducer_options.cpp"), path.join(SPIRV_TOOLS, "source/spirv_target_env.cpp"), path.join(SPIRV_TOOLS, "source/spirv_target_env.h"), path.join(SPIRV_TOOLS, "source/spirv_validator_options.cpp"), @@ -89,6 +94,8 @@ project "spirv-opt" path.join(SPIRV_TOOLS, "source/val/decoration.h"), path.join(SPIRV_TOOLS, "source/val/function.cpp"), path.join(SPIRV_TOOLS, "source/val/instruction.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate.h"), path.join(SPIRV_TOOLS, "source/val/validate_adjacency.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_annotation.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_arithmetics.cpp"), @@ -101,27 +108,28 @@ project "spirv-opt" path.join(SPIRV_TOOLS, "source/val/validate_composites.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_constants.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_conversion.cpp"), - path.join(SPIRV_TOOLS, "source/val/validate_datarules.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_debug.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_decorations.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_derivatives.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_execution_limitations.cpp"), - path.join(SPIRV_TOOLS, "source/val/validate_ext_inst.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate_extensions.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_function.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_id.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_image.cpp"), - path.join(SPIRV_TOOLS, "source/val/validate_interfaces.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_instruction.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate_interfaces.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_layout.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_literals.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_logicals.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_memory.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate_memory_semantics.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate_misc.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_mode_setting.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_non_uniform.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_primitives.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate_scopes.cpp"), + path.join(SPIRV_TOOLS, "source/val/validate_small_type_uses.cpp"), path.join(SPIRV_TOOLS, "source/val/validate_type.cpp"), - path.join(SPIRV_TOOLS, "source/val/validate.cpp"), - path.join(SPIRV_TOOLS, "source/val/validate.h"), path.join(SPIRV_TOOLS, "source/val/validation_state.cpp"), } @@ -133,6 +141,64 @@ project "spirv-opt" "/wd4706", -- warning C4706: assignment within conditional expression } + configuration { "mingw* or linux or osx" } + buildoptions { + "-Wno-switch", + } + + configuration { "mingw* or linux-gcc-*" } + buildoptions { + "-Wno-misleading-indentation", + } + + configuration {} + +project "spirv-cross" + kind "StaticLib" + + defines { + "SPIRV_CROSS_EXCEPTIONS_TO_ASSERTIONS", + } + + includedirs { + path.join(SPIRV_CROSS, "include"), + } + + files { + path.join(SPIRV_CROSS, "spirv.hpp"), + path.join(SPIRV_CROSS, "spirv_cfg.cpp"), + path.join(SPIRV_CROSS, "spirv_cfg.hpp"), + path.join(SPIRV_CROSS, "spirv_common.hpp"), + path.join(SPIRV_CROSS, "spirv_cpp.cpp"), + path.join(SPIRV_CROSS, "spirv_cpp.hpp"), + path.join(SPIRV_CROSS, "spirv_cross.cpp"), + path.join(SPIRV_CROSS, "spirv_cross.hpp"), + path.join(SPIRV_CROSS, "spirv_cross_parsed_ir.cpp"), + path.join(SPIRV_CROSS, "spirv_cross_parsed_ir.hpp"), + path.join(SPIRV_CROSS, "spirv_cross_util.cpp"), + path.join(SPIRV_CROSS, "spirv_cross_util.hpp"), + path.join(SPIRV_CROSS, "spirv_glsl.cpp"), + path.join(SPIRV_CROSS, "spirv_glsl.hpp"), + path.join(SPIRV_CROSS, "spirv_hlsl.cpp"), + path.join(SPIRV_CROSS, "spirv_hlsl.hpp"), + path.join(SPIRV_CROSS, "spirv_msl.cpp"), + path.join(SPIRV_CROSS, "spirv_msl.hpp"), + path.join(SPIRV_CROSS, "spirv_parser.cpp"), + path.join(SPIRV_CROSS, "spirv_parser.hpp"), + path.join(SPIRV_CROSS, "spirv_reflect.cpp"), + path.join(SPIRV_CROSS, "spirv_reflect.hpp"), + } + + configuration { "vs*" } + buildoptions { + "/wd4018", -- warning C4018: '<': signed/unsigned mismatch + "/wd4245", -- warning C4245: 'return': conversion from 'int' to 'unsigned int', signed/unsigned mismatch + "/wd4706", -- warning C4706: assignment within conditional expression + "/wd4715", -- warning C4715: '': not all control paths return a value + } + + configuration {} + project "glslang" kind "StaticLib" @@ -244,14 +310,168 @@ project "glsl-optimizer" } files { - path.join(GLSL_OPTIMIZER, "src/mesa/**.c"), - path.join(GLSL_OPTIMIZER, "src/glsl/**.cpp"), - path.join(GLSL_OPTIMIZER, "src/mesa/**.h"), - path.join(GLSL_OPTIMIZER, "src/glsl/**.c"), - path.join(GLSL_OPTIMIZER, "src/glsl/**.cpp"), - path.join(GLSL_OPTIMIZER, "src/glsl/**.h"), - path.join(GLSL_OPTIMIZER, "src/util/**.c"), - path.join(GLSL_OPTIMIZER, "src/util/**.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/glcpp/glcpp.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/glcpp/glcpp-lex.c"), + path.join(GLSL_OPTIMIZER, "src/glsl/glcpp/glcpp-parse.c"), + path.join(GLSL_OPTIMIZER, "src/glsl/glcpp/glcpp-parse.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/glcpp/pp.c"), + + path.join(GLSL_OPTIMIZER, "src/glsl/ast.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ast_array_index.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ast_expr.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ast_function.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ast_to_hir.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ast_type.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/builtin_functions.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/builtin_type_macros.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/builtin_types.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/builtin_variables.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_lexer.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_optimizer.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_optimizer.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_parser.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_parser.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_parser_extras.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_parser_extras.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_symbol_table.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_symbol_table.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_types.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/glsl_types.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/hir_field_selection.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_basic_block.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_basic_block.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_builder.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_builder.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_clone.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_constant_expression.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_equals.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_expression_flattening.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_expression_flattening.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_function.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_function_can_inline.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_function_detect_recursion.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_function_inlining.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_hierarchical_visitor.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_hierarchical_visitor.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_hv_accept.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_import_prototypes.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_optimization.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_print_glsl_visitor.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_print_glsl_visitor.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_print_metal_visitor.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_print_metal_visitor.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_print_visitor.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_print_visitor.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_rvalue_visitor.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_rvalue_visitor.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_stats.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_stats.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_uniform.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_unused_structs.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_unused_structs.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_validate.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_variable_refcount.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_variable_refcount.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/ir_visitor.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_atomics.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_functions.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_interface_blocks.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_uniform_block_active_visitor.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_uniform_block_active_visitor.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_uniform_blocks.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_uniform_initializers.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_uniforms.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_varyings.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/link_varyings.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/linker.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/linker.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/list.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/loop_analysis.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/loop_analysis.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/loop_controls.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/loop_unroll.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_clip_distance.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_discard.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_discard_flow.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_if_to_cond_assign.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_instructions.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_jumps.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_mat_op_to_vec.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_named_interface_blocks.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_noise.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_offset_array.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_output_reads.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_packed_varyings.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_packing_builtins.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_ubo_reference.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_variable_index_to_cond_assign.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_vec_index_to_cond_assign.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_vec_index_to_swizzle.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_vector.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_vector_insert.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/lower_vertex_id.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_algebraic.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_array_splitting.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_constant_folding.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_constant_propagation.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_constant_variable.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_copy_propagation.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_copy_propagation_elements.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_cse.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_dead_builtin_variables.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_dead_builtin_varyings.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_dead_code.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_dead_code_local.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_dead_functions.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_flatten_nested_if_blocks.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_flip_matrices.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_function_inlining.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_if_simplification.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_minmax.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_noop_swizzle.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_rebalance_tree.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_redundant_jumps.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_structure_splitting.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_swizzle_swizzle.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_tree_grafting.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/opt_vectorize.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/program.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/s_expression.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/s_expression.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/standalone_scaffolding.cpp"), + path.join(GLSL_OPTIMIZER, "src/glsl/standalone_scaffolding.h"), + path.join(GLSL_OPTIMIZER, "src/glsl/strtod.c"), + path.join(GLSL_OPTIMIZER, "src/glsl/strtod.h"), + + path.join(GLSL_OPTIMIZER, "src/mesa/main/compiler.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/config.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/context.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/core.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/dd.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/errors.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/glheader.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/glminimal.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/imports.c"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/imports.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/macros.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/mtypes.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/main/simple_list.h"), + + path.join(GLSL_OPTIMIZER, "src/mesa/program/hash_table.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/program/prog_hash_table.c"), + path.join(GLSL_OPTIMIZER, "src/mesa/program/prog_instruction.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/program/prog_parameter.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/program/prog_statevars.h"), + path.join(GLSL_OPTIMIZER, "src/mesa/program/symbol_table.c"), + path.join(GLSL_OPTIMIZER, "src/mesa/program/symbol_table.h"), + + path.join(GLSL_OPTIMIZER, "src/util/hash_table.c"), + path.join(GLSL_OPTIMIZER, "src/util/hash_table.h"), + path.join(GLSL_OPTIMIZER, "src/util/macros.h"), + path.join(GLSL_OPTIMIZER, "src/util/ralloc.c"), + path.join(GLSL_OPTIMIZER, "src/util/ralloc.h"), } removefiles { @@ -307,6 +527,7 @@ project "glsl-optimizer" "-fno-strict-aliasing", -- glsl-optimizer has bugs if strict aliasing is used. "-Wno-implicit-fallthrough", + "-Wno-parentheses", "-Wno-sign-compare", "-Wno-unused-function", "-Wno-unused-parameter", @@ -362,6 +583,7 @@ project "fcpp" configuration { "not vs*" } buildoptions { "-Wno-implicit-fallthrough", + "-Wno-incompatible-pointer-types", "-Wno-parentheses-equality", } @@ -376,6 +598,7 @@ project "shaderc" path.join(BGFX_DIR, "include"), path.join(BGFX_DIR, "3rdparty/dxsdk/include"), + FCPP_DIR, path.join(BGFX_DIR, "3rdparty/glslang/glslang/Public"), @@ -384,6 +607,10 @@ project "shaderc" path.join(GLSL_OPTIMIZER, "include"), path.join(GLSL_OPTIMIZER, "src/glsl"), + + SPIRV_CROSS, + + path.join(SPIRV_TOOLS, "include"), } links { @@ -392,6 +619,7 @@ project "shaderc" "glslang", "glsl-optimizer", "spirv-opt", + "spirv-cross", } files { @@ -419,12 +647,17 @@ project "shaderc" "psapi", } + configuration { "osx or linux*" } + links { + "pthread", + } + configuration {} - if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-ext"), { + if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-gnm"), { path.join(BGFX_DIR, "scripts/shaderc.lua"), }) then - if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-ext"), { + if filesexist(BGFX_DIR, path.join(BGFX_DIR, "../bgfx-gnm"), { path.join(BGFX_DIR, "tools/shaderc/shaderc_pssl.cpp"), }) then removefiles { @@ -432,16 +665,9 @@ project "shaderc" } end - dofile(path.join(BGFX_DIR, "../bgfx-ext/scripts/shaderc.lua") ) + dofile(path.join(BGFX_DIR, "../bgfx-gnm/scripts/shaderc.lua") ) end - configuration { "osx or linux*" } - links { - "pthread", - } - - configuration {} - strip() group "tools" diff --git a/3rdparty/bgfx/scripts/temp.bgfx.h b/3rdparty/bgfx/scripts/temp.bgfx.h new file mode 100644 index 00000000000..e1dde4ccf6b --- /dev/null +++ b/3rdparty/bgfx/scripts/temp.bgfx.h @@ -0,0 +1,138 @@ +/* + * Copyright 2011-2019 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE + * + * vim: set tabstop=4 expandtab: + */ + +/* + * + * AUTO GENERATED! DO NOT EDIT! ( source : $source ) + * + */ + +#ifndef BGFX_C99_H_HEADER_GUARD +#define BGFX_C99_H_HEADER_GUARD + +#include <stdarg.h> // va_list +#include <stdbool.h> // bool +#include <stdint.h> // uint32_t +#include <stdlib.h> // size_t + +#include <bx/platform.h> + +#if !defined(BGFX_INVALID_HANDLE) +# define BGFX_INVALID_HANDLE { UINT16_MAX } +#endif // !defined(BGFX_INVALID_HANDLE) + +#ifndef BGFX_SHARED_LIB_BUILD +# define BGFX_SHARED_LIB_BUILD 0 +#endif // BGFX_SHARED_LIB_BUILD + +#ifndef BGFX_SHARED_LIB_USE +# define BGFX_SHARED_LIB_USE 0 +#endif // BGFX_SHARED_LIB_USE + +#if BX_PLATFORM_WINDOWS +# define BGFX_SYMBOL_EXPORT __declspec(dllexport) +# define BGFX_SYMBOL_IMPORT __declspec(dllimport) +#else +# define BGFX_SYMBOL_EXPORT __attribute__((visibility("default"))) +# define BGFX_SYMBOL_IMPORT +#endif // BX_PLATFORM_WINDOWS + +#if BGFX_SHARED_LIB_BUILD +# define BGFX_SHARED_LIB_API BGFX_SYMBOL_EXPORT +#elif BGFX_SHARED_LIB_USE +# define BGFX_SHARED_LIB_API BGFX_SYMBOL_IMPORT +#else +# define BGFX_SHARED_LIB_API +#endif // BGFX_SHARED_LIB_* + +#if defined(__cplusplus) +# define BGFX_C_API extern "C" BGFX_SHARED_LIB_API +#else +# define BGFX_C_API BGFX_SHARED_LIB_API +#endif // defined(__cplusplus) + +#include "../defines.h" + +$cenums + +/**/ +typedef uint16_t bgfx_view_id_t; + +/**/ +typedef struct bgfx_allocator_interface_s +{ + const struct bgfx_allocator_vtbl_s* vtbl; + +} bgfx_allocator_interface_t; + +/**/ +typedef struct bgfx_allocator_vtbl_s +{ + void* (*realloc)(bgfx_allocator_interface_t* _this, void* _ptr, size_t _size, size_t _align, const char* _file, uint32_t _line); + +} bgfx_allocator_vtbl_t; + +/**/ +typedef struct bgfx_interface_vtbl bgfx_interface_vtbl_t; + +/**/ +typedef struct bgfx_callback_interface_s +{ + const struct bgfx_callback_vtbl_s* vtbl; + +} bgfx_callback_interface_t; + +/**/ +typedef struct bgfx_callback_vtbl_s +{ + void (*fatal)(bgfx_callback_interface_t* _this, const char* _filePath, uint16_t _line, bgfx_fatal_t _code, const char* _str); + void (*trace_vargs)(bgfx_callback_interface_t* _this, const char* _filePath, uint16_t _line, const char* _format, va_list _argList); + void (*profiler_begin)(bgfx_callback_interface_t* _this, const char* _name, uint32_t _abgr, const char* _filePath, uint16_t _line); + void (*profiler_begin_literal)(bgfx_callback_interface_t* _this, const char* _name, uint32_t _abgr, const char* _filePath, uint16_t _line); + void (*profiler_end)(bgfx_callback_interface_t* _this); + uint32_t (*cache_read_size)(bgfx_callback_interface_t* _this, uint64_t _id); + bool (*cache_read)(bgfx_callback_interface_t* _this, uint64_t _id, void* _data, uint32_t _size); + void (*cache_write)(bgfx_callback_interface_t* _this, uint64_t _id, const void* _data, uint32_t _size); + void (*screen_shot)(bgfx_callback_interface_t* _this, const char* _filePath, uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _data, uint32_t _size, bool _yflip); + void (*capture_begin)(bgfx_callback_interface_t* _this, uint32_t _width, uint32_t _height, uint32_t _pitch, bgfx_texture_format_t _format, bool _yflip); + void (*capture_end)(bgfx_callback_interface_t* _this); + void (*capture_frame)(bgfx_callback_interface_t* _this, const void* _data, uint32_t _size); + +} bgfx_callback_vtbl_t; + +$chandles + +#define BGFX_HANDLE_IS_VALID(h) ((h).idx != UINT16_MAX) + +$cfuncptrs + +$cstructs + +$c99decl + +/**/ +typedef enum bgfx_function_id +{ + $c99_functionid + + BGFX_FUNCTION_ID_COUNT + +} bgfx_function_id_t; + +/**/ +struct bgfx_interface_vtbl +{ + $interface_struct +}; + +/**/ +typedef bgfx_interface_vtbl_t* (*PFN_BGFX_GET_INTERFACE)(uint32_t _version); + +/**/ +BGFX_C_API bgfx_interface_vtbl_t* bgfx_get_interface(uint32_t _version); + +#endif // BGFX_C99_H_HEADER_GUARD diff --git a/3rdparty/bgfx/scripts/temp.bgfx.idl.inl b/3rdparty/bgfx/scripts/temp.bgfx.idl.inl new file mode 100644 index 00000000000..63e180c2748 --- /dev/null +++ b/3rdparty/bgfx/scripts/temp.bgfx.idl.inl @@ -0,0 +1,97 @@ +/* + * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause + */ + +/* + * + * AUTO GENERATED! DO NOT EDIT! + * + */ + +#define BGFX_C99_ENUM_CHECK(_enum, _c99enumcount) \ + BX_STATIC_ASSERT(_enum::Count == _enum::Enum(_c99enumcount) ) + +BGFX_C99_ENUM_CHECK(bgfx::Fatal, BGFX_FATAL_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::RendererType, BGFX_RENDERER_TYPE_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::Attrib, BGFX_ATTRIB_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::AttribType, BGFX_ATTRIB_TYPE_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::TextureFormat, BGFX_TEXTURE_FORMAT_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::UniformType, BGFX_UNIFORM_TYPE_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::BackbufferRatio, BGFX_BACKBUFFER_RATIO_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::OcclusionQueryResult, BGFX_OCCLUSION_QUERY_RESULT_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::Topology, BGFX_TOPOLOGY_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::TopologyConvert, BGFX_TOPOLOGY_CONVERT_COUNT); +BGFX_C99_ENUM_CHECK(bgfx::RenderFrame, BGFX_RENDER_FRAME_COUNT); + +#undef BGFX_C99_ENUM_CHECK + +#define BGFX_C99_STRUCT_SIZE_CHECK(_cppstruct, _c99struct) \ + BX_STATIC_ASSERT(sizeof(_cppstruct) == sizeof(_c99struct) ) + +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Memory, bgfx_memory_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Transform, bgfx_transform_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Stats, bgfx_stats_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::VertexLayout, bgfx_vertex_layout_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::TransientIndexBuffer, bgfx_transient_index_buffer_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::TransientVertexBuffer, bgfx_transient_vertex_buffer_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::InstanceDataBuffer, bgfx_instance_data_buffer_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::TextureInfo, bgfx_texture_info_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::UniformInfo, bgfx_uniform_info_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Attachment, bgfx_attachment_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Caps::GPU, bgfx_caps_gpu_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Caps::Limits, bgfx_caps_limits_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::Caps, bgfx_caps_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::PlatformData, bgfx_platform_data_t); +BGFX_C99_STRUCT_SIZE_CHECK(bgfx::InternalData, bgfx_internal_data_t); + +#undef BGFX_C99_STRUCT_SIZE_CHECK + +$c99 + +/* user define functions */ +BGFX_C_API void bgfx_init_ctor(bgfx_init_t* _init) +{ + BX_PLACEMENT_NEW(_init, bgfx::Init); + +} + +BGFX_C_API bool bgfx_init(const bgfx_init_t * _init) +{ + bgfx_init_t init =*_init; + + if (init.callback != NULL) + { + static bgfx::CallbackC99 s_callback; + s_callback.m_interface = init.callback; + init.callback = reinterpret_cast<bgfx_callback_interface_t*>(&s_callback); + } + + if (init.allocator != NULL) + { + static bgfx::AllocatorC99 s_allocator; + s_allocator.m_interface = init.allocator; + init.allocator = reinterpret_cast<bgfx_allocator_interface_t*>(&s_allocator); + } + + union { const bgfx_init_t* c; const bgfx::Init* cpp; } in; + in.c = &init; + + return bgfx::init(*in.cpp); + +} + +/**/ +BGFX_C_API bgfx_interface_vtbl_t* bgfx_get_interface(uint32_t _version) +{ + if (_version == BGFX_API_VERSION) + { + static bgfx_interface_vtbl_t s_bgfx_interface = + { + $interface_import + }; + + return &s_bgfx_interface; + } + + return NULL; +} diff --git a/3rdparty/bgfx/scripts/temp.defines.h b/3rdparty/bgfx/scripts/temp.defines.h new file mode 100644 index 00000000000..4437bfa7894 --- /dev/null +++ b/3rdparty/bgfx/scripts/temp.defines.h @@ -0,0 +1,94 @@ +/* + * Copyright 2011-2019 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause + */ + +#ifndef BGFX_DEFINES_H_HEADER_GUARD +#define BGFX_DEFINES_H_HEADER_GUARD + +$version + +$cflags + +/// Blend function separate. +#define BGFX_STATE_BLEND_FUNC_SEPARATE(_srcRGB, _dstRGB, _srcA, _dstA) (UINT64_C(0) \ + | ( ( (uint64_t)(_srcRGB)|( (uint64_t)(_dstRGB)<<4) ) ) \ + | ( ( (uint64_t)(_srcA )|( (uint64_t)(_dstA )<<4) )<<8) \ + ) + +/// Blend equation separate. +#define BGFX_STATE_BLEND_EQUATION_SEPARATE(_equationRGB, _equationA) ( (uint64_t)(_equationRGB)|( (uint64_t)(_equationA)<<3) ) + +/// Blend function. +#define BGFX_STATE_BLEND_FUNC(_src, _dst) BGFX_STATE_BLEND_FUNC_SEPARATE(_src, _dst, _src, _dst) + +/// Blend equation. +#define BGFX_STATE_BLEND_EQUATION(_equation) BGFX_STATE_BLEND_EQUATION_SEPARATE(_equation, _equation) + +/// Utility predefined blend modes. + +/// Additive blending. +#define BGFX_STATE_BLEND_ADD (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE) \ + ) + +/// Alpha blend. +#define BGFX_STATE_BLEND_ALPHA (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA) \ + ) + +/// Selects darker color of blend. +#define BGFX_STATE_BLEND_DARKEN (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE) \ + | BGFX_STATE_BLEND_EQUATION(BGFX_STATE_BLEND_EQUATION_MIN) \ + ) + +/// Selects lighter color of blend. +#define BGFX_STATE_BLEND_LIGHTEN (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_ONE) \ + | BGFX_STATE_BLEND_EQUATION(BGFX_STATE_BLEND_EQUATION_MAX) \ + ) + +/// Multiplies colors. +#define BGFX_STATE_BLEND_MULTIPLY (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_DST_COLOR, BGFX_STATE_BLEND_ZERO) \ + ) + +/// Opaque pixels will cover the pixels directly below them without any math or algorithm applied to them. +#define BGFX_STATE_BLEND_NORMAL (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_INV_SRC_ALPHA) \ + ) + +/// Multiplies the inverse of the blend and base colors. +#define BGFX_STATE_BLEND_SCREEN (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_ONE, BGFX_STATE_BLEND_INV_SRC_COLOR) \ + ) + +/// Decreases the brightness of the base color based on the value of the blend color. +#define BGFX_STATE_BLEND_LINEAR_BURN (0 \ + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_DST_COLOR, BGFX_STATE_BLEND_INV_DST_COLOR) \ + | BGFX_STATE_BLEND_EQUATION(BGFX_STATE_BLEND_EQUATION_SUB) \ + ) + +/// +#define BGFX_STATE_BLEND_FUNC_RT_x(_src, _dst) (0 \ + | ( (uint32_t)( (_src)>>BGFX_STATE_BLEND_SHIFT) \ + | ( (uint32_t)( (_dst)>>BGFX_STATE_BLEND_SHIFT)<<4) ) \ + ) + +/// +#define BGFX_STATE_BLEND_FUNC_RT_xE(_src, _dst, _equation) (0 \ + | BGFX_STATE_BLEND_FUNC_RT_x(_src, _dst) \ + | ( (uint32_t)( (_equation)>>BGFX_STATE_BLEND_EQUATION_SHIFT)<<8) \ + ) + +#define BGFX_STATE_BLEND_FUNC_RT_1(_src, _dst) (BGFX_STATE_BLEND_FUNC_RT_x(_src, _dst)<< 0) +#define BGFX_STATE_BLEND_FUNC_RT_2(_src, _dst) (BGFX_STATE_BLEND_FUNC_RT_x(_src, _dst)<<11) +#define BGFX_STATE_BLEND_FUNC_RT_3(_src, _dst) (BGFX_STATE_BLEND_FUNC_RT_x(_src, _dst)<<22) + +#define BGFX_STATE_BLEND_FUNC_RT_1E(_src, _dst, _equation) (BGFX_STATE_BLEND_FUNC_RT_xE(_src, _dst, _equation)<< 0) +#define BGFX_STATE_BLEND_FUNC_RT_2E(_src, _dst, _equation) (BGFX_STATE_BLEND_FUNC_RT_xE(_src, _dst, _equation)<<11) +#define BGFX_STATE_BLEND_FUNC_RT_3E(_src, _dst, _equation) (BGFX_STATE_BLEND_FUNC_RT_xE(_src, _dst, _equation)<<22) + + +#endif // BGFX_DEFINES_H_HEADER_GUARD diff --git a/3rdparty/bgfx/scripts/texturec.lua b/3rdparty/bgfx/scripts/texturec.lua index c1c0e7da12f..69a58567778 100644 --- a/3rdparty/bgfx/scripts/texturec.lua +++ b/3rdparty/bgfx/scripts/texturec.lua @@ -1,5 +1,5 @@ -- --- Copyright 2010-2018 Branimir Karadzic. All rights reserved. +-- Copyright 2010-2019 Branimir Karadzic. All rights reserved. -- License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause -- diff --git a/3rdparty/bgfx/scripts/texturev.lua b/3rdparty/bgfx/scripts/texturev.lua index 8d17034c664..f6e93d8ba06 100644 --- a/3rdparty/bgfx/scripts/texturev.lua +++ b/3rdparty/bgfx/scripts/texturev.lua @@ -80,6 +80,7 @@ project ("texturev") configuration { "vs20* or mingw*" } links { + "comdlg32", "gdi32", "psapi", } @@ -116,24 +117,6 @@ project ("texturev") "GLESv2", } - configuration { "nacl*" } - kind "ConsoleApp" - targetextension ".nexe" - links { - "ppapi", - "ppapi_gles2", - "pthread", - } - - configuration { "pnacl" } - kind "ConsoleApp" - targetextension ".pexe" - links { - "ppapi", - "ppapi_gles2", - "pthread", - } - configuration { "asmjs" } kind "ConsoleApp" targetextension ".bc" @@ -174,7 +157,7 @@ project ("texturev") "-framework QuartzCore", } - configuration { "xcode4", "ios" } + configuration { "xcode*", "ios" } kind "WindowedApp" configuration { "qnx*" } diff --git a/3rdparty/bgfx/scripts/tools.mk b/3rdparty/bgfx/scripts/tools.mk index 2b034bcca30..d3ec6784b03 100644 --- a/3rdparty/bgfx/scripts/tools.mk +++ b/3rdparty/bgfx/scripts/tools.mk @@ -1,5 +1,5 @@ # -# Copyright 2011-2018 Branimir Karadzic. All rights reserved. +# Copyright 2011-2019 Branimir Karadzic. All rights reserved. # License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause # @@ -17,8 +17,8 @@ else OS=linux endif else -CMD_MKDIR=cmd /C "if not exist "$(subst /,\,$(1))" mkdir "$(subst /,\,$(1))"" -CMD_RMDIR=cmd /C "if exist "$(subst /,\,$(1))" rmdir /S /Q "$(subst /,\,$(1))"" +CMD_MKDIR=cmd //C "if not exist "$(subst /,\,$(1))" mkdir "$(subst /,\,$(1))"" +CMD_RMDIR=cmd //C "if exist "$(subst /,\,$(1))" rmdir /S /Q "$(subst /,\,$(1))"" OS=windows endif |