summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/scripts/bindings-zig.lua
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/scripts/bindings-zig.lua')
-rw-r--r--3rdparty/bgfx/scripts/bindings-zig.lua491
1 files changed, 491 insertions, 0 deletions
diff --git a/3rdparty/bgfx/scripts/bindings-zig.lua b/3rdparty/bgfx/scripts/bindings-zig.lua
new file mode 100644
index 00000000000..ad385ecd3a3
--- /dev/null
+++ b/3rdparty/bgfx/scripts/bindings-zig.lua
@@ -0,0 +1,491 @@
+local codegen = require "codegen"
+local idl = codegen.idl "bgfx.idl"
+
+local zig_template = [[
+// Copyright 2011-2022 Branimir Karadzic. All rights reserved.
+// License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
+
+
+//
+// AUTO GENERATED! DO NOT EDIT!
+//
+
+
+const std = @import("std");
+
+pub const ViewId = u16;
+
+$types
+
+$funcs
+
+]]
+
+local function isempty(s)
+ return s == nil or s == ''
+end
+
+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 enum = {}
+
+local function convert_array(member)
+ if string.find(member.array, "::") then
+ return string.format("[%s]", enum[member.array])
+ else
+ return member.array
+ end
+end
+
+local function gisub(s, pat, repl, n)
+ pat = string.gsub(pat, '(%a)', function(v)
+ return '[' .. string.upper(v) .. string.lower(v) .. ']'
+ end)
+ if n then
+ return string.gsub(s, pat, repl, n)
+ else
+ return string.gsub(s, pat, repl)
+ end
+end
+
+local function convert_type_0(arg)
+ if hasPrefix(arg.ctype, "uint64_t") then
+ return arg.ctype:gsub("uint64_t", "u64")
+ elseif hasPrefix(arg.ctype, "int64_t") then
+ return arg.ctype:gsub("int64_t", "i64")
+ elseif hasPrefix(arg.ctype, "uint32_t") then
+ return arg.ctype:gsub("uint32_t", "u32")
+ elseif hasPrefix(arg.ctype, "int32_t") then
+ return arg.ctype:gsub("int32_t", "i32")
+ elseif hasPrefix(arg.ctype, "uint16_t") then
+ return arg.ctype:gsub("uint16_t", "u16")
+ elseif hasPrefix(arg.ctype, "uint8_t") then
+ return arg.ctype:gsub("uint8_t", "u8")
+ elseif hasPrefix(arg.ctype, "uintptr_t") then
+ return arg.ctype:gsub("uintptr_t", "usize")
+ elseif hasPrefix(arg.ctype, "float") then
+ return arg.ctype:gsub("float", "f32")
+ elseif arg.ctype == "const char*" then
+ return "[*c]const u8"
+ elseif hasPrefix(arg.ctype, "char") then
+ return arg.ctype:gsub("char", "u8")
+ elseif hasSuffix(arg.fulltype, "Handle") then
+ return arg.fulltype
+ elseif arg.ctype == "..." then
+ return "..."
+ elseif arg.ctype == "va_list" or arg.fulltype == "bx::AllocatorI*" or arg.fulltype == "CallbackI*" or arg.fulltype ==
+ "ReleaseFn" then
+ return "?*anyopaque"
+ end
+
+ return arg.fulltype
+end
+
+local function convert_type(arg)
+ local ctype = convert_type_0(arg)
+ ctype = ctype:gsub("::Enum", "")
+ ctype = ctype:gsub(" &", "*")
+ ctype = ctype:gsub("&", "*")
+ ctype = ctype:gsub("char", "u8")
+ ctype = ctype:gsub("float", "f32")
+ ctype = ctype:gsub("const void%*", "?*const anyopaque")
+ ctype = ctype:gsub("Encoder%*", "?*Encoder")
+
+ if hasSuffix(ctype, "void*") then
+ ctype = ctype:gsub("void%*", "?*anyopaque");
+ elseif hasSuffix(ctype, "*") then
+ ctype = "[*c]" .. ctype:gsub("*", "")
+ end
+
+ if arg.array ~= nil then
+ ctype = ctype:gsub("const ", "")
+ ctype = convert_array(arg) .. ctype
+ end
+
+ return ctype
+end
+
+local function convert_struct_type(arg)
+ return convert_type(arg)
+end
+
+local function convert_ret_type(arg)
+ return convert_type(arg)
+end
+
+local function wrap_simple_func(func, args, argNames)
+ local zigFunc = {}
+ local zigFuncTemplate = [[pub inline fn $func($params) $ret {
+ return $cfunc($args);
+}]]
+
+ -- transform name to camelCase from snake_case
+ zigFunc.func = func.cname:gsub("_(.)", func.cname.upper)
+ -- make 2d/3d upper case 2D/3D
+ zigFunc.func = zigFunc.func:gsub("%dd", zigFunc.func.upper);
+ zigFunc.params = table.concat(args, ", ")
+ zigFunc.ret = convert_ret_type(func.ret)
+ zigFunc.cfunc = "bgfx_" .. func.cname
+ zigFunc.args = table.concat(argNames, ", ")
+ return zigFuncTemplate:gsub("$(%l+)", zigFunc)
+end
+
+local function wrap_method(func, type, args, argNames, indent)
+ local zigFunc = {}
+ local zigFuncTemplate = [[%spub inline fn $func($params) $ret {
+ %sreturn $cfunc($args);
+%s}]]
+
+ zigFuncTemplate = string.format(zigFuncTemplate, indent, indent, indent);
+
+ -- transform name to camelCase from snake_case
+ zigFunc.func = func.cname:gsub("_(.)", func.cname.upper)
+ -- remove type from name
+ zigFunc.func = gisub(zigFunc.func, type, "");
+ -- make first letter lowercase
+ zigFunc.func = zigFunc.func:gsub("^%L", string.lower)
+ -- make 2d/3d upper case 2D/3D
+ zigFunc.func = zigFunc.func:gsub("%dd", zigFunc.func.upper);
+ zigFunc.params = table.concat(args, ", ")
+ zigFunc.ret = convert_ret_type(func.ret)
+ -- remove C API pointer [*c] for fluent interfaces
+ if zigFunc.ret == ("[*c]" .. type) then
+ zigFunc.ret = zigFunc.ret:gsub("%[%*c%]", "*")
+ end
+ zigFunc.cfunc = "bgfx_" .. func.cname
+ zigFunc.args = table.concat(argNames, ", ")
+ return zigFuncTemplate:gsub("$(%l+)", zigFunc)
+end
+
+local converter = {}
+local yield = coroutine.yield
+local gen = {}
+
+local indent = ""
+
+function gen.gen()
+ -- find the functions that have `this` first argument
+ -- these belong to a type (struct) and we need to add them when converting structures
+ local methods = {}
+ for _, func in ipairs(idl["funcs"]) do
+ if func.this ~= nil then
+ if methods[func.this_type.type] == nil then
+ methods[func.this_type.type] = {}
+ end
+ table.insert(methods[func.this_type.type], func)
+ end
+ end
+
+ local r = zig_template:gsub("$(%l+)", function(what)
+ local tmp = {}
+ for _, object in ipairs(idl[what]) do
+ local co = coroutine.create(converter[what])
+ local any
+ -- we're pretty confident there are no types that have the same name with a func
+ local funcs = methods[object.name]
+ while true do
+ local ok, v = coroutine.resume(co, {
+ obj = object,
+ funcs = funcs
+ })
+ 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")
+ 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 = "u32"
+ if typ.bits == 64 then
+ format = "0x%016x"
+ enumType = "u64"
+ elseif typ.bits == 16 then
+ format = "0x%04x"
+ enumType = "u16"
+ end
+
+ local name = typ.name .. "Flags"
+ yield("pub const " .. name .. " = " .. enumType .. ";")
+
+ for idx, flag in ipairs(typ.flag) do
+ if flag.comment ~= nil then
+ if idx ~= 1 then
+ yield("")
+ end
+
+ for _, comment in ipairs(flag.comment) do
+ yield("/// " .. comment)
+ end
+ end
+
+ local flagName = flag.name:gsub("_", "")
+ -- make 2d/3d upper case 2D/3D
+ flagName = flagName:gsub("%dd", flagName.upper);
+ yield("pub const " .. name .. "_" .. flagName .. ": " .. name .. string.rep(" ", 22 - #(flagName)) .. " = " ..
+ string.format(flag.format or format, flag.value) .. ";")
+ end
+
+ if typ.shift then
+ yield(" " .. "Shift" .. string.rep(" ", 22 - #("Shift")) .. " = " .. flag.shift)
+ end
+
+ -- generate Mask
+ if typ.mask then
+ yield(" " .. "Mask" .. string.rep(" ", 22 - #("Mask")) .. " = " .. string.format(format, flag.mask))
+ end
+end
+
+local function lastCombinedFlagBlock()
+ if lastCombinedFlag then
+ local typ = combined[lastCombinedFlag]
+ if typ then
+ FlagBlock(combined[lastCombinedFlag])
+ yield("")
+ end
+ lastCombinedFlag = nil
+ end
+end
+
+local function convert_struct_member(member)
+ return member.name .. ": " .. convert_struct_type(member)
+end
+
+local namespace = ""
+
+function converter.types(params)
+ local typ = params.obj
+ local funcs = params.funcs
+ if typ.handle then
+ lastCombinedFlagBlock()
+
+ yield("pub const " .. typ.name .. " = extern struct {")
+ yield(" idx: c_ushort,")
+ yield("};")
+ elseif hasSuffix(typ.name, "::Enum") then
+ lastCombinedFlagBlock()
+
+ yield("pub const " .. typ.typename .. " = enum(c_int) {")
+ for idx, enum in ipairs(typ.enum) do
+
+ if enum.comment ~= nil then
+ if idx ~= 1 then
+ yield("")
+ end
+
+ for _, comment in ipairs(enum.comment) do
+ yield(" /// " .. comment)
+ end
+ end
+
+ yield(" " .. enum.name .. ",")
+ end
+ yield("");
+ yield(" Count")
+ 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("pub const " .. typ.namespace .. " = extern struct {")
+ namespace = typ.namespace
+ indent = " "
+ end
+ elseif namespace ~= "" then
+ indent = " "
+ namespace = ""
+ skip = true
+ end
+
+ if not skip then
+ if typ.name ~= "Encoder" then
+ yield(indent .. "pub const " .. typ.name .. " = extern struct {")
+ else
+ yield(indent .. "pub const " .. typ.name .. " = opaque {")
+ end
+ end
+
+ for _, member in ipairs(typ.struct) do
+ yield(indent .. indent .. convert_struct_member(member) .. ",")
+ end
+ if funcs ~= nil then
+ for _, func in ipairs(funcs) do
+ converter.funcs({
+ obj = func,
+ asMethod = true
+ })
+ end
+ end
+
+ yield(indent .. "};")
+ end
+end
+
+function converter.funcs(params)
+ local func = params.obj
+ if func.cpponly then
+ return
+ end
+
+ -- skip for now, don't know how to handle variadic functions
+ if func.cname == "dbg_text_printf" or func.cname == "dbg_text_vprintf" then
+ return
+ end
+
+ local func_indent = (params.asMethod == true and indent .. indent or "")
+
+ if func.comments ~= nil then
+ for _, line in ipairs(func.comments) do
+ yield(func_indent .. "/// " .. line)
+ end
+
+ local hasParams = false
+
+ for _, arg in ipairs(func.args) do
+ if arg.comment ~= nil then
+ local comment = table.concat(arg.comment, " ")
+
+ yield(func_indent .. "/// <param name=\"" .. arg.name .. "\">" .. comment .. "</param>")
+
+ hasParams = true
+ end
+ end
+ end
+
+ local args = {}
+ local argNames = {}
+
+ if func.this ~= nil then
+ local ptr = "[*c]"
+ if params.asMethod == true then
+ ptr = "*"
+ end
+ -- print("Function " .. func.name .. " has this: " .. func.this_type.type)
+ if func.const ~= nil then
+ ptr = ptr .. "const "
+ end
+
+ if func.this_type.type == "Encoder" then
+ ptr = "?*"
+ end
+ args[1] = "self: " .. ptr .. func.this_type.type
+ argNames[1] = "self"
+ end
+ for _, arg in ipairs(func.args) do
+ local argName = arg.name
+ -- local argName = arg.name:gsub("_", "")
+ -- argName = argName:gsub("enum", "enumeration")
+ -- argName = argName:gsub("type_", '@"type"')
+ if not isempty(argName) then
+ table.insert(argNames, argName)
+ table.insert(args, argName .. ": " .. convert_type(arg))
+ else
+ table.insert(args, convert_type(arg))
+ end
+ end
+
+ if (params.asMethod == true) then
+ yield(wrap_method(func, func.this_type.type, args, argNames, func_indent))
+ else
+ if func.this == nil then
+ yield(wrap_simple_func(func, args, argNames))
+ end
+ yield(
+ "extern fn bgfx_" .. func.cname .. "(" .. table.concat(args, ", ") .. ") " .. convert_ret_type(func.ret) ..
+ ";")
+ end
+end
+
+function gen.write(codes, outputfile)
+ local out = assert(io.open(outputfile, "wb"))
+ out:write(codes)
+ out:close()
+ print("Generating: " .. outputfile)
+end
+
+if (...) == nil then
+ -- run `lua bindings-zig.lua` in command line
+ print(gen.gen())
+end
+
+return gen