CI: Install MinGW via egor-tensin/setup-mingw

Scoop install is being problematic since their 0.1.0 release.

(cherry picked from commit 3846201fbb)

.github/actions/godot-cache/action.yml

@@ -1,22 +0,0 @@
-name: Setup Godot build cache
-description: Setup Godot build cache.
-inputs:
-  cache-name:
-    description: The cache base name (job name by default).
-    default: "${{github.job}}"
-  scons-cache:
-    description: The scons cache path.
-    default: "${{github.workspace}}/.scons-cache/"
-runs:
-  using: "composite"
-  steps:
-    # Upload cache on completion and check it out now
-    - name: Load .scons_cache directory
-      uses: actions/cache@v3
-      with:
-        path: ${{inputs.scons-cache}}
-        key: ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
-        restore-keys: |
-          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
-          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}
-          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}

.github/workflows/ci.yml

@@ -1,143 +1,154 @@
 name: Continuous integration
 on: [push, pull_request]
 
-env:
-  # Only used for the cache key. Increment version to force clean build.
-  GODOT_BASE_BRANCH: 3.x
-
-concurrency:
-  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}
-  cancel-in-progress: true
-
 jobs:
-  build:
-    name: ${{ matrix.name }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: 🐧 Linux (GCC)
-            os: ubuntu-20.04
-            platform: linux
-            artifact-name: godot-cpp-linux-glibc2.31-x86_64-release
-            artifact-path: bin/libgodot-cpp.linux.release.64.a
-            godot_zip: Godot_v3.5-stable_linux_server.64.zip
-            executable: Godot_v3.5-stable_linux_server.64
-            cache-name: linux-x86_64
-
-          - name: 🏁 Windows (x86_64, MSVC)
-            os: windows-2022
-            platform: windows
-            artifact-name: godot-cpp-windows-msvc2019-x86_64-release
-            artifact-path: bin/libgodot-cpp.windows.release.64.lib
-            cache-name: windows-x86_64-msvc
-
-          - name: 🏁 Windows (x86_64, MinGW)
-            os: windows-2022
-            platform: windows
-            artifact-name: godot-cpp-linux-mingw-x86_64-release
-            artifact-path: bin/libgodot-cpp.windows.release.64.a
-            flags: use_mingw=yes
-            cache-name: windows-x86_64-mingw
-
-          - name: 🍎 macOS (universal)
-            os: macos-13
-            platform: osx
-            artifact-name: godot-cpp-macos-universal-release
-            artifact-path: bin/libgodot-cpp.osx.release.64.a
-            flags: macos_arch=universal
-            godot_zip: Godot_v3.5-stable_osx.universal.zip
-            executable: Godot.app/Contents/MacOS/Godot
-            cache-name: macos-unversal
-
-          - name: 🤖 Android (arm64)
-            os: ubuntu-20.04
-            platform: android
-            artifact-name: godot-cpp-android-arm64-release
-            artifact-path: bin/libgodot-cpp.android.release.arm64v8.a
-            flags: ANDROID_NDK_ROOT=$ANDROID_NDK_LATEST_HOME android_arch=arm64v8
-            cache-name: android-arm64
-
-          - name: 🍏 iOS (arm64)
-            os: macos-13
-            platform: ios
-            artifact-name: godot-cpp-ios-arm64-release
-            artifact-path: bin/libgodot-cpp.ios.release.arm64.a
-            cache-name: ios-arm64
-
-    env:
-      SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
-
+  linux:
+    name: Build (Linux, GCC)
+    runs-on: ubuntu-18.04
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
         with:
           submodules: recursive
 
-      - name: Setup Godot build cache
-        uses: ./.github/actions/godot-cache
-        with:
-          cache-name: ${{ matrix.cache-name }}
-        continue-on-error: true
-
       - name: Set up Python (for SCons)
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v2
         with:
           python-version: '3.x'
 
-      - name: Linux dependencies
-        if: ${{ matrix.platform == 'linux' }}
+      - name: Install dependencies
         run: |
           sudo apt-get update -qq
           sudo apt-get install -qqq build-essential pkg-config
+          python -m pip install scons
+          curl -LO https://downloads.tuxfamily.org/godotengine/3.4/Godot_v3.4-stable_linux_server.64.zip
+          unzip Godot_v3.4-stable_linux_server.64.zip
 
-      - name: Install scons
+      - name: Build godot-cpp
+        run: |
+          scons target=release generate_bindings=yes -j $(nproc)
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: godot-cpp-linux-glibc2.27-x86_64-release
+          path: bin/libgodot-cpp.linux.release.64.a
+          if-no-files-found: error
+
+      - name: Build test GDNative library
+        run: |
+          scons target=release platform=linux bits=64 -j $(nproc) -C test
+
+      - name: Run test GDNative library
+        run: |
+          ./Godot_v3.4-stable_linux_server.64 --path test -s script.gd
+
+  windows-msvc:
+    name: Build (Windows, MSVC)
+    runs-on: windows-2019
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+
+      - name: Set up Python (for SCons)
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
         run: |
           python -m pip install scons
 
-      - name: Windows dependency (MinGW)
-        if: ${{ matrix.platform == 'windows' }}
-        uses: egor-tensin/setup-mingw@v2
-        with:
-          version: 12.2.0
-
-      - name: Build godot-cpp (debug)
+      - name: Build godot-cpp
         run: |
-          scons platform=${{ matrix.platform }} target=debug ${{ matrix.flags }}
-
-      - name: Build test without rebuilding godot-cpp (debug)
-        run: |
-          cd test
-          scons platform=${{ matrix.platform }} target=debug ${{ matrix.flags }} build_library=no
-
-      - name: Build test and godot-cpp (release)
-        run: |
-          cd test
-          scons platform=${{ matrix.platform }} target=release ${{ matrix.flags }}
-
-      - name: Run test GDNative library
-        if: ${{ matrix.platform == 'linux' || matrix.platform == 'osx' }}
-        run: |
-          curl -LO https://downloads.tuxfamily.org/godotengine/3.5/${{ matrix.godot_zip }}
-          unzip ${{ matrix.godot_zip }}
-          ./${{ matrix.executable }} --path test -s script.gd
+          scons target=release generate_bindings=yes -j $env:NUMBER_OF_PROCESSORS
 
       - name: Upload artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v2
         with:
-          name: ${{ matrix.artifact-name }}
-          path: ${{ matrix.artifact-path }}
+          name: godot-cpp-windows-msvc2019-x86_64-release
+          path: bin/libgodot-cpp.windows.release.64.lib
           if-no-files-found: error
 
+  windows-mingw:
+    name: Build (Windows, MinGW)
+    runs-on: windows-2019
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+
+      - name: Set up Python (for SCons)
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install scons
+
+      - name: Setup MinGW for Windows/MinGW build
+        uses: egor-tensin/setup-mingw@v2
+
+      - name: Build godot-cpp
+        run: |
+          scons target=release generate_bindings=yes use_mingw=yes -j $env:NUMBER_OF_PROCESSORS
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: godot-cpp-linux-mingw-x86_64-release
+          path: bin/libgodot-cpp.windows.release.64.a
+          if-no-files-found: error
+
+  macos:
+    name: Build (macOS, Clang)
+    runs-on: macos-11
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+
+      - name: Set up Python (for SCons)
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install scons
+          curl -LO https://downloads.tuxfamily.org/godotengine/3.4/Godot_v3.4-stable_osx.universal.zip
+          unzip Godot_v3.4-stable_osx.universal.zip
+
+      - name: Build godot-cpp
+        run: |
+          scons target=release generate_bindings=yes -j $(sysctl -n hw.logicalcpu)
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: godot-cpp-macos-universal-release
+          path: bin/libgodot-cpp.osx.release.64.a
+          if-no-files-found: error
+
+      - name: Build test GDNative library
+        run: |
+          scons target=release platform=osx bits=64 macos_arch=universal -j $(sysctl -n hw.logicalcpu) -C test
+
+      - name: Run test GDNative library
+        run: |
+          ./Godot.app/Contents/MacOS/Godot --path test -s script.gd
+
   static-checks:
-    name: 📊 Static Checks (clang-format)
+    name: Static Checks (clang-format)
     runs-on: ubuntu-20.04
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
+        uses: actions/checkout@v2
 
       - name: Make apt sources.list use the default Ubuntu repositories
         run: |
@@ -154,7 +165,3 @@ jobs:
       - name: Style checks via clang-format
         run: |
           bash ./misc/scripts/clang_format.sh
-
-      - name: Bindings generation checks (ensures get_file_list returns all generated files)
-        run: |
-          python ./misc/scripts/check_get_file_list.py

.gitignore

@@ -1,11 +1,7 @@
 # Misc
-gen/*
 logs/*
 *.log
 
-# The default cache directory
-.scons_cache/
-
 # Binaries
 *.o
 *.os

CMakeLists.txt

@@ -1,36 +1,36 @@
 # cmake arguments
 # CMAKE_BUILD_TYPE:			Compilation target (Debug or Release defaults to Debug)
-#
+# 
 # godot-cpp cmake arguments
 # GODOT_HEADERS_DIR:		This is where the gdnative include folder is (godot_source/modules/gdnative/include)
 # GODOT_CUSTOM_API_FILE:	This is if you have another path for the godot_api.json
-#
+# 
 # Android cmake arguments
 # CMAKE_TOOLCHAIN_FILE:		The path to the android cmake toolchain ($ANDROID_NDK/build/cmake/android.toolchain.cmake)
 # ANDROID_NDK:				The path to the android ndk root folder
 # ANDROID_TOOLCHAIN_NAME:	The android toolchain (arm-linux-androideabi-4.9 or aarch64-linux-android-4.9 or x86-4.9 or x86_64-4.9)
 # ANDROID_PLATFORM:			The android platform version (android-23)
 # More info here: https://godot.readthedocs.io/en/latest/development/compiling/compiling_for_android.html
-#
+# 
 # Examples
-#
+# 
 # Builds a debug version:
 # cmake .
 # cmake --build .
-#
+# 
 # Builds a release version with clang
 # CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" .
 # cmake --build .
-#
+# 
 # Builds an android armeabi-v7a debug version:
 # cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake -DANDROID_NDK=$ANDROID_NDK \
 #		-DANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.9 -DANDROID_PLATFORM=android-23 -DCMAKE_BUILD_TYPE=Debug .
 # cmake --build .
-#
+# 
 # Protip
 # Generate the buildfiles in a sub directory to not clutter the root directory with build files:
 # mkdir build && cd build && cmake -G "Unix Makefiles" .. && cmake --build .
-#
+# 
 # Todo
 # Test build for Windows, Mac and mingw.
 
@@ -40,7 +40,7 @@ cmake_minimum_required(VERSION 3.6)
 option(GENERATE_TEMPLATE_GET_NODE "Generate a template version of the Node class's get_node." ON)
 
 # Change the output directory to the bin directory
-set(BUILD_PATH ${CMAKE_CURRENT_SOURCE_DIR}/bin)
+set(BUILD_PATH ${CMAKE_SOURCE_DIR}/bin)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${BUILD_PATH}")
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${BUILD_PATH}")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${BUILD_PATH}")
@@ -52,7 +52,7 @@ SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${BUILD_PATH}")
 SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${BUILD_PATH}")
 
 # Default build type is Debug in the SConstruct
-if("${CMAKE_BUILD_TYPE}" STREQUAL "")
+if(CMAKE_BUILD_TYPE STREQUAL "")
 	set(CMAKE_BUILD_TYPE Debug)
 endif()
 
@@ -67,13 +67,6 @@ set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-if(NOT DEFINED BITS)
-	set(BITS 32)
-	if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-		set(BITS 64)
-	endif(CMAKE_SIZEOF_VOID_P EQUAL 8)
-endif()
-
 # Input from user for godot headers and the api file
 set(GODOT_HEADERS_DIR "godot-headers" CACHE STRING "")
 set(GODOT_CUSTOM_API_FILE "godot-headers/api.json" CACHE STRING "")
@@ -104,13 +97,17 @@ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 	#	string(REGEX REPLACE "/W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 	#endif()
 
-else()  # GCC/Clang
+else()
+
+#elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	# using Clang
+#elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+	# using GCC and maybe MinGW?
+
 	set(GODOT_LINKER_FLAGS "-static-libgcc -static-libstdc++ -Wl,-R,'$$ORIGIN'")
 
-	if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
-		set(GODOT_COMPILE_FLAGS "-fPIC")
-	endif()
-	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -g -Wwrite-strings")
+	# Hmm.. maybe to strikt?
+	set(GODOT_COMPILE_FLAGS "-fPIC -g -Wwrite-strings")
 	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wchar-subscripts -Wcomment -Wdisabled-optimization")
 	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wformat -Wformat=2 -Wformat-security -Wformat-y2k")
 	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wimport -Winit-self -Winline -Winvalid-pch -Werror")
@@ -197,6 +194,11 @@ set_property(TARGET ${PROJECT_NAME} APPEND_STRING PROPERTY LINK_FLAGS ${GODOT_LI
 
 # Create the correct name (godot.os.build_type.system_bits)
 
+set(BITS 32)
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+	set(BITS 64)
+endif(CMAKE_SIZEOF_VOID_P EQUAL 8)
+
 string(TOLOWER "${CMAKE_SYSTEM_NAME}" SYSTEM_NAME)
 string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE)
 

Makefile

@@ -3,7 +3,7 @@ HEADERS = godot-headers
 TARGET = debug
 USE_CLANG = no
 
-BASE = scons use_llvm=$(USE_CLANG) generate_bindings=$(GENERATE_BINDINGS) target=$(TARGET) headers=$(HEADERS)
+BASE = scons use_llvm=$(USE_CLANG) generate_bindings=$(GENERATE_BINDINGS) target=$(TARGET) headers=$(HEADERS) -j4
 LINUX = $(BASE) platform=linux
 WINDOWS = $(BASE) platform=windows
 OSX = $(BASE) platform=osx

SConstruct

@@ -1,10 +1,19 @@
 #!/usr/bin/env python
 
-import codecs
 import os
 import sys
 import subprocess
-from binding_generator import scons_generate_bindings, scons_emit_files
+
+if sys.version_info < (3,):
+
+    def decode_utf8(x):
+        return x
+
+else:
+    import codecs
+
+    def decode_utf8(x):
+        return codecs.utf_8_decode(x)[0]
 
 
 # Workaround for MinGW. See:
@@ -72,25 +81,6 @@ else:
 
 env = Environment(ENV=os.environ)
 
-# Default num_jobs to local cpu count if not user specified.
-# SCons has a peculiarity where user-specified options won't be overridden
-# by SetOption, so we can rely on this to know if we should use our default.
-initial_num_jobs = env.GetOption("num_jobs")
-altered_num_jobs = initial_num_jobs + 1
-env.SetOption("num_jobs", altered_num_jobs)
-# os.cpu_count() requires Python 3.4+.
-if hasattr(os, "cpu_count") and env.GetOption("num_jobs") == altered_num_jobs:
-    cpu_count = os.cpu_count()
-    if cpu_count is None:
-        print("Couldn't auto-detect CPU count to configure build parallelism. Specify it with the -j argument.")
-    else:
-        safer_cpu_count = cpu_count if cpu_count <= 4 else cpu_count - 1
-        print(
-            "Auto-detected %d CPU cores available for build parallelism. Using %d cores by default. You can override it with the -j argument."
-            % (cpu_count, safer_cpu_count)
-        )
-        env.SetOption("num_jobs", safer_cpu_count)
-
 is64 = sys.maxsize > 2 ** 32
 if (
     env["TARGET_ARCH"] == "amd64"
@@ -117,22 +107,20 @@ opts.Add(BoolVariable("use_mingw", "Use the MinGW compiler instead of MSVC - onl
 opts.Add(EnumVariable("target", "Compilation target", "debug", allowed_values=("debug", "release"), ignorecase=2))
 opts.Add(
     PathVariable(
-        "headers_dir",
-        "Path to the directory containing Godot headers",
-        "godot-headers",
-        PathVariable.PathIsDir,
+        "headers_dir", "Path to the directory containing Godot headers", "godot-headers", PathVariable.PathIsDir
     )
 )
 opts.Add(PathVariable("custom_api_file", "Path to a custom JSON API file", None, PathVariable.PathIsFile))
-opts.Add(BoolVariable("generate_bindings", "Force GDNative API bindings generation.", False))
 opts.Add(
     EnumVariable(
-        "android_arch",
-        "Target Android architecture",
-        "armv7",
-        ["armv7", "arm64v8", "x86", "x86_64"],
+        "generate_bindings",
+        "Generate GDNative API bindings",
+        "auto",
+        allowed_values=["yes", "no", "auto", "true"],
+        ignorecase=2,
     )
 )
+opts.Add(EnumVariable("android_arch", "Target Android architecture", "armv7", ["armv7", "arm64v8", "x86", "x86_64"]))
 opts.Add("macos_deployment_target", "macOS deployment target", "default")
 opts.Add("macos_sdk_path", "macOS SDK path", "")
 opts.Add(EnumVariable("macos_arch", "Target macOS architecture", "universal", ["universal", "x86_64", "arm64"]))
@@ -153,26 +141,11 @@ opts.Add(
     "Path to your Android NDK installation. By default, uses ANDROID_NDK_ROOT from your defined environment variables.",
     os.environ.get("ANDROID_NDK_ROOT", None),
 )
-opts.Add(
-    BoolVariable(
-        "generate_template_get_node",
-        "Generate a template version of the Node class's get_node.",
-        True,
-    )
-)
-
-opts.Add(BoolVariable("build_library", "Build the godot-cpp library.", True))
+opts.Add(BoolVariable("generate_template_get_node", "Generate a template version of the Node class's get_node.", True))
 
 opts.Update(env)
 Help(opts.GenerateHelpText(env))
 
-# Detect and print a warning listing unknown SCons variables to ease troubleshooting.
-unknown = opts.UnknownVariables()
-if unknown:
-    print("WARNING: Unknown SCons variables were passed and will be ignored:")
-    for item in unknown.items():
-        print("    " + item[0] + "=" + item[1])
-
 # This makes sure to keep the session environment variables on Windows.
 # This way, you can run SCons in a Visual Studio 2017 prompt and it will find
 # all the required tools
@@ -184,18 +157,11 @@ if host_platform == "windows" and env["platform"] != "android":
 
     opts.Update(env)
 
-# Require C++14
-if host_platform == "windows" and env["platform"] == "windows" and not env["use_mingw"]:
-    # MSVC
-    env.Append(CCFLAGS=["/std:c++14"])
-else:
-    env.Append(CCFLAGS=["-std=c++14"])
-
 if env["platform"] == "linux" or env["platform"] == "freebsd":
     if env["use_llvm"]:
         env["CXX"] = "clang++"
 
-    env.Append(CCFLAGS=["-fPIC", "-Wwrite-strings"])
+    env.Append(CCFLAGS=["-fPIC", "-std=c++14", "-Wwrite-strings"])
     env.Append(LINKFLAGS=["-Wl,-R,'$$ORIGIN'"])
 
     if env["target"] == "debug":
@@ -224,6 +190,8 @@ elif env["platform"] == "osx":
         env.Append(LINKFLAGS=["-arch", env["macos_arch"]])
         env.Append(CCFLAGS=["-arch", env["macos_arch"]])
 
+    env.Append(CCFLAGS=["-std=c++14"])
+
     if env["macos_deployment_target"] != "default":
         env.Append(CCFLAGS=["-mmacosx-version-min=" + env["macos_deployment_target"]])
         env.Append(LINKFLAGS=["-mmacosx-version-min=" + env["macos_deployment_target"]])
@@ -232,7 +200,13 @@ elif env["platform"] == "osx":
         env.Append(CCFLAGS=["-isysroot", env["macos_sdk_path"]])
         env.Append(LINKFLAGS=["-isysroot", env["macos_sdk_path"]])
 
-    env.Append(LINKFLAGS=["-Wl,-undefined,dynamic_lookup"])
+    env.Append(
+        LINKFLAGS=[
+            "-framework",
+            "Cocoa",
+            "-Wl,-undefined,dynamic_lookup",
+        ]
+    )
 
     if env["target"] == "debug":
         env.Append(CCFLAGS=["-Og", "-g"])
@@ -243,12 +217,13 @@ elif env["platform"] == "ios":
     if env["ios_simulator"]:
         sdk_name = "iphonesimulator"
         env.Append(CCFLAGS=["-mios-simulator-version-min=10.0"])
+        env["LIBSUFFIX"] = ".simulator" + env["LIBSUFFIX"]
     else:
         sdk_name = "iphoneos"
         env.Append(CCFLAGS=["-miphoneos-version-min=10.0"])
 
     try:
-        sdk_path = codecs.utf_8_decode(subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip())[0]
+        sdk_path = decode_utf8(subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip())
     except (subprocess.CalledProcessError, OSError):
         raise ValueError("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))
 
@@ -259,13 +234,14 @@ elif env["platform"] == "ios":
     env["CXX"] = compiler_path + "clang++"
     env["AR"] = compiler_path + "ar"
     env["RANLIB"] = compiler_path + "ranlib"
-    env["SHLIBSUFFIX"] = ".dylib"
 
-    env.Append(CCFLAGS=["-arch", env["ios_arch"], "-isysroot", sdk_path])
+    env.Append(CCFLAGS=["-std=c++14", "-arch", env["ios_arch"], "-isysroot", sdk_path])
     env.Append(
         LINKFLAGS=[
             "-arch",
             env["ios_arch"],
+            "-framework",
+            "Cocoa",
             "-Wl,-undefined,dynamic_lookup",
             "-isysroot",
             sdk_path,
@@ -304,20 +280,14 @@ elif env["platform"] == "windows":
         # Don't Clone the environment. Because otherwise, SCons will pick up msvc stuff.
         env = Environment(ENV=os.environ, tools=["mingw"])
         opts.Update(env)
-
-        # Still need to use C++14.
-        env.Append(CCFLAGS=["-std=c++14"])
-        # Don't want lib prefixes
-        env["IMPLIBPREFIX"] = ""
-        env["SHLIBPREFIX"] = ""
+        # env = env.Clone(tools=['mingw'])
 
         env["SPAWN"] = mySpawn
-        env.Replace(ARFLAGS=["q"])
 
     # Native or cross-compilation using MinGW
     if host_platform == "linux" or host_platform == "freebsd" or host_platform == "osx" or env["use_mingw"]:
         # These options are for a release build even using target=debug
-        env.Append(CCFLAGS=["-O3", "-Wwrite-strings"])
+        env.Append(CCFLAGS=["-O3", "-std=c++14", "-Wwrite-strings"])
         env.Append(
             LINKFLAGS=[
                 "--static",
@@ -332,10 +302,9 @@ elif env["platform"] == "android":
         # Don't Clone the environment. Because otherwise, SCons will pick up msvc stuff.
         env = Environment(ENV=os.environ, tools=["mingw"])
         opts.Update(env)
+        # env = env.Clone(tools=['mingw'])
 
-        # Long line hack. Use custom spawn, quick AR append (to avoid files with the same names to override each other).
         env["SPAWN"] = mySpawn
-        env.Replace(ARFLAGS=["q"])
 
     # Verify NDK root
     if not "ANDROID_NDK_ROOT" in env:
@@ -400,22 +369,16 @@ elif env["platform"] == "android":
     # Setup tools
     env["CC"] = toolchain + "/bin/clang"
     env["CXX"] = toolchain + "/bin/clang++"
-    env["AR"] = toolchain + "/bin/llvm-ar"
-    env["AS"] = toolchain + "/bin/llvm-as"
-    env["LD"] = toolchain + "/bin/llvm-ld"
-    env["STRIP"] = toolchain + "/bin/llvm-strip"
-    env["RANLIB"] = toolchain + "/bin/llvm-ranlib"
-    env["SHLIBSUFFIX"] = ".so"
+    env["AR"] = toolchain + "/bin/" + arch_info["tool_path"] + "-ar"
+    env["AS"] = toolchain + "/bin/" + arch_info["tool_path"] + "-as"
+    env["LD"] = toolchain + "/bin/" + arch_info["tool_path"] + "-ld"
+    env["STRIP"] = toolchain + "/bin/" + arch_info["tool_path"] + "-strip"
+    env["RANLIB"] = toolchain + "/bin/" + arch_info["tool_path"] + "-ranlib"
 
     env.Append(
-        CCFLAGS=[
-            "--target=" + arch_info["target"] + env["android_api_level"],
-            "-march=" + arch_info["march"],
-            "-fPIC",
-        ]
+        CCFLAGS=["--target=" + arch_info["target"] + env["android_api_level"], "-march=" + arch_info["march"], "-fPIC"]
     )
     env.Append(CCFLAGS=arch_info["ccflags"])
-    env.Append(LINKFLAGS=["--target=" + arch_info["target"] + env["android_api_level"], "-march=" + arch_info["march"]])
 
     if env["target"] == "debug":
         env.Append(CCFLAGS=["-Og", "-g"])
@@ -455,14 +418,17 @@ elif env["platform"] == "javascript":
     elif env["target"] == "release":
         env.Append(CCFLAGS=["-O3"])
 
-# Cache
-scons_cache_path = os.environ.get("SCONS_CACHE")
-if scons_cache_path is not None:
-    CacheDir(scons_cache_path)
-    Decider("MD5")
+env.Append(
+    CPPPATH=[
+        ".",
+        env["headers_dir"],
+        "include",
+        "include/gen",
+        "include/core",
+    ]
+)
 
-# Generate bindings
-env.Append(BUILDERS={"GenerateBindings": Builder(action=scons_generate_bindings, emitter=scons_emit_files)})
+# Generate bindings?
 json_api_file = ""
 
 if "custom_api_file" in env:
@@ -470,46 +436,36 @@ if "custom_api_file" in env:
 else:
     json_api_file = os.path.join(os.getcwd(), env["headers_dir"], "api.json")
 
-bindings = env.GenerateBindings(
-    env.Dir("."), [json_api_file, "binding_generator.py"]
-)
+if env["generate_bindings"] == "auto":
+    # Check if generated files exist
+    should_generate_bindings = not os.path.isfile(os.path.join(os.getcwd(), "src", "gen", "Object.cpp"))
+else:
+    should_generate_bindings = env["generate_bindings"] in ["yes", "true"]
 
-# Forces bindings regeneration.
-if env["generate_bindings"]:
-    AlwaysBuild(bindings)
-    NoCache(bindings)
+if should_generate_bindings:
+    # Actually create the bindings here
+    import binding_generator
 
-# Includes
-env.Append(CPPPATH=[[env.Dir(d) for d in [".", env["headers_dir"], "include", "include/gen", "include/core"]]])
+    binding_generator.generate_bindings(json_api_file, env["generate_template_get_node"])
 
 # Sources to compile
 sources = []
 add_sources(sources, "src/core", "cpp")
-sources.extend(f for f in bindings if str(f).endswith(".cpp"))
+add_sources(sources, "src/gen", "cpp")
 
 arch_suffix = env["bits"]
 if env["platform"] == "android":
     arch_suffix = env["android_arch"]
 elif env["platform"] == "ios":
     arch_suffix = env["ios_arch"]
-    if env["ios_simulator"]:
-        arch_suffix += ".simulator"
 elif env["platform"] == "osx":
     if env["macos_arch"] != "universal":
         arch_suffix = env["macos_arch"]
 elif env["platform"] == "javascript":
     arch_suffix = "wasm"
-# Expose it to projects that import this env.
-env["arch_suffix"] = arch_suffix
 
-library = None
-env["OBJSUFFIX"] = ".{}.{}.{}{}".format(env["platform"], env["target"], arch_suffix, env["OBJSUFFIX"])
-library_name = "libgodot-cpp.{}.{}.{}{}".format(env["platform"], env["target"], arch_suffix, env["LIBSUFFIX"])
-
-if env["build_library"]:
-    library = env.StaticLibrary(target=env.File("bin/%s" % library_name), source=sources)
-    Default(library)
-
-env.Append(LIBPATH=[env.Dir("bin")])
-env.Append(LIBS=library_name)
-Return("env")
+library = env.StaticLibrary(
+    target="bin/" + "libgodot-cpp.{}.{}.{}{}".format(env["platform"], env["target"], arch_suffix, env["LIBSUFFIX"]),
+    source=sources,
+)
+Default(library)

binding_generator.py

@@ -15,9 +15,9 @@ def correct_method_name(method_list):
 classes = []
 
 
-def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+def print_file_list(api_filepath, output_dir, headers=False, sources=False):
     global classes
-    files = []
+    end = ";"
     with open(api_filepath) as api_file:
         classes = json.load(api_file)
     include_gen_folder = Path(output_dir) / "include" / "gen"
@@ -26,35 +26,17 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
         header_filename = include_gen_folder / (strip_name(_class["name"]) + ".hpp")
         source_filename = source_gen_folder / (strip_name(_class["name"]) + ".cpp")
         if headers:
-            files.append(str(header_filename.as_posix()))
+            print(str(header_filename.as_posix()), end=end)
         if sources:
-            files.append(str(source_filename.as_posix()))
+            print(str(source_filename.as_posix()), end=end)
     icall_header_filename = include_gen_folder / "__icalls.hpp"
     register_types_filename = source_gen_folder / "__register_types.cpp"
     init_method_bindings_filename = source_gen_folder / "__init_method_bindings.cpp"
     if headers:
-        files.append(str(icall_header_filename.as_posix()))
+        print(str(icall_header_filename.as_posix()), end=end)
     if sources:
-        files.append(str(register_types_filename.as_posix()))
-        files.append(str(init_method_bindings_filename.as_posix()))
-    return files
-
-
-def print_file_list(api_filepath, output_dir, headers=False, sources=False):
-    for f in get_file_list(api_filepath, output_dir, headers, sources):
-        print(f, end=";")
-
-
-def scons_emit_files(target, source, env):
-    files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)]
-    env.Clean(target, files)
-    env["godot_cpp_gen_dir"] = target[0].abspath
-    return files, source
-
-
-def scons_generate_bindings(target, source, env):
-    generate_bindings(str(source[0]), env["generate_template_get_node"], env["godot_cpp_gen_dir"])
-    return None
+        print(str(register_types_filename.as_posix()), end=end)
+        print(str(init_method_bindings_filename.as_posix()), end=end)
 
 
 def generate_bindings(api_filepath, use_template_get_node, output_dir="."):
@@ -66,12 +48,25 @@ def generate_bindings(api_filepath, use_template_get_node, output_dir="."):
     include_gen_folder = Path(output_dir) / "include" / "gen"
     source_gen_folder = Path(output_dir) / "src" / "gen"
 
-    include_gen_folder.mkdir(parents=True, exist_ok=True)
-    source_gen_folder.mkdir(parents=True, exist_ok=True)
+    try:
+        include_gen_folder.mkdir(parents=True)
+    except os.error as e:
+        if e.errno == errno.EEXIST:
+            print(str(source_gen_folder) + ": " + os.strerror(e.errno))
+        else:
+            exit(1)
+
+    try:
+        source_gen_folder.mkdir(parents=True)
+    except os.error as e:
+        if e.errno == errno.EEXIST:
+            print(str(source_gen_folder) + ": " + os.strerror(e.errno))
+        else:
+            exit(1)
 
     for c in classes:
         # print(c['name'])
-        used_classes = sorted(get_used_classes(c))
+        used_classes = get_used_classes(c)
         if use_template_get_node and c["name"] == "Node":
             correct_method_name(c["methods"])
 

misc/scripts/check_get_file_list.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-
-import os, sys
-
-from pathlib import Path
-
-sys.path.insert(1, os.path.join(os.path.dirname(__file__), "..", ".."))
-
-from binding_generator import get_file_list, generate_bindings
-
-api_filepath = "godot-headers/api.json"
-bits = "64"
-double = "float"
-output_dir = "self_test"
-
-generate_bindings(api_filepath, use_template_get_node=False, output_dir=output_dir)
-flist = get_file_list(api_filepath, output_dir, headers=True, sources=True)
-
-p = Path(output_dir)
-allfiles = [str(f.as_posix()) for f in p.glob("**/*.*")]
-missing = list(filter((lambda f: f not in flist), allfiles))
-extras = list(filter((lambda f: f not in allfiles), flist))
-if len(missing) > 0 or len(extras) > 0:
-    print("Error!")
-    for f in missing:
-        print("MISSING: " + str(f))
-    for f in extras:
-        print("EXTRA: " + str(f))
-    sys.exit(1)
-else:
-    print("OK!")

src/core/Rect2.cpp

@@ -46,35 +46,25 @@ namespace godot {
 #endif
 
 real_t Rect2::distance_to(const Vector2 &p_point) const {
-	real_t dist = 0.0;
-	bool inside = true;
+	real_t dist = 1e20;
 
 	if (p_point.x < position.x) {
-		real_t d = position.x - p_point.x;
-		dist = d;
-		inside = false;
+		dist = MIN(dist, position.x - p_point.x);
 	}
 	if (p_point.y < position.y) {
-		real_t d = position.y - p_point.y;
-		dist = inside ? d : MIN(dist, d);
-		inside = false;
+		dist = MIN(dist, position.y - p_point.y);
 	}
 	if (p_point.x >= (position.x + size.x)) {
-		real_t d = p_point.x - (position.x + size.x);
-		dist = inside ? d : MIN(dist, d);
-		inside = false;
+		dist = MIN(p_point.x - (position.x + size.x), dist);
 	}
 	if (p_point.y >= (position.y + size.y)) {
-		real_t d = p_point.y - (position.y + size.y);
-		dist = inside ? d : MIN(dist, d);
-		inside = false;
+		dist = MIN(p_point.y - (position.y + size.y), dist);
 	}
 
-	if (inside) {
+	if (dist == 1e20)
 		return 0;
-	} else {
+	else
 		return dist;
-	}
 }
 
 Rect2 Rect2::clip(const Rect2 &p_rect) const { /// return a clipped rect

test/SConstruct

@@ -1,16 +1,141 @@
 #!/usr/bin/env python
+import os
+import sys
 
-env = SConscript("../SConstruct")
+# Try to detect the host platform automatically.
+# This is used if no `platform` argument is passed
+if sys.platform.startswith("linux"):
+    host_platform = "linux"
+elif sys.platform == "darwin":
+    host_platform = "osx"
+elif sys.platform == "win32" or sys.platform == "msys":
+    host_platform = "windows"
+else:
+    raise ValueError("Could not detect platform automatically, please specify with platform=<platform>")
+
+env = Environment(ENV=os.environ)
+
+opts = Variables([], ARGUMENTS)
+
+# Define our options
+opts.Add(EnumVariable("target", "Compilation target", "debug", ["d", "debug", "r", "release"]))
+opts.Add(EnumVariable("platform", "Compilation platform", host_platform, ["", "windows", "x11", "linux", "osx"]))
+opts.Add(
+    EnumVariable("p", "Compilation target, alias for 'platform'", host_platform, ["", "windows", "x11", "linux", "osx"])
+)
+opts.Add(EnumVariable("bits", "Target platform bits", "64", ("32", "64")))
+opts.Add(BoolVariable("use_llvm", "Use the LLVM / Clang compiler", "no"))
+opts.Add(PathVariable("target_path", "The path where the lib is installed.", "bin/", PathVariable.PathAccept))
+opts.Add(PathVariable("target_name", "The library name.", "libgdexample", PathVariable.PathAccept))
+
+# Local dependency paths, adapt them to your setup
+godot_headers_path = "../godot-headers/"
+cpp_bindings_path = "../"
+cpp_library = "libgodot-cpp"
+
+# only support 64 at this time..
+bits = 64
+
+# Updates the environment with the option variables.
+opts.Update(env)
+# Generates help for the -h scons option.
+Help(opts.GenerateHelpText(env))
+
+# This makes sure to keep the session environment variables on Windows.
+# This way, you can run SCons in a Visual Studio 2017 prompt and it will find
+# all the required tools
+if host_platform == "windows" and env["platform"] != "android":
+    if env["bits"] == "64":
+        env = Environment(TARGET_ARCH="amd64")
+    elif env["bits"] == "32":
+        env = Environment(TARGET_ARCH="x86")
+
+    opts.Update(env)
+
+# Process some arguments
+if env["use_llvm"]:
+    env["CC"] = "clang"
+    env["CXX"] = "clang++"
+
+if env["p"] != "":
+    env["platform"] = env["p"]
+
+if env["platform"] == "":
+    print("No valid target platform selected.")
+    quit()
+
+# For the reference:
+# - CCFLAGS are compilation flags shared between C and C++
+# - CFLAGS are for C-specific compilation flags
+# - CXXFLAGS are for C++-specific compilation flags
+# - CPPFLAGS are for pre-processor flags
+# - CPPDEFINES are for pre-processor defines
+# - LINKFLAGS are for linking flags
+
+# Check our platform specifics
+if env["platform"] == "osx":
+    env["target_path"] += "osx/"
+    cpp_library += ".osx"
+    env.Append(CCFLAGS=["-arch", "x86_64"])
+    env.Append(CXXFLAGS=["-std=c++17"])
+    env.Append(LINKFLAGS=["-arch", "x86_64"])
+    if env["target"] in ("debug", "d"):
+        env.Append(CCFLAGS=["-g", "-O2"])
+    else:
+        env.Append(CCFLAGS=["-g", "-O3"])
+
+elif env["platform"] in ("x11", "linux"):
+    env["target_path"] += "x11/"
+    cpp_library += ".linux"
+    env.Append(CCFLAGS=["-fPIC"])
+    env.Append(CXXFLAGS=["-std=c++17"])
+    if env["target"] in ("debug", "d"):
+        env.Append(CCFLAGS=["-g3", "-Og"])
+    else:
+        env.Append(CCFLAGS=["-g", "-O3"])
+
+elif env["platform"] == "windows":
+    env["target_path"] += "win64/"
+    cpp_library += ".windows"
+    # This makes sure to keep the session environment variables on windows,
+    # that way you can run scons in a vs 2017 prompt and it will find all the required tools
+    env.Append(ENV=os.environ)
+
+    env.Append(CPPDEFINES=["WIN32", "_WIN32", "_WINDOWS", "_CRT_SECURE_NO_WARNINGS"])
+    env.Append(CCFLAGS=["-W3", "-GR"])
+    env.Append(CXXFLAGS=["-std:c++17"])
+    if env["target"] in ("debug", "d"):
+        env.Append(CPPDEFINES=["_DEBUG"])
+        env.Append(CCFLAGS=["-EHsc", "-MDd", "-ZI"])
+        env.Append(LINKFLAGS=["-DEBUG"])
+    else:
+        env.Append(CPPDEFINES=["NDEBUG"])
+        env.Append(CCFLAGS=["-O2", "-EHsc", "-MD"])
+
+if env["target"] in ("debug", "d"):
+    cpp_library += ".debug"
+else:
+    cpp_library += ".release"
+
+cpp_library += "." + str(bits)
+
+# make sure our binding library is properly includes
+env.Append(
+    CPPPATH=[
+        ".",
+        godot_headers_path,
+        cpp_bindings_path + "include/",
+        cpp_bindings_path + "include/core/",
+        cpp_bindings_path + "include/gen/",
+    ]
+)
+env.Append(LIBPATH=[cpp_bindings_path + "bin/"])
+env.Append(LIBS=[cpp_library])
 
 # tweak this if you want to use different folders, or more folders, to store your source code in.
-env.Append(CPPPATH=['src/'])
-sources = Glob('src/*.cpp')
+env.Append(CPPPATH=["src/"])
+sources = Glob("src/*.cpp")
 
-library = env.SharedLibrary(
-    "bin/libgdexample.{}.{}.{}{}".format(
-        env["platform"], env["target"], env["arch_suffix"], env["SHLIBSUFFIX"]
-    ),
-    source=sources,
-)
+library = env.SharedLibrary(target=env["target_path"] + env["target_name"], source=sources)
 
 Default(library)

test/gdexample.gdnlib

@@ -7,10 +7,10 @@ reloadable=false
 
 [entry]
 
-X11.64="res://bin/libgdexample.linux.release.64.so"
-Server.64="res://bin/libgdexample.linux.release.64.so"
-Windows.64="res://bin/libgdexample.windows.release.64.dll"
-OSX.64="res://bin/libgdexample.osx.release.64.dylib"
+X11.64="res://bin/x11/libgdexample.so"
+Server.64="res://bin/x11/libgdexample.so"
+Windows.64="res://bin/win64/libgdexample.dll"
+OSX.64="res://bin/osx/libgdexample.dylib"
 
 [dependencies]