refactor xmake scripts

xmake/editor.lua

@@ -0,0 +1,15 @@
+target("Editor")
+	set_default(false)
+	
+	-- Disable building
+	on_build((function() end))
+    
+	on_run(
+        (function(godot_project_folder)
+            return function(target)
+                local project_file = path.join(godot_project_folder, "project.godot")
+                os.execv("echo", {"godot", project_file})
+                os.exec("godot " .. project_file)
+            end
+        end)(GODOT_PROJECT_FOLDER)
+    )

xmake/godot.lua

@@ -0,0 +1,26 @@
+------- project settings -------
+
+-- project name
+set_project(PROJECT_NAME)
+
+-- project version
+set_version(VERSION)
+
+-- min version of xmake we need to run
+-- NOTE: this is the version i used to develop this template, may not 100% correct
+set_xmakever("2.9.0")
+
+add_rules("mode.debug", "mode.release")
+
+-- c++17 is required for godot 4.x, we use c++20 here
+set_languages("c++20")
+
+-- use latest 4.x version by default
+add_requires("godotcpp4")
+
+
+includes("tasks.lua")
+
+includes("target.lua")
+
+includes("editor.lua")

xmake/target.lua

@@ -0,0 +1,65 @@
+-- more on https://xmake.io/#/manual/project_target
+target(PROJECT_NAME)
+    set_kind("shared")
+    set_default(true)
+
+    add_packages("godotcpp4")
+
+    -- more on https://xmake.io/#/manual/project_target?id=targetadd_files
+    add_files("../src/**.cpp")
+
+    -- change the output name
+    set_basename(PROJECT_NAME .. ".$(os)_$(mode)_$(arch)")
+
+    -- libraries will saved in os level folder
+    set_targetdir("../" .. GODOT_PROJECT_FOLDER .. "/lib")
+
+    -- where to save .obj files
+    -- we use a seprate folder, so that it will not populate the targer folder
+    set_objectdir("../build/.objs")
+
+    -- where .d files are saved
+    set_dependir("../build/.deps")
+
+    -- set_optimize("smallest")
+
+    -- handlers
+
+    -- before_run(function (target)  end)
+    -- after_run(function (target)  end)
+    -- before_build(function (target)  end)
+    -- after_build(function (target)  end)
+    -- before_clean(function (target)  end)
+    -- after_clean(function (target)  end)
+
+    on_run(
+        (function(godot_project_folder)
+            return function(target)
+                os.execv("echo", {"godot --path", godot_project_folder})
+                os.exec("godot --path " .. godot_project_folder)
+            end
+        end)(GODOT_PROJECT_FOLDER)
+    )
+
+    on_package(function(target)
+        import("core.base.task")
+
+        target_platform = "Unknown"
+
+        if is_plat("windows") then
+            target_platform = "Windows Desktop"
+        elseif is_plat("macosx") then
+            target_platform = "macOS"
+        elseif is_plat("linux") then
+            target_platform = "Linux/X11"
+        elseif is_plat("android") then
+            target_platform = "Android"
+        end
+
+        task.run("export", {}, target_platform)
+    end)
+
+    after_clean(function (target) 
+        import("core.base.task")
+        task.run("clean-publish")
+    end)

xmake/tasks.lua

@@ -0,0 +1,204 @@
+-- NOTE:
+-- xmake cannot accept the global variables in on_xxx functions, so we use a wrapper function to bind it
+
+-- export specified godot project, with the export execution name
+-- args:
+--  target_platform: the target platform, like "Windows Desktop"
+--  name: the export execute name, it will be endswith ".exe" on windows
+task("export")
+    on_run((function(godot_project_folder, publish_folder) 
+        return function(target_platform)
+            local name = godot_project_folder
+            
+            -- different platform may have different execute name
+            -- xmake supported platforms:
+            -- windows
+            -- cross
+            -- linux
+            -- macosx
+            -- android
+            -- iphoneos
+            -- watchos
+            if is_plat("windows") then
+                name = name .. ".exe"
+            end
+
+            local export_mode = "export-debug"
+
+            if is_mode("release") then
+                export_mode = "export-release"
+            end
+
+            if not os.isdir(publish_folder) then
+                os.mkdir(publish_folder)
+            end
+
+            local godot_project_file = path.join(godot_project_folder, "project.godot")
+
+            local export_path = path.absolute(path.join(publish_folder, name))
+
+            os.execv("echo", {"godot", godot_project_file, export_mode, target_platform, export_path})
+            os.exec("godot %s --headless --%s %s %s", godot_project_file, export_mode, "\"" .. target_platform .. "\"", export_path)
+        end
+    
+    end)(GODOT_PROJECT_FOLDER, PUBLISH_FOLDER))
+task_end()
+
+
+
+
+
+-- clean the publish folder and build folder
+task("clean-publish")
+    on_run((function(godot_project_folder, publish_folder)
+        return function ()
+            -- remove publish folder
+            if os.isdir(publish_folder) then
+                os.tryrm(publish_folder)
+            end
+
+            -- remove build target folder
+            local bin_dir = path.join(godot_project_folder, "bin")
+            if os.isdir(bin_dir) then
+                os.tryrm(path.join(bin_dir, "$(os)"))
+            end
+        end
+    end)(GODOT_PROJECT_FOLDER, PUBLISH_FOLDER))
+task_end()
+
+
+-- tasks that exposed to cli
+-- NOTE: for complex tasks, we can use a seprate file to define it
+
+-- generate a class that inherit from godot class
+-- args:
+--   name: the new class name
+--   basename: the base class name to inherit (must under godot_cpp/classes)
+--   dir: the directory to save the class (must under src)
+--   namespace: the namespace of the new class
+
+task("ext-class")
+    on_run(function ()
+        -- more on: https://xmake.io/#/manual/plugin_task
+        -- we need this module to load options from menu
+        import "core.base.option"
+
+        local namespace = option.get("namespace")
+        local name = option.get("name")
+        local base = option.get("base")
+        local dir = option.get("dir")
+
+        -- we calculate these here, in case there is any special case to handle
+        local header_guard = string.upper(name) .. "_H"
+
+        import("class_tpl", {rootdir="templates", alias="class_render"})
+
+        -- header and impl text
+        local header_text = class_render.render_header(header_guard, namespace, name, base)
+        local impl_text = class_render.render_impl(namespace, name)
+
+        -- save
+        local output_dir = "src"
+
+        if dir ~= nil then
+            output_dir = path.join("src", dir)
+        end
+
+        if not os.isdir(output_dir) then
+            os.mkdir(output_dir)
+        end
+
+        local header_file = path.join(output_dir, string.lower(name) .. ".h")
+        local impl_file = path.join(output_dir, string.lower(name) .. ".cpp")
+
+        io.writefile(header_file, header_text)
+        io.writefile(impl_file, impl_text)
+
+    end)
+
+    -- options 
+    set_menu {
+        usage = "xmake ext-class [options]",
+
+        description = "Generate godot class that inherits from a base class under godot_cpp/classes",
+
+        options = {
+
+            -- kv options
+            -- (short, long), (kv, default_value), description, [values])
+            {"s", "namespace",    "kv", "godot",  "Set the namespace of the new class"},
+            {"d", "dir",          "kv", nil,      "Set the directory to save the class"},
+
+            {},
+
+            -- single value options
+            {"n", "name",         "v", nil,       "Set the new class name"},
+            {"b", "base",         "v", nil,       "Set the base class name to inherit"},
+        }
+    }
+task_end() 
+
+
+
+
+
+task("gengdextension")
+    on_run((function(godot_project_folder, project_name)
+        return function ()
+
+            local bin_dir = path.join(godot_project_folder, "bin")
+            if not os.isdir(bin_dir) then
+                os.mkdir(bin_dir)
+            end
+            
+            local godot_gdextension_file = path.join(bin_dir, project_name .. ".gdextension")
+
+            local fileContent = 
+[[
+[icons]
+ProjectName = "res://icon.svg"
+
+[configuration]
+
+entry_symbol = "library_init"
+compatibility_minimum = "4.2"
+
+[libraries]
+
+macos.debug = "res://lib/libProjectName.macos_framework"
+macos.release = "res://lib/libProjectName.macos_framework"
+
+window.debug.x86_32 = "res://lib/libProjectName.windows_debug_x86.dll"
+window.release.x86_32 = "res://lib/libProjectName.windows_release_x86.dll"
+window.debug.x86_64 = "res://lib/libProjectName.windows_debug_x64.dll"
+window.release.x86_64 = "res://lib/libProjectName.windows_release_x64.dll"
+
+linux.debug.x86_64 = "res://lib/libProjectName.linux_debug_x86_64.so"
+linux.release.x86_64 = "res://lib/libProjectName.linux_release_x86_64.so"
+linux.debug.arm64 = "res://lib/libProjectName.linux_debug_arm64.so"
+linux.release.arm64 = "res://lib/libProjectName.linux_release_arm64.so"
+linux.debug.rv64 = "res://lib/libProjectName.linux_debug_rv64.so"
+linux.release.rv64 = "res://lib/libProjectName.linux_release_rv64.so"
+
+android.debug.x86_64 = "res://lib/libProjectName.android_debug_x86_64.so"
+android.release.x86_64 = "res://lib/libProjectName.android_release_x86_64.so"
+android.debug.arm64 = "res://lib/libProjectName.android_debug_arm64.so"
+android.release.arm64 = "res://lib/libProjectName.android_release_arm64.so"
+
+]]
+
+            -- needs testing with macos
+
+            fileContent = string.gsub(fileContent, "ProjectName", project_name)
+
+            io.writefile(godot_gdextension_file, fileContent)
+        end
+    end)(GODOT_PROJECT_FOLDER, PROJECT_NAME))
+
+    -- options 
+    set_menu {
+        usage = "xmake gengdextension",
+
+        description = "Generate gdextension file",
+    }
+task_end()