summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/scripts/bindings-cs.lua
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/scripts/bindings-cs.lua')
-rw-r--r--3rdparty/bgfx/scripts/bindings-cs.lua425
1 files changed, 425 insertions, 0 deletions
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