CI: Fix MinGW install error by pinning to earlier version

Works around https://github.com/egor-tensin/setup-mingw/issues/14.

(cherry picked from commit 0369f6fea0)

.clang-format

@@ -13,9 +13,9 @@ AlignAfterOpenBracket: DontAlign
 AlignTrailingComments: false
 AllowAllParametersOfDeclarationOnNextLine: false
 # AllowShortBlocksOnASingleLine: false
-AllowShortCaseLabelsOnASingleLine: true
+# AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: true
+# AllowShortIfStatementsOnASingleLine: false
 # AllowShortLoopsOnASingleLine: false
 # AlwaysBreakAfterDefinitionReturnType: None
 # AlwaysBreakAfterReturnType: None
@@ -76,7 +76,7 @@ IndentWidth:     4
 # IndentWrappedFunctionNames: false
 # JavaScriptQuotes: Leave
 # JavaScriptWrapImports: true
-# KeepEmptyLinesAtTheStartOfBlocks: true
+KeepEmptyLinesAtTheStartOfBlocks: false
 # MacroBlockBegin: ''
 # MacroBlockEnd:   ''
 # MaxEmptyLinesToKeep: 1
@@ -112,10 +112,11 @@ UseTab:          Always
 ---
 ### C++ specific config ###
 Language:        Cpp
-Standard:        Cpp03
+Standard:        Cpp11
 ---
 ### ObjC specific config ###
 Language:        ObjC
+Standard:        Cpp11
 ObjCBlockIndentWidth: 4
 # ObjCSpaceAfterProperty: false
 # ObjCSpaceBeforeProtocolList: true
@@ -123,4 +124,5 @@ ObjCBlockIndentWidth: 4
 ### Java specific config ###
 Language:        Java
 # BreakAfterJavaFieldAnnotations: false
+JavaImportGroups: ['org.godotengine', 'android', 'androidx', 'com.android', 'com.google', 'java', 'javax']
 ...

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

.github/workflows/ci.yml

@@ -0,0 +1,131 @@
+name: Continuous integration
+on: [push, pull_request]
+
+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
+
+          - 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
+
+          - 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
+
+          - 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
+
+          - 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
+
+          - name: 🍏 iOS (arm64)
+            os: macos-13
+            platform: ios
+            artifact-name: godot-cpp-ios-arm64-release
+            artifact-path: bin/libgodot-cpp.ios.release.arm64.a
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python (for SCons)
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+
+      - name: Linux dependencies
+        if: ${{ matrix.platform == 'linux' }}
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -qqq build-essential pkg-config
+
+      - name: Install scons
+        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)
+        run: |
+          scons platform=${{ matrix.platform }} target=debug generate_bindings=yes ${{ 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
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.artifact-name }}
+          path: ${{ matrix.artifact-path }}
+          if-no-files-found: error
+
+  static-checks:
+    name: 📊 Static Checks (clang-format)
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Make apt sources.list use the default Ubuntu repositories
+        run: |
+          sudo rm -f /etc/apt/sources.list.d/*
+          sudo cp -f misc/ci/sources.list /etc/apt/sources.list
+          sudo apt-get update
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get install -qq dos2unix recode clang-format-11
+          sudo update-alternatives --remove-all clang-format
+          sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-11 100
+
+      - name: Style checks via clang-format
+        run: |
+          bash ./misc/scripts/clang_format.sh

.gitignore

@@ -1,11 +1,14 @@
 # Misc
+gen/*
 logs/*
+*.log
 
 # Binaries
 *.o
 *.os
 *.so
 *.obj
+*.bc
 *.pyc
 *.dblite
 *.pdb
@@ -16,3 +19,159 @@ bin
 *.creator.user
 *.files
 *.includes
+
+# Gprof output
+gmon.out
+
+# Vim temp files
+*.swo
+*.swp
+
+# Qt project files
+*.config
+*.creator
+*.creator.*
+*.files
+*.includes
+*.cflags
+*.cxxflags
+
+# Eclipse CDT files
+.cproject
+.settings/
+
+# Geany/geany-plugins files
+*.geany
+.geanyprj
+
+# Misc
+.DS_Store
+logs/
+
+# for projects that use SCons for building: http://http://www.scons.org/
+.sconf_temp
+.sconsign.dblite
+*.pyc
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.opendb
+*.VC.VC.opendb
+enc_temp_folder/
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+
+# CodeLite project files
+*.project
+*.workspace
+.codelite/
+
+# Windows Azure Build Output
+csx/
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Others
+sql/
+*.Cache
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+__pycache__/
+
+# KDE
+.directory
+
+#Kdevelop project files
+*.kdev4
+
+# xCode
+xcuserdata
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file to a newer
+# Visual Studio version. Backup files are not needed, because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+App_Data/*.mdf
+App_Data/*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# =========================
+# Windows detritus
+# =========================
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+logo.h
+*.autosave
+
+# https://github.com/github/gitignore/blob/master/Global/Tags.gitignore
+# Ignore tags created by etags, ctags, gtags (GNU global) and cscope
+TAGS
+!TAGS/
+tags
+*.tags
+!tags/
+gtags.files
+GTAGS
+GRTAGS
+GPATH
+cscope.files
+cscope.out
+cscope.in.out
+cscope.po.out
+godot.creator.*
+
+# Visual Studio 2017 and Visual Studio Code workspace folder
+/.vs
+/.vscode
+
+# Visual Studio Code workspace file
+*.code-workspace
+
+# Scons progress indicator
+.scons_node_count
+
+# ccls cache (https://github.com/MaskRay/ccls)
+.ccls-cache/
+
+# compile commands (https://clang.llvm.org/docs/JSONCompilationDatabase.html)
+compile_commands.json

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "godot_headers"]
-	path = godot_headers
-	url = https://github.com/GodotNativeTools/godot_headers
+[submodule "godot-headers"]
+	path = godot-headers
+	url = https://github.com/godotengine/godot-headers

.travis.yml

@@ -1,76 +0,0 @@
-language: cpp
-dist: xenial
-osx_image: xcode10.1
-
-env:
-  global:
-    - SCONS_CACHE="$HOME/.scons_cache"
-    - SCONS_CACHE_LIMIT=1024
-
-cache:
-  directories:
-    - $SCONS_CACHE
-
-matrix:
-  include:
-    - name: Linux Debug + Static Checks
-      os: linux
-      compiler: gcc
-      env: TARGET=debug STATIC_CHECKS=yes
-      addons:
-        apt:
-          sources:
-            - llvm-toolchain-xenial-6.0
-          packages:
-            [scons, pkg-config, build-essential, p7zip-full, clang-format-6.0]
-
-    - name: Linux Release
-      os: linux
-      compiler: gcc
-      addons:
-        apt:
-          packages:
-            [scons, pkg-config, build-essential, p7zip-full]
-      env: TARGET=release
-
-    - name: macOS Debug
-      os: osx
-      compiler: clang
-      env: TARGET=debug
-
-    - name: macOS Release
-      os: osx
-      compiler: clang
-      env: TARGET=release
-
-    - name: Windows MSVC Debug
-      os: windows
-      env: TARGET=debug
-
-    - name: Windows MSVC Release
-      os: windows
-      env: TARGET=release
-
-install:
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      brew update;
-      brew install scons p7zip;
-    fi
-
-  - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then
-      curl -LO https://downloads.sourceforge.net/project/scons/scons-local/3.0.5/scons-local-3.0.5.zip;
-      unzip scons-local-3.0.5.zip;
-    fi
-
-script:
-  - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then
-      export SCONS="./scons.bat";
-    else
-      export SCONS="scons";
-    fi
-
-  - $SCONS target="$TARGET" bits=64 generate_bindings=yes $SCONS_FLAGS;
-
-  - if [[ "$STATIC_CHECKS" == "yes" ]]; then
-      sh ./misc/travis/clang-format.sh;
-    fi

CMakeLists.txt

@@ -1,44 +1,46 @@
 # 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.
 
 project(godot-cpp)
 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_SOURCE_DIR}/bin)
+set(BUILD_PATH ${CMAKE_CURRENT_SOURCE_DIR}/bin)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${BUILD_PATH}")
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${BUILD_PATH}")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${BUILD_PATH}")
@@ -50,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()
 
@@ -65,9 +67,16 @@ 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 "")
+set(GODOT_HEADERS_DIR "godot-headers" CACHE STRING "")
+set(GODOT_CUSTOM_API_FILE "godot-headers/api.json" CACHE STRING "")
 
 set(GODOT_COMPILE_FLAGS )
 set(GODOT_LINKER_FLAGS )
@@ -95,21 +104,17 @@ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 	#	string(REGEX REPLACE "/W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 	#endif()
 
-else()
-
-#elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-	# using Clang
-#elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	# using GCC and maybe MinGW?
-
+else()  # GCC/Clang
 	set(GODOT_LINKER_FLAGS "-static-libgcc -static-libstdc++ -Wl,-R,'$$ORIGIN'")
 
-	# Hmm.. maybe to strikt?
-	set(GODOT_COMPILE_FLAGS "-fPIC -g -Wwrite-strings")
+	if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
+		set(GODOT_COMPILE_FLAGS "-fPIC")
+	endif()
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -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")
-	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wlong-long -Wmissing-braces -Wmissing-format-attribute")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wmissing-braces -Wmissing-format-attribute")
 	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wmissing-include-dirs -Wmissing-noreturn -Wpacked -Wpointer-arith")
 	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wredundant-decls -Wreturn-type -Wsequence-point")
 	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wswitch -Wswitch-enum -Wtrigraphs")
@@ -131,24 +136,53 @@ else()
 endif()
 
 # Generate source from the bindings file
+find_package(Python3 3.4 REQUIRED) # pathlib should be present
+if(GENERATE_TEMPLATE_GET_NODE)
+	set(GENERATE_BINDING_PARAMETERS "True")
+else()
+	set(GENERATE_BINDING_PARAMETERS "False")
+endif()
+
 message(STATUS "Generating Bindings")
-execute_process(COMMAND "python" "-c" "import binding_generator; binding_generator.generate_bindings(\"${GODOT_CUSTOM_API_FILE}\")"
+execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "import binding_generator; binding_generator.print_file_list(\"${GODOT_CUSTOM_API_FILE}\", \"${CMAKE_CURRENT_BINARY_DIR}\", headers=True)"
 	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-	RESULT_VARIABLE GENERATION_RESULT
-	OUTPUT_VARIABLE GENERATION_OUTPUT)
-message(STATUS ${GENERATION_RESULT} ${GENERATION_OUTPUT})
+	RESULT_VARIABLE HEADERS_FILE_LIST_RESULT
+	OUTPUT_VARIABLE HEADERS_FILE_LIST
+)
+set(HEADERS_FILE_LIST ${HEADERS_FILE_LIST})
+
+execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "import binding_generator; binding_generator.print_file_list(\"${GODOT_CUSTOM_API_FILE}\", \"${CMAKE_CURRENT_BINARY_DIR}\", sources=True)"
+	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+	RESULT_VARIABLE SOURCES_FILE_LIST_RESULT
+	OUTPUT_VARIABLE SOURCES_FILE_LIST
+)
+set(SOURCES_FILE_LIST ${SOURCES_FILE_LIST})
+
+add_custom_command(OUTPUT ${HEADERS_FILE_LIST} ${SOURCES_FILE_LIST}
+		COMMAND "${Python3_EXECUTABLE}" "-c" "import binding_generator; binding_generator.generate_bindings(\"${GODOT_CUSTOM_API_FILE}\", \"${GENERATE_BINDING_PARAMETERS}\", \"${CMAKE_CURRENT_BINARY_DIR}\")"
+		VERBATIM
+		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+		MAIN_DEPENDENCY ${GODOT_CUSTOM_API_FILE}
+		DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/binding_generator.py
+		COMMENT Generating Bindings
+)
 
 # Get Sources
 file(GLOB_RECURSE SOURCES src/*.c**)
 file(GLOB_RECURSE HEADERS include/*.h**)
 
 # Define our godot-cpp library
-add_library(${PROJECT_NAME} ${SOURCES} ${HEADERS})
+add_library(${PROJECT_NAME}
+		${SOURCES}
+		${SOURCES_FILE_LIST}
+		${HEADERS}
+		${HEADERS_FILE_LIST}
+)
 target_include_directories(${PROJECT_NAME}
 	PUBLIC
 	include
 	include/core
-	include/gen
+	${CMAKE_CURRENT_BINARY_DIR}/include/gen/
 )
 
 # Put godot headers as SYSTEM PUBLIC to exclude warnings from irrelevant headers
@@ -163,13 +197,8 @@ 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)
+string(TOLOWER "${CMAKE_SYSTEM_NAME}" SYSTEM_NAME)
+string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE)
 
 if(ANDROID)
 	# Added the android abi after system name

LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2017-2020 GodotNativeTools
+Copyright (c) 2017-2022 Godot Engine contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

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

README.md

@@ -1,25 +1,44 @@
 # godot-cpp
-C++ bindings for the Godot script API
 
-The instructions below feature the new NativeScript 1.1 class structure and will only work for modules created for Godot 3.1 and later. Use the following branches for older implementations:
+This repository contains the  *C++ bindings* for the [**Godot Engine**](https://github.com/godotengine/godot)'s GDNative API.
 
-Version | Branch
---- | ---
-**Godot 3.0 Nativescript 1.0** | [3.0](https://github.com/GodotNativeTools/godot-cpp/tree/3.0)
-**Godot 3.1 Nativescript 1.0** | [nativescript-1.0](https://github.com/GodotNativeTools/godot-cpp/tree/nativescript-1.0)
+- [**Versioning**](#versioning)
+- [**Contributing**](#contributing)
+- [**Getting Started**](#getting-started)
+- [**Creating a simple class**](#creating-a-simple-class)
 
-Index:
--   [**Contributing**](#contributing)
--   [**Getting Started**](#getting-started)
--   [**Creating a simple class**](#creating-a-simple-class)
+## Versioning
+
+This repositories follows the same branch versioning as the main [Godot Engine
+repository](https://github.com/godotengine/godot):
+
+- `master` tracks the current development branch.
+- `3.x` tracks the development of the next 3.x minor release.
+- Other versioned branches (e.g. `3.3`, `3.2`) track the latest stable release
+  in the corresponding branch.
+
+Stable releases are also tagged on this repository:
+[**Tags**](https://github.com/godotengine/godot-cpp/tags).
+
+**For any project built against a stable release of Godot, we recommend using
+this repository as a Git submodule, checking out the specific tag matching your
+Godot version.**
+
+> As the `master` and `3.x` branches are constantly getting updates, if you are
+> using `godot-cpp` against a more current version of Godot, see the instructions
+> in [**godot-headers**](https://github.com/godotengine/godot-headers) for
+> updating the relevant files.
 
 ## Contributing
-We greatly appreciate help in maintaining and extending this project. 
-If you wish to help out ensure you have an account on Github and create a "fork" of the this repo.
-Rémi "Akien" Verschelde wrote an excellent bit of documentation for the main Godot project on this: 
-https://docs.godotengine.org/en/3.0/community/contributing/pr_workflow.html
 
-It is advisible to also install clang-format and copy the files in `misc/hooks` into `.git/hooks` so format checking is done before your changes are submitted.
+We greatly appreciate help in maintaining and extending this project. If you
+wish to help out, ensure you have an account on GitHub and create a "fork" of
+this repository. Rémi "Akien" Verschelde wrote an excellent bit of documentation
+for the main Godot project on this:
+[Pull request workflow](https://docs.godotengine.org/en/stable/community/contributing/pr_workflow.html)
+
+Please install clang-format and copy the files in `misc/hooks` into `.git/hooks`
+so formatting is done before your changes are submitted.
 
 ## Getting Started
 
@@ -28,76 +47,114 @@ It is advisible to also install clang-format and copy the files in `misc/hooks`
 
 ### Setting up a new project
 
-We recommend using git for managing your project and the instructions below assume so. Alternatively you can download the source code directly from GitHub in which case you need to download both [godot-cpp](https://github.com/GodotNativeTools/godot-cpp) and [godot_headers](https://github.com/GodotNativeTools/godot_headers).
+We recommend using Git for managing your project. The instructions below assume
+you're using Git. Alternatively, you can download the source code directly from
+GitHub. In this case, you need to download both
+[godot-cpp](https://github.com/godotengine/godot-cpp) and
+[godot-headers](https://github.com/godotengine/godot-headers).
 
-```
-$ mkdir SimpleLibrary
-$ cd SimpleLibrary
-$ mkdir bin
-$ mkdir src
-$ git clone --recursive https://github.com/GodotNativeTools/godot-cpp
+```bash
+mkdir SimpleLibrary
+cd SimpleLibrary
+mkdir bin
+mkdir src
+git clone --recursive https://github.com/godotengine/godot-cpp
 ```
 
-Note that if you wish to use a specific branch, add the -b option to the clone command:
-```
-$ git clone --recursive https://github.com/GodotNativeTools/godot-cpp -b 3.0
+If you wish to use a specific branch, add the -b option to the clone command:
+
+```bash
+git clone --recursive https://github.com/godotengine/godot-cpp -b 3.0
 ```
 
-If your project is an existing repository, use git submodule instead:
-```
-$ git submodule add https://github.com/GodotNativeTools/godot-cpp
-$ git submodule update --init --recursive
+If your project is an existing repository, use a Git submodule instead:
+
+```bash
+git submodule add https://github.com/godotengine/godot-cpp
+git submodule update --init --recursive
 ```
 
-Right now our directory structure should look like this:
-```
+Right now, our directory structure should look like this:
+
+```text
 SimpleLibrary/
 ├─godot-cpp/
-| └─godot_headers/
+| └─godot-headers/
 ├─bin/
 └─src/
 ```
 
-### Updating the api.json
-Our api.json file contains meta data of all the classes that are part of the Godot core and are needed to generate the C++ binding classes for use in GDNative modules. 
+### Updating the `api.json` file
 
-This file is supplied with our godot_headers repository for your convinience but if you are running a custom build of Godot and need access to classes that have recent changes a new api.json file must be generated. You do this by starting your Godot executable with the following parameters:
+Our `api.json` file contains metadata for all the classes that are part of the
+Godot core. This metadata is required to generate the C++ binding classes for
+use in GDNative modules.
 
-```
-$ godot --gdnative-generate-json-api api.json
+This file is supplied with our
+[godot-headers](https://github.com/godotengine/godot-headers) repository
+for your convenience. However, if you're running a custom build of Godot and
+need access to classes that have recent changes, you must generate a new
+`api.json` file. You do this by starting your Godot executable with the
+following parameters:
+
+```bash
+godot --gdnative-generate-json-api api.json
 ```
 
-Now copy the api.json file into your folder structure so its easy to access. **Note** the remark below for the extra ```custom_api_file``` command line parameter needed to tell scons where to find your file.
+Now copy the `api.json` file into your folder structure to make it easier to
+access.
 
-### Compiling the cpp bindings library
-The final step is to compile our cpp bindings library:
+See the remark below for the extra ```custom_api_file``` SCons argument, which
+is required to tell SCons where to find your file.
+
+### Compiling the C++ bindings library
+
+The final step is to compile our C++ bindings library:
+
+```bash
+cd godot-cpp
+scons platform=<your platform> generate_bindings=yes
+cd ..
 ```
-$ cd godot-cpp
-$ scons platform=<your platform> generate_bindings=yes
-$ cd ..
+
+Replace `<your platform>` with either `windows`, `linux`, `osx` or `android`. If
+you leave out `platform`, the target platform will automatically be detected
+from the host platform.
+
+The resulting library will be created in `godot-cpp/bin/`, take note of its name
+as it'll differ depending on the target platform.
+
+#### Compiling for Android
+
+Download the latest [Android NDK](https://developer.android.com/ndk/downloads)
+and set the NDK path.
+
+```bash
+scons platform=android generate_bindings=yes ANDROID_NDK_ROOT="/PATH-TO-ANDROID-NDK/" android_arch=<arch>
 ```
-For android:
-Download the latest [Android NDK](https://developer.android.com/ndk/downloads) from the official website and set NDK path.
-```
-$ scons platform=android generate_bindings=yes ANDROID_NDK_ROOT="/PATH-TO-ANDROID-NDK/" android_arch=<  >
-```
-`android_arch` can be `armv7, arm64v8, x86, x86_64`.
-`ANDROID_NDK_ROOT` can also be set in the environment variables of your computer if you do not want to include it in your Scons call.
 
+The value of `android_arch` can be `armv7, arm64v8, x86, x86_64`. Most Android
+devices in use nowadays use an ARM architecture, so compiling for `armv7` and
+`arm64v8` is often enough when distributing an application.
 
-> Replace `<your platform>` with either `windows`, `linux`, `osx` or `android`.
+`ANDROID_NDK_ROOT` can also be set in the environment variables of your PC if
+you don't want to include it in your SCons call.
 
-> Include `use_llvm=yes` for using clang++
+#### Compilation options
 
-> Include `target=runtime` to build a runtime build (windows only at the moment)
+You can optionally add the following options to the SCons command line:
 
-> The resulting library will be created in `godot-cpp/bin/`, take note of its name as it will be different depending on platform.
-
-> If you want to use an alternative api.json file add `use_custom_api_file=yes custom_api_file=../api.json`, be sure to specify the correct location of where you placed your file.
+- When targeting Linux, add `use_llvm=yes` to use Clang instead of GCC.
+- When targeting Windows, add `use_mingw=yes` to use MinGW instead of MSVC.
+- When targeting Windows, include `target=runtime` to build a runtime build.
+- To use an alternative `api.json` file, add `use_custom_api_file=yes
+  custom_api_file=../api.json`. Be sure to specify the correct location where
+  you placed your file (it can be a relative or absolute path).
 
 ## Creating a simple class
 
-Create `init.cpp` under `SimpleLibrary/src/` and add the following code
+Create `init.cpp` under `SimpleLibrary/src/` and add the following code:
+
 ```cpp
 #include <Godot.hpp>
 #include <Reference.hpp>
@@ -109,7 +166,7 @@ class SimpleClass : public Reference {
 public:
     SimpleClass() { }
 
-    /* _init must exist as it is called by Godot */
+    /** `_init` must exist as it is called by Godot. */
     void _init() { }
 
     void test_void_method() {
@@ -125,21 +182,21 @@ public:
 
     static void _register_methods() {
         register_method("method", &SimpleClass::method);
-        
+
         /**
-         * How to register exports like gdscript
-         * export var _name = "SimpleClass"
+         * The line below is equivalent to the following GDScript export:
+         *     export var _name = "SimpleClass"
          **/
         register_property<SimpleClass, String>("base/name", &SimpleClass::_name, String("SimpleClass"));
 
-        /* or alternatively with getter and setter methods */
+        /** Alternatively, with getter and setter methods: */
         register_property<SimpleClass, int>("base/value", &SimpleClass::set_value, &SimpleClass::get_value, 0);
 
-        /** For registering signal **/
+        /** Registering a signal: **/
         // register_signal<SimpleClass>("signal_name");
         // register_signal<SimpleClass>("signal_name", "string_argument", GODOT_VARIANT_TYPE_STRING)
     }
-    
+
     String _name;
     int _value;
 
@@ -170,52 +227,146 @@ extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
 }
 ```
 
-### Compiling
+### Compiling the GDNative library
 
-*Linux*
+Once you've compiled the GDNative C++ bindings (see above), you can compile the GDNative library we've just created.
+
+#### Linux
+
+```bash
+cd SimpleLibrary
+clang++ -fPIC -o src/init.o -c src/init.cpp -g -O3 -std=c++14 -Igodot-cpp/include -Igodot-cpp/include/core -Igodot-cpp/include/gen -Igodot-cpp/godot-headers
+clang++ -o bin/libtest.so -shared src/init.o -Lgodot-cpp/bin -l<name of the godot-cpp>
 ```
-$ cd SimpleLibrary
-$ clang -fPIC -o src/init.os -c src/init.cpp -g -O3 -std=c++14 -Igodot-cpp/include -Igodot-cpp/include/core -Igodot-cpp/include/gen -Igodot-cpp/godot_headers
-$ clang -o bin/libtest.so -shared src/init.os -Lgodot-cpp/bin -l<name of the godot-cpp>
+
+You'll need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library).
+
+This creates the file `libtest.so` in your `SimpleLibrary/bin` directory.
+
+#### Windows
+
+```bash
+cd SimpleLibrary
+cl /Fosrc/init.obj /c src/init.cpp /nologo -EHsc -DNDEBUG /MDd /Igodot-cpp\include /Igodot-cpp\include\core /Igodot-cpp\include\gen /Igodot-cpp\godot-headers
+link /nologo /dll /out:bin\libtest.dll /implib:bin\libsimple.lib src\init.obj godot-cpp\bin\<name of the godot-cpp>
 ```
-> This creates the file `libtest.so` in your `SimpleLibrary/bin` directory.
 
-> You will need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library)
+You'll need to replace `<name of the godot-cpp>` with the file that was created
+in [**Compiling the cpp bindingslibrary**](#compiling-the-cpp-bindings-library).
+Replace `/MDd` with `/MD` to create a release build, which will run faster and
+be smaller.
 
-*Windows*
+This creates the file `libtest.dll` in your `SimpleLibrary/bin` directory.
+
+#### macOS
+
+For macOS, you'll need to find out which compiler flags need to be used. These
+are likely similar to Linux when using Clang, but may not be identical.
+
+If you find suitable compiler flags for this example library, feel free to
+submit a pull request :slightly_smiling_face:
+
+#### Android
+
+```bash
+cd SimpleLibrary
+aarch64-linux-android29-clang++ -fPIC -o src/init.o -c src/init.cpp -g -O3 -std=c++14 -Igodot-cpp/include -Igodot-cpp/include/core -Igodot-cpp/include/gen -Igodot-cpp/godot-headers
+aarch64-linux-android29-clang++ -o bin/libtest.so -shared src/init.o -Lgodot-cpp/bin -l<name of the godot-cpp>
 ```
-$ cd SimpleLibrary
-$ cl /Fosrc/init.obj /c src/init.cpp /nologo -EHsc -DNDEBUG /MDd /Igodot-cpp\include /Igodot-cpp\include\core /Igodot-cpp\include\gen /Igodot-cpp\godot_headers
-$ link /nologo /dll /out:bin\libtest.dll /implib:bin\libsimple.lib src\init.obj godot-cpp\bin\<name of the godot-cpp>
+
+You'll need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library). The command above targets `arm64v8`. To target `armv7`, use `armv7a-linux-androideabi29-clang++` instead of `aarch64-linux-android29-clang++`.
+
+This creates the file `libtest.so` in your `SimpleLibrary/bin` directory.
+
+#### iOS
+
+GDNative isn't supported on iOS yet. This is because iOS only allows linking
+static libraries, not dynamic libraries. In theory, it would be possible to link
+a GDNative library statically, but some of GDNative's convenience would be lost
+in the process as one would have to recompile the engine on every change. See
+[issue #30](https://github.com/godotengine/godot-headers/issues/30) in the
+Godot headers repository for more information.
+
+#### HTML5
+
+GDNative is supported on [specific exports](https://docs.godotengine.org/en/latest/tutorials/export/exporting_for_web.html#export-options) for the HTML5 platform since Godot `3.3`. Linking webassembly modules is currently underspecified in the standard, but [emscripten](https://emscripten.org/), which Godot uses to build the HTML5 version, implements its own linking system.
+
+To build GDNative libraries, you will need a recent version of [Emscripten](https://emscripten.org/).
+
+```bash
+cd SimpleLibrary
+emcc  -o bin/libtest.wasm -g -O3 -s SIDE_MODULE=1 src/init.cpp godot-cpp/bin/<name of the godot-cpp> -Igodot-cpp/include -Igodot-cpp/include/core -Igodot-cpp/include/gen -Igodot-cpp/godot-headers
 ```
-> This creates the file `libtest.dll` in your `SimpleLibrary/bin` directory.
 
-> You will need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library)
-
-> Finally replace `/MDd` with `/MD` if you're generated a runtime build.
-
-*macOS*
-For OSX you need to find out what compiler flags need to be used.
-
-*Android*
-```
-$ cd SimpleLibrary
-$ aarch64-linux-android29-clang -fPIC -o src/init.os -c src/init.cpp -g -O3 -std=c++14 -Igodot-cpp/include -Igodot-cpp/include/core -Igodot-cpp/include/gen -Igodot-cpp/godot_headers
-$ aarch64-linux-android29-clang -o bin/libtest.so -shared src/init.os -Lgodot-cpp/bin -l<name of the godot-cpp>
-```
-> use `armv7a-linux-androideabi29-clang` for 32 bit armeabi-v7a library
-
-> This creates the file `libtest.so` in your `SimpleLibrary/bin` directory.
-
-> You will need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library)
+You'll need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library).
 
+This creates the file `libtest.so` in your `SimpleLibrary/bin` directory.
 
 ### Creating `.gdnlib` and `.gdns` files
-follow [godot_header/README.md](https://github.com/GodotNativeTools/godot_headers/blob/master/README.md#how-do-i-use-native-scripts-from-the-editor) to create the `.gdns` 
 
-### Implementing with gdscript
+Follow the instructions in
+[godot-headers/README.md](https://github.com/godotengine/godot-headers/blob/master/README.md#how-do-i-use-native-scripts-from-the-editor)
+to create the `.gdns` file. This file contains paths to GDNative libraries for
+various platforms. This makes the library usable from Godot in a
+platform-independent manner.
+
+### Implementing with GDScript
+
+Once your GDNative library is compiled and referenced in a `.gdns` file, you can use it in GDScript or C#. Here's an example with GDScript:
+
 ```gdscript
-var simpleclass = load("res://simpleclass.gdns").new();
-simpleclass.method("Test argument");
+var simpleclass = load("res://simpleclass.gdns").new()
+simpleclass.method("Test argument")
 ```
 
+### Using Godot classes in C++
+
+Godot expects you to manage its classes the same way the engine does. These rules apply to all Godot classes, including your NativeScripts, but not to any normal C++ classes used in your library.
+
+- Instantiate Objects using `_new()`, not C++'s `new` operator.
+
+```cpp
+Sprite *sprite = Sprite::_new();
+```
+
+- Destroy Nodes using `queue_free()`, not C++'s `delete` operator.
+
+```cpp
+some_old_node->queue_free();
+```
+
+- Wrap References in `Ref` instead of passing around raw pointers. They are reference-counted and don't need to be freed manually.
+
+```cpp
+Ref<Texture> texture = resource_loader->load("res://icon.png");
+```
+
+- Pass core types that do *not* inherit Object by value. The containers (Array, Dictionary, PoolArray, String) manage their own memory and do not need to be explicitly initialized or freed.
+
+```cpp
+Array ints;
+ints.append(123);
+return ints;
+```
+
+- Initialize your NativeScript classes in their `_init()` method, not their constructor. The constructor can't access the base class's methods.
+
+- Cast objects using `Object::cast_to`, not unsafe C-style casts or `static_cast`.
+
+```cpp
+MeshInstance *m = Object::cast_to<MeshInstance>(get_node("ChildNode"));
+// `m` will be null if it's not a MeshInstance
+if (m) { ... }
+```
+
+- **Never** use Godot types in static or global variables. The Godot API isn't loaded until after their constructors are called.
+
+```cpp
+String s; // crashes
+class SomeClass {
+    static Dictionary d; // crashes
+
+    static Node *node_a = NULL; // fine, it's just a pointer
+    static Node *node_b = Node::_new(); // crashes
+};
+```

SConstruct

@@ -5,24 +5,35 @@ import sys
 import subprocess
 
 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:
 # http://www.scons.org/wiki/LongCmdLinesOnWin32
-if (os.name=="nt"):
+if os.name == "nt":
     import subprocess
 
-    def mySubProcess(cmdline,env):
-        #print "SPAWNED : " + cmdline
+    def mySubProcess(cmdline, env):
+        # print "SPAWNED : " + cmdline
         startupinfo = subprocess.STARTUPINFO()
         startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-        proc = subprocess.Popen(cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE, startupinfo=startupinfo, shell = False, env = env)
+        proc = subprocess.Popen(
+            cmdline,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            startupinfo=startupinfo,
+            shell=False,
+            env=env,
+        )
         data, err = proc.communicate()
         rv = proc.wait()
         if rv:
@@ -33,354 +44,493 @@ if (os.name=="nt"):
 
     def mySpawn(sh, escape, cmd, args, env):
 
-        newargs = ' '.join(args[1:])
+        newargs = " ".join(args[1:])
         cmdline = cmd + " " + newargs
 
-        rv=0
-        if len(cmdline) > 32000 and cmd.endswith("ar") :
+        rv = 0
+        if len(cmdline) > 32000 and cmd.endswith("ar"):
             cmdline = cmd + " " + args[1] + " " + args[2] + " "
-            for i in range(3,len(args)) :
-                rv = mySubProcess( cmdline + args[i], env )
-                if rv :
+            for i in range(3, len(args)):
+                rv = mySubProcess(cmdline + args[i], env)
+                if rv:
                     break
         else:
-            rv = mySubProcess( cmdline, env )
+            rv = mySubProcess(cmdline, env)
 
         return rv
 
+
 def add_sources(sources, dir, extension):
     for f in os.listdir(dir):
-        if f.endswith('.' + extension):
-            sources.append(dir + '/' + f)
+        if f.endswith("." + extension):
+            sources.append(dir + "/" + f)
 
 
 # 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'
+if sys.platform.startswith("linux"):
+    host_platform = "linux"
+elif sys.platform.startswith("freebsd"):
+    host_platform = "freebsd"
+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>'
-    )
+    raise ValueError("Could not detect platform automatically, please specify with platform=<platform>")
 
-opts = Variables([], ARGUMENTS)
-opts.Add(EnumVariable(
-    'platform',
-    'Target platform',
-    host_platform,
-    allowed_values=('linux', 'osx', 'windows', 'android', 'ios'),
-    ignorecase=2
-))
-opts.Add(EnumVariable(
-    'bits',
-    'Target platform bits',
-    'default',
-    ('default', '32', '64')
-))
-opts.Add(BoolVariable(
-    'use_llvm',
-    'Use the LLVM compiler - only effective when targeting Linux',
-    False
-))
-opts.Add(BoolVariable(
-    'use_mingw',
-    'Use the MinGW compiler instead of MSVC - only effective on Windows',
-    False
-))
-# Must be the same setting as used for cpp_bindings
-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
-))
-opts.Add(PathVariable(
-    'custom_api_file',
-    'Path to a custom JSON API file',
-    None,
-    PathVariable.PathIsFile
-))
-opts.Add(BoolVariable(
-    'generate_bindings',
-    'Generate GDNative API bindings',
-    False
-))
-opts.Add(EnumVariable(
-    'android_arch',
-    'Target Android architecture',
-    'armv7',
-    ['armv7','arm64v8','x86','x86_64']
-))
-opts.Add(EnumVariable(
-    'ios_arch',
-    'Target iOS architecture',
-    'arm64',
-    ['armv7', 'arm64', 'x86_64']
-))
-opts.Add(
-    'IPHONEPATH',
-    'Path to iPhone toolchain',
-    '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain',
-)
-opts.Add(
-    'android_api_level',
-    'Target Android API level',
-    '18' if ARGUMENTS.get("android_arch", 'armv7') in ['armv7', 'x86'] else '21'
-)
-opts.Add(
-    'ANDROID_NDK_ROOT',
-    'Path to your Android NDK installation. By default, uses ANDROID_NDK_ROOT from your defined environment variables.',
-    os.environ.get("ANDROID_NDK_ROOT", None)
-)
+env = Environment(ENV=os.environ)
 
-env = Environment(ENV = os.environ)
-opts.Update(env)
-Help(opts.GenerateHelpText(env))
+# 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
+is64 = sys.maxsize > 2 ** 32
 if (
-    env['TARGET_ARCH'] == 'amd64' or
-    env['TARGET_ARCH'] == 'emt64' or
-    env['TARGET_ARCH'] == 'x86_64' or
-    env['TARGET_ARCH'] == 'arm64-v8a'
+    env["TARGET_ARCH"] == "amd64"
+    or env["TARGET_ARCH"] == "emt64"
+    or env["TARGET_ARCH"] == "x86_64"
+    or env["TARGET_ARCH"] == "arm64-v8a"
 ):
     is64 = True
 
-if env['bits'] == 'default':
-    env['bits'] = '64' if is64 else '32'
+opts = Variables([], ARGUMENTS)
+opts.Add(
+    EnumVariable(
+        "platform",
+        "Target platform",
+        host_platform,
+        allowed_values=("linux", "freebsd", "osx", "windows", "android", "ios", "javascript"),
+        ignorecase=2,
+    )
+)
+opts.Add(EnumVariable("bits", "Target platform bits", "64" if is64 else "32", ("32", "64")))
+opts.Add(BoolVariable("use_llvm", "Use the LLVM compiler - only effective when targeting Linux or FreeBSD", False))
+opts.Add(BoolVariable("use_mingw", "Use the MinGW compiler instead of MSVC - only effective on Windows", False))
+# Must be the same setting as used for cpp_bindings
+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,
+    )
+)
+opts.Add(PathVariable("custom_api_file", "Path to a custom JSON API file", None, PathVariable.PathIsFile))
+opts.Add(
+    EnumVariable(
+        "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"]))
+opts.Add(EnumVariable("ios_arch", "Target iOS architecture", "arm64", ["armv7", "arm64", "x86_64"]))
+opts.Add(BoolVariable("ios_simulator", "Target iOS Simulator", False))
+opts.Add(
+    "IPHONEPATH",
+    "Path to iPhone toolchain",
+    "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain",
+)
+opts.Add(
+    "android_api_level",
+    "Target Android API level",
+    "18" if ARGUMENTS.get("android_arch", "armv7") in ["armv7", "x86"] else "21",
+)
+opts.Add(
+    "ANDROID_NDK_ROOT",
+    "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.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
-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')
+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)
 
-if env['platform'] == 'linux':
-    if env['use_llvm']:
-        env['CXX'] = 'clang++'
+# 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"])
 
-    env.Append(CCFLAGS=['-fPIC', '-g', '-std=c++14', '-Wwrite-strings'])
+if env["platform"] == "linux" or env["platform"] == "freebsd":
+    if env["use_llvm"]:
+        env["CXX"] = "clang++"
+
+    env.Append(CCFLAGS=["-fPIC", "-Wwrite-strings"])
     env.Append(LINKFLAGS=["-Wl,-R,'$$ORIGIN'"])
 
-    if env['target'] == 'debug':
-        env.Append(CCFLAGS=['-Og'])
-    elif env['target'] == 'release':
-        env.Append(CCFLAGS=['-O3'])
+    if env["target"] == "debug":
+        env.Append(CCFLAGS=["-Og", "-g"])
+    elif env["target"] == "release":
+        env.Append(CCFLAGS=["-O3"])
 
-    if env['bits'] == '64':
-        env.Append(CCFLAGS=['-m64'])
-        env.Append(LINKFLAGS=['-m64'])
-    elif env['bits'] == '32':
-        env.Append(CCFLAGS=['-m32'])
-        env.Append(LINKFLAGS=['-m32'])
+    if env["bits"] == "64":
+        env.Append(CCFLAGS=["-m64"])
+        env.Append(LINKFLAGS=["-m64"])
+    elif env["bits"] == "32":
+        env.Append(CCFLAGS=["-m32"])
+        env.Append(LINKFLAGS=["-m32"])
 
-elif env['platform'] == 'osx':
+elif env["platform"] == "osx":
     # Use Clang on macOS by default
-    env['CXX'] = 'clang++'
+    env["CXX"] = "clang++"
 
-    if env['bits'] == '32':
-        raise ValueError(
-            'Only 64-bit builds are supported for the macOS target.'
-        )
+    if env["bits"] == "32":
+        raise ValueError("Only 64-bit builds are supported for the macOS target.")
 
-    env.Append(CCFLAGS=['-g', '-std=c++14', '-arch', 'x86_64'])
-    env.Append(LINKFLAGS=[
-        '-arch',
-        'x86_64',
-        '-framework',
-        'Cocoa',
-        '-Wl,-undefined,dynamic_lookup',
-    ])
-
-    if env['target'] == 'debug':
-        env.Append(CCFLAGS=['-Og'])
-    elif env['target'] == 'release':
-        env.Append(CCFLAGS=['-O3'])
-
-elif env['platform'] == 'ios':
-    if env['ios_arch'] == 'x86_64':
-        sdk_name = 'iphonesimulator'
-        env.Append(CCFLAGS=['-mios-simulator-version-min=10.0'])
+    if env["macos_arch"] == "universal":
+        env.Append(LINKFLAGS=["-arch", "x86_64", "-arch", "arm64"])
+        env.Append(CCFLAGS=["-arch", "x86_64", "-arch", "arm64"])
     else:
-        sdk_name = 'iphoneos'
-        env.Append(CCFLAGS=['-miphoneos-version-min=10.0'])
+        env.Append(LINKFLAGS=["-arch", env["macos_arch"]])
+        env.Append(CCFLAGS=["-arch", env["macos_arch"]])
+
+    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"]])
+
+    if env["macos_sdk_path"]:
+        env.Append(CCFLAGS=["-isysroot", env["macos_sdk_path"]])
+        env.Append(LINKFLAGS=["-isysroot", env["macos_sdk_path"]])
+
+    env.Append(LINKFLAGS=["-Wl,-undefined,dynamic_lookup"])
+
+    if env["target"] == "debug":
+        env.Append(CCFLAGS=["-Og", "-g"])
+    elif env["target"] == "release":
+        env.Append(CCFLAGS=["-O3"])
+
+elif env["platform"] == "ios":
+    if env["ios_simulator"]:
+        sdk_name = "iphonesimulator"
+        env.Append(CCFLAGS=["-mios-simulator-version-min=10.0"])
+    else:
+        sdk_name = "iphoneos"
+        env.Append(CCFLAGS=["-miphoneos-version-min=10.0"])
 
     try:
-        sdk_path = decode_utf8(subprocess.check_output(['xcrun', '--sdk', sdk_name, '--show-sdk-path']).strip())
+        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))
 
-    compiler_path = env['IPHONEPATH'] + '/usr/bin/'
-    env['ENV']['PATH'] = env['IPHONEPATH'] + "/Developer/usr/bin/:" + env['ENV']['PATH']
+    compiler_path = env["IPHONEPATH"] + "/usr/bin/"
+    env["ENV"]["PATH"] = env["IPHONEPATH"] + "/Developer/usr/bin/:" + env["ENV"]["PATH"]
 
-    env['CC'] = compiler_path + 'clang'
-    env['CXX'] = compiler_path + 'clang++'
-    env['AR'] = compiler_path + 'ar'
-    env['RANLIB'] = compiler_path + 'ranlib'
+    env["CC"] = compiler_path + "clang"
+    env["CXX"] = compiler_path + "clang++"
+    env["AR"] = compiler_path + "ar"
+    env["RANLIB"] = compiler_path + "ranlib"
+    env["SHLIBSUFFIX"] = ".dylib"
 
-    env.Append(CCFLAGS=['-g', '-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,
-        '-F' + sdk_path
-    ])
+    env.Append(CCFLAGS=["-arch", env["ios_arch"], "-isysroot", sdk_path])
+    env.Append(
+        LINKFLAGS=[
+            "-arch",
+            env["ios_arch"],
+            "-Wl,-undefined,dynamic_lookup",
+            "-isysroot",
+            sdk_path,
+            "-F" + sdk_path,
+        ]
+    )
 
-    if env['target'] == 'debug':
-        env.Append(CCFLAGS=['-Og'])
-    elif env['target'] == 'release':
-        env.Append(CCFLAGS=['-O3'])
+    if env["target"] == "debug":
+        env.Append(CCFLAGS=["-Og", "-g"])
+    elif env["target"] == "release":
+        env.Append(CCFLAGS=["-O3"])
 
-elif env['platform'] == 'windows':
-    if host_platform == 'windows' and not env['use_mingw']:
+elif env["platform"] == "windows":
+    if host_platform == "windows" and not env["use_mingw"]:
         # MSVC
-        env.Append(LINKFLAGS=['/WX'])
-        if env['target'] == 'debug':
-            env.Append(CCFLAGS=['/Z7', '/Od', '/EHsc', '/D_DEBUG', '/MDd'])
-        elif env['target'] == 'release':
-            env.Append(CCFLAGS=['/O2', '/EHsc', '/DNDEBUG', '/MD'])
+        env.Append(LINKFLAGS=["/WX"])
+        if env["target"] == "debug":
+            env.Append(CCFLAGS=["/Z7", "/Od", "/EHsc", "/D_DEBUG", "/MDd"])
+        elif env["target"] == "release":
+            env.Append(CCFLAGS=["/O2", "/EHsc", "/DNDEBUG", "/MD"])
 
-    elif host_platform == 'linux' or host_platform == 'osx':
+    elif host_platform == "linux" or host_platform == "freebsd" or host_platform == "osx":
         # Cross-compilation using MinGW
-        if env['bits'] == '64':
-            env['CXX'] = 'x86_64-w64-mingw32-g++'
-            env['AR'] = "x86_64-w64-mingw32-ar"
-            env['RANLIB'] = "x86_64-w64-mingw32-ranlib"
-            env['LINK'] = "x86_64-w64-mingw32-g++"
-        elif env['bits'] == '32':
-            env['CXX'] = 'i686-w64-mingw32-g++'
-            env['AR'] = "i686-w64-mingw32-ar"
-            env['RANLIB'] = "i686-w64-mingw32-ranlib"
-            env['LINK'] = "i686-w64-mingw32-g++"
-    elif host_platform == 'windows' and env['use_mingw']:
-        env = env.Clone(tools=['mingw'])
+        if env["bits"] == "64":
+            env["CXX"] = "x86_64-w64-mingw32-g++"
+            env["AR"] = "x86_64-w64-mingw32-ar"
+            env["RANLIB"] = "x86_64-w64-mingw32-ranlib"
+            env["LINK"] = "x86_64-w64-mingw32-g++"
+        elif env["bits"] == "32":
+            env["CXX"] = "i686-w64-mingw32-g++"
+            env["AR"] = "i686-w64-mingw32-ar"
+            env["RANLIB"] = "i686-w64-mingw32-ranlib"
+            env["LINK"] = "i686-w64-mingw32-g++"
+
+    elif host_platform == "windows" and env["use_mingw"]:
+        # 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["SPAWN"] = mySpawn
+        env.Replace(ARFLAGS=["q"])
 
     # Native or cross-compilation using MinGW
-    if host_platform == 'linux' or host_platform == 'osx' or env['use_mingw']:
-        env.Append(CCFLAGS=['-g', '-O3', '-std=c++14', '-Wwrite-strings'])
-        env.Append(LINKFLAGS=[
-            '--static',
-            '-Wl,--no-undefined',
-            '-static-libgcc',
-            '-static-libstdc++',
-        ])
-elif env['platform'] == 'android':
-    if host_platform == 'windows':
-        env = env.Clone(tools=['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(
+            LINKFLAGS=[
+                "--static",
+                "-Wl,--no-undefined",
+                "-static-libgcc",
+                "-static-libstdc++",
+            ]
+        )
+
+elif env["platform"] == "android":
+    if host_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)
+
+        # 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:
-        raise ValueError("To build for Android, ANDROID_NDK_ROOT must be defined. Please set ANDROID_NDK_ROOT to the root folder of your Android NDK installation.")
+    if not "ANDROID_NDK_ROOT" in env:
+        raise ValueError(
+            "To build for Android, ANDROID_NDK_ROOT must be defined. Please set ANDROID_NDK_ROOT to the root folder of your Android NDK installation."
+        )
 
     # Validate API level
-    api_level = int(env['android_api_level'])
-    if env['android_arch'] in ['x86_64', 'arm64v8'] and api_level < 21:
+    api_level = int(env["android_api_level"])
+    if env["android_arch"] in ["x86_64", "arm64v8"] and api_level < 21:
         print("WARN: 64-bit Android architectures require an API level of at least 21; setting android_api_level=21")
-        env['android_api_level'] = '21'
+        env["android_api_level"] = "21"
         api_level = 21
 
     # Setup toolchain
-    toolchain = env['ANDROID_NDK_ROOT'] + "/toolchains/llvm/prebuilt/"
+    toolchain = env["ANDROID_NDK_ROOT"] + "/toolchains/llvm/prebuilt/"
     if host_platform == "windows":
         toolchain += "windows"
         import platform as pltfm
+
         if pltfm.machine().endswith("64"):
             toolchain += "-x86_64"
     elif host_platform == "linux":
         toolchain += "linux-x86_64"
     elif host_platform == "osx":
         toolchain += "darwin-x86_64"
-    env.PrependENVPath('PATH', toolchain + "/bin") # This does nothing half of the time, but we'll put it here anyways
+    env.PrependENVPath("PATH", toolchain + "/bin")  # This does nothing half of the time, but we'll put it here anyways
 
     # Get architecture info
     arch_info_table = {
-        "armv7" : {
-            "march":"armv7-a", "target":"armv7a-linux-androideabi", "tool_path":"arm-linux-androideabi", "compiler_path":"armv7a-linux-androideabi",
-            "ccflags" : ['-mfpu=neon']
-            },
-        "arm64v8" : {
-            "march":"armv8-a", "target":"aarch64-linux-android", "tool_path":"aarch64-linux-android", "compiler_path":"aarch64-linux-android",
-            "ccflags" : []
-            },
-        "x86" : {
-            "march":"i686", "target":"i686-linux-android", "tool_path":"i686-linux-android", "compiler_path":"i686-linux-android",
-            "ccflags" : ['-mstackrealign']
-            },
-        "x86_64" : {"march":"x86-64", "target":"x86_64-linux-android", "tool_path":"x86_64-linux-android", "compiler_path":"x86_64-linux-android",
-            "ccflags" : []
-        }
+        "armv7": {
+            "march": "armv7-a",
+            "target": "armv7a-linux-androideabi",
+            "tool_path": "arm-linux-androideabi",
+            "compiler_path": "armv7a-linux-androideabi",
+            "ccflags": ["-mfpu=neon"],
+        },
+        "arm64v8": {
+            "march": "armv8-a",
+            "target": "aarch64-linux-android",
+            "tool_path": "aarch64-linux-android",
+            "compiler_path": "aarch64-linux-android",
+            "ccflags": [],
+        },
+        "x86": {
+            "march": "i686",
+            "target": "i686-linux-android",
+            "tool_path": "i686-linux-android",
+            "compiler_path": "i686-linux-android",
+            "ccflags": ["-mstackrealign"],
+        },
+        "x86_64": {
+            "march": "x86-64",
+            "target": "x86_64-linux-android",
+            "tool_path": "x86_64-linux-android",
+            "compiler_path": "x86_64-linux-android",
+            "ccflags": [],
+        },
     }
-    arch_info = arch_info_table[env['android_arch']]
+    arch_info = arch_info_table[env["android_arch"]]
 
     # Setup tools
-    env['CC'] = toolchain + "/bin/clang"
-    env['CXX'] = toolchain + "/bin/clang++"
-    env['AR'] = toolchain + "/bin/" + arch_info['tool_path'] + "-ar"
+    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.Append(CCFLAGS=['--target=' + arch_info['target'] + env['android_api_level'], '-march=' + arch_info['march'], '-fPIC'])#, '-fPIE', '-fno-addrsig', '-Oz'])
-    env.Append(CCFLAGS=arch_info['ccflags'])
+    env.Append(
+        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"]])
 
-env.Append(CPPPATH=[
-    '.',
-    env['headers_dir'],
-    'include',
-    'include/gen',
-    'include/core',
-])
+    if env["target"] == "debug":
+        env.Append(CCFLAGS=["-Og", "-g"])
+    elif env["target"] == "release":
+        env.Append(CCFLAGS=["-O3"])
+
+elif env["platform"] == "javascript":
+    env["ENV"] = os.environ
+    env["CC"] = "emcc"
+    env["CXX"] = "em++"
+    env["AR"] = "emar"
+    env["RANLIB"] = "emranlib"
+    env.Append(CPPFLAGS=["-s", "SIDE_MODULE=1"])
+    env.Append(LINKFLAGS=["-s", "SIDE_MODULE=1"])
+    env["SHOBJSUFFIX"] = ".bc"
+    env["SHLIBSUFFIX"] = ".wasm"
+    # Use TempFileMunge since some AR invocations are too long for cmd.exe.
+    # Use POSIX-style paths, required with TempFileMunge.
+    env["ARCOM_POSIX"] = env["ARCOM"].replace("$TARGET", "$TARGET.posix").replace("$SOURCES", "$SOURCES.posix")
+    env["ARCOM"] = "${TEMPFILE(ARCOM_POSIX)}"
+
+    # All intermediate files are just LLVM bitcode.
+    env["OBJPREFIX"] = ""
+    env["OBJSUFFIX"] = ".bc"
+    env["PROGPREFIX"] = ""
+    # Program() output consists of multiple files, so specify suffixes manually at builder.
+    env["PROGSUFFIX"] = ""
+    env["LIBPREFIX"] = "lib"
+    env["LIBSUFFIX"] = ".a"
+    env["LIBPREFIXES"] = ["$LIBPREFIX"]
+    env["LIBSUFFIXES"] = ["$LIBSUFFIX"]
+    env.Replace(SHLINKFLAGS="$LINKFLAGS")
+    env.Replace(SHLINKFLAGS="$LINKFLAGS")
+
+    if env["target"] == "debug":
+        env.Append(CCFLAGS=["-O0", "-g"])
+    elif env["target"] == "release":
+        env.Append(CCFLAGS=["-O3"])
+
+env.Append(
+    CPPPATH=[
+        ".",
+        env["headers_dir"],
+        "include",
+        "include/gen",
+        "include/core",
+    ]
+)
 
 # Generate bindings?
-json_api_file = ''
+json_api_file = ""
 
-if 'custom_api_file' in env:
-    json_api_file = env['custom_api_file']
+if "custom_api_file" in env:
+    json_api_file = env["custom_api_file"]
 else:
-    json_api_file = os.path.join(os.getcwd(), 'godot_headers', 'api.json')
+    json_api_file = os.path.join(os.getcwd(), env["headers_dir"], "api.json")
 
-if env['generate_bindings']:
+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"]
+
+if should_generate_bindings:
     # Actually create the bindings here
     import binding_generator
 
-    binding_generator.generate_bindings(json_api_file)
+    binding_generator.generate_bindings(json_api_file, env["generate_template_get_node"])
 
 # Sources to compile
 sources = []
-add_sources(sources, 'src/core', 'cpp')
-add_sources(sources, 'src/gen', 'cpp')
+add_sources(sources, "src/core", "cpp")
+add_sources(sources, "src/gen", "cpp")
 
-arch_suffix = env['bits']
-if env['platform'] == 'android':
-    arch_suffix = env['android_arch']
-if env['platform'] == 'ios':
-    arch_suffix = env['ios_arch']
+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 = env.StaticLibrary(
-    target='bin/' + 'libgodot-cpp.{}.{}.{}{}'.format(
-        env['platform'],
-        env['target'],
-        arch_suffix,
-        env['LIBSUFFIX']
-    ), source=sources
-)
-Default(library)
+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(CPPPATH=[env.Dir(f) for f in [env["headers_dir"], "include", "include/gen", "include/core"]])
+env.Append(LIBPATH=[env.Dir("bin")])
+env.Append(LIBS=library_name)
+Return("env")

binding_generator.py

@@ -1,56 +1,114 @@
 #!/usr/bin/env python
-
+from __future__ import print_function
 import json
+import os
+import errno
+from pathlib import Path
+
+# Convenience function for using template get_node
+def correct_method_name(method_list):
+    for method in method_list:
+        if method["name"] == "get_node":
+            method["name"] = "get_node_internal"
 
-# comment.
 
 classes = []
 
-def generate_bindings(path):
 
+def print_file_list(api_filepath, output_dir, headers=False, sources=False):
     global classes
-    classes = json.load(open(path))
+    end = ";"
+    with open(api_filepath) as api_file:
+        classes = json.load(api_file)
+    include_gen_folder = Path(output_dir) / "include" / "gen"
+    source_gen_folder = Path(output_dir) / "src" / "gen"
+    for _class in classes:
+        header_filename = include_gen_folder / (strip_name(_class["name"]) + ".hpp")
+        source_filename = source_gen_folder / (strip_name(_class["name"]) + ".cpp")
+        if headers:
+            print(str(header_filename.as_posix()), end=end)
+        if sources:
+            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:
+        print(str(icall_header_filename.as_posix()), end=end)
+    if sources:
+        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="."):
+    global classes
+    with open(api_filepath) as api_file:
+        classes = json.load(api_file)
 
     icalls = set()
+    include_gen_folder = Path(output_dir) / "include" / "gen"
+    source_gen_folder = Path(output_dir) / "src" / "gen"
+
+    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']
+        # print(c['name'])
         used_classes = get_used_classes(c)
+        if use_template_get_node and c["name"] == "Node":
+            correct_method_name(c["methods"])
 
-        header = generate_class_header(used_classes, c)
+        header = generate_class_header(used_classes, c, use_template_get_node)
 
-        impl = generate_class_implementation(icalls, used_classes, c)
+        impl = generate_class_implementation(icalls, used_classes, c, use_template_get_node)
 
-        header_file = open("include/gen/" + strip_name(c["name"]) + ".hpp", "w+")
-        header_file.write(header)
+        header_filename = include_gen_folder / (strip_name(c["name"]) + ".hpp")
+        with header_filename.open("w+") as header_file:
+            header_file.write(header)
 
-        source_file = open("src/gen/" + strip_name(c["name"]) + ".cpp", "w+")
-        source_file.write(impl)
+        source_filename = source_gen_folder / (strip_name(c["name"]) + ".cpp")
+        with source_filename.open("w+") as source_file:
+            source_file.write(impl)
 
+    icall_header_filename = include_gen_folder / "__icalls.hpp"
+    with icall_header_filename.open("w+") as icall_header_file:
+        icall_header_file.write(generate_icall_header(icalls))
 
-    icall_header_file = open("include/gen/__icalls.hpp", "w+")
-    icall_header_file.write(generate_icall_header(icalls))
+    register_types_filename = source_gen_folder / "__register_types.cpp"
+    with register_types_filename.open("w+") as register_types_file:
+        register_types_file.write(generate_type_registry(classes))
 
-    register_types_file = open("src/gen/__register_types.cpp", "w+")
-    register_types_file.write(generate_type_registry(classes))
-
-    init_method_bindings_file = open("src/gen/__init_method_bindings.cpp", "w+")
-    init_method_bindings_file.write(generate_init_method_bindings(classes))
+    init_method_bindings_filename = source_gen_folder / "__init_method_bindings.cpp"
+    with init_method_bindings_filename.open("w+") as init_method_bindings_file:
+        init_method_bindings_file.write(generate_init_method_bindings(classes))
 
 
 def is_reference_type(t):
     for c in classes:
-        if c['name'] != t:
+        if c["name"] != t:
             continue
-        if c['is_reference']:
+        if c["is_reference"]:
             return True
     return False
 
-def make_gdnative_type(t):
+
+def make_gdnative_type(t, ref_allowed):
     if is_enum(t):
         return remove_enum_prefix(t) + " "
     elif is_class_type(t):
-        if is_reference_type(t):
+        if is_reference_type(t) and ref_allowed:
             return "Ref<" + strip_name(t) + "> "
         else:
             return strip_name(t) + " *"
@@ -62,7 +120,7 @@ def make_gdnative_type(t):
         return strip_name(t) + " "
 
 
-def generate_class_header(used_classes, c):
+def generate_class_header(used_classes, c, use_template_get_node):
 
     source = []
     source.append("#ifndef GODOT_CPP_" + strip_name(c["name"]).upper() + "_HPP")
@@ -71,10 +129,9 @@ def generate_class_header(used_classes, c):
     source.append("")
 
     source.append("#include <gdnative_api_struct.gen.h>")
-    source.append("#include <stdint.h>")
+    source.append("#include <cstdint>")
     source.append("")
 
-
     source.append("#include <core/CoreTypes.hpp>")
 
     class_name = strip_name(c["name"])
@@ -83,9 +140,10 @@ def generate_class_header(used_classes, c):
     # so don't include it here because it's not needed
     if class_name != "Object" and class_name != "Reference":
         source.append("#include <core/Ref.hpp>")
+        ref_allowed = True
     else:
         source.append("#include <core/TagDB.hpp>")
-
+        ref_allowed = False
 
     included = []
 
@@ -94,36 +152,38 @@ def generate_class_header(used_classes, c):
             used_class_name = remove_enum_prefix(extract_nested_type(used_class))
             if used_class_name not in included:
                 included.append(used_class_name)
-                source.append("#include \"" + used_class_name + ".hpp\"")
+                source.append('#include "' + used_class_name + '.hpp"')
         elif is_enum(used_class) and is_nested_type(used_class) and not is_nested_type(used_class, class_name):
             used_class_name = remove_enum_prefix(used_class)
             if used_class_name not in included:
                 included.append(used_class_name)
-                source.append("#include \"" + used_class_name + ".hpp\"")
+                source.append('#include "' + used_class_name + '.hpp"')
 
     source.append("")
 
     if c["base_class"] != "":
-        source.append("#include \"" + strip_name(c["base_class"]) + ".hpp\"")
-
+        source.append('#include "' + strip_name(c["base_class"]) + '.hpp"')
 
     source.append("namespace godot {")
     source.append("")
 
-
     for used_type in used_classes:
         if is_enum(used_type) or is_nested_type(used_type, class_name):
             continue
         else:
             source.append("class " + strip_name(used_type) + ";")
 
-
     source.append("")
 
     vararg_templates = ""
 
     # generate the class definition here
-    source.append("class " + class_name + (" : public _Wrapped" if c["base_class"] == "" else (" : public " + strip_name(c["base_class"])) ) + " {")
+    source.append(
+        "class "
+        + class_name
+        + (" : public _Wrapped" if c["base_class"] == "" else (" : public " + strip_name(c["base_class"])))
+        + " {"
+    )
 
     if c["base_class"] == "":
         source.append("public: enum { ___CLASS_IS_SCRIPT = 0, };")
@@ -144,12 +204,15 @@ def generate_class_header(used_classes, c):
 
     source.append("\t};")
     source.append("\tstatic ___method_bindings ___mb;")
+    source.append("\tstatic void *_detail_class_tag;")
     source.append("")
     source.append("public:")
     source.append("\tstatic void ___init_method_bindings();")
 
-    source.append("")
+    # class id from core engine for casting
+    source.append("\tinline static size_t ___get_id() { return (size_t)_detail_class_tag; }")
 
+    source.append("")
 
     if c["singleton"]:
         source.append("\tstatic inline " + class_name + " *get_singleton()")
@@ -163,10 +226,21 @@ def generate_class_header(used_classes, c):
 
         # godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");"
 
-    # ___get_class_name
-    source.append("\tstatic inline const char *___get_class_name() { return (const char *) \"" + strip_name(c["name"]) + "\"; }")
+    # class name:
+    # Two versions needed needed because when the user implements a custom class,
+    # we want to override `___get_class_name` while `___get_godot_class_name` can keep returning the base name
+    source.append(
+        '\tstatic inline const char *___get_class_name() { return (const char *) "' + strip_name(c["name"]) + '"; }'
+    )
+    source.append(
+        '\tstatic inline const char *___get_godot_class_name() { return (const char *) "'
+        + strip_name(c["name"])
+        + '"; }'
+    )
 
-    source.append("\tstatic inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }")
+    source.append(
+        "\tstatic inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }"
+    )
 
     enum_values = []
 
@@ -184,7 +258,6 @@ def generate_class_header(used_classes, c):
         if name not in enum_values:
             source.append("\tconst static int " + name + " = " + str(c["constants"][name]) + ";")
 
-
     if c["instanciable"]:
         source.append("")
         source.append("")
@@ -192,7 +265,6 @@ def generate_class_header(used_classes, c):
 
     source.append("\n\t// methods")
 
-
     if class_name == "Object":
         source.append("#ifndef GODOT_CPP_NO_OBJECT_CAST")
         source.append("\ttemplate<class T>")
@@ -201,26 +273,23 @@ def generate_class_header(used_classes, c):
         source.append("")
 
     for method in c["methods"]:
-
         method_signature = ""
 
         # TODO decide what to do about virtual methods
         # method_signature += "virtual " if method["is_virtual"] else ""
-        method_signature += make_gdnative_type(method["return_type"])
+        method_signature += make_gdnative_type(method["return_type"], ref_allowed)
         method_name = escape_cpp(method["name"])
-        method_signature +=  method_name + "("
-
+        method_signature += method_name + "("
 
         has_default_argument = False
         method_arguments = ""
 
         for i, argument in enumerate(method["arguments"]):
-            method_signature += "const " + make_gdnative_type(argument["type"])
+            method_signature += "const " + make_gdnative_type(argument["type"], ref_allowed)
             argument_name = escape_cpp(argument["name"])
             method_signature += argument_name
             method_arguments += argument_name
 
-
             # default arguments
             def escape_default_arg(_type, default_value):
                 if _type == "Color":
@@ -229,7 +298,15 @@ def generate_class_header(used_classes, c):
                     return default_value.lower()
                 if _type == "Array":
                     return "Array()"
-                if _type in ["PoolVector2Array", "PoolStringArray", "PoolVector3Array", "PoolColorArray", "PoolIntArray", "PoolRealArray"]:
+                if _type in [
+                    "PoolVector2Array",
+                    "PoolStringArray",
+                    "PoolVector3Array",
+                    "PoolColorArray",
+                    "PoolIntArray",
+                    "PoolRealArray",
+                    "PoolByteArray",
+                ]:
                     return _type + "()"
                 if _type == "Vector2":
                     return "Vector2" + default_value
@@ -243,8 +320,8 @@ def generate_class_header(used_classes, c):
                     return "Rect2" + default_value
                 if _type == "Variant":
                     return "Variant()" if default_value == "Null" else default_value
-                if _type == "String":
-                    return "\"" + default_value + "\""
+                if _type == "String" or _type == "NodePath":
+                    return '"' + default_value + '"'
                 if _type == "RID":
                     return "RID()"
 
@@ -253,15 +330,10 @@ def generate_class_header(used_classes, c):
 
                 return default_value
 
-
-
-
             if argument["has_default_value"] or has_default_argument:
                 method_signature += " = " + escape_default_arg(argument["type"], argument["default_value"])
                 has_default_argument = True
 
-
-
             if i != len(method["arguments"]) - 1:
                 method_signature += ", "
                 method_arguments += ","
@@ -270,36 +342,59 @@ def generate_class_header(used_classes, c):
             if len(method["arguments"]) > 0:
                 method_signature += ", "
                 method_arguments += ", "
-            vararg_templates += "\ttemplate <class... Args> " + method_signature + "Args... args){\n\t\treturn " + method_name + "(" + method_arguments + "Array::make(args...));\n\t}\n"""
+            vararg_templates += (
+                "\ttemplate <class... Args> "
+                + method_signature
+                + "Args... args){\n\t\treturn "
+                + method_name
+                + "("
+                + method_arguments
+                + "Array::make(args...));\n\t}\n"
+                ""
+            )
             method_signature += "const Array& __var_args = Array()"
 
         method_signature += ")" + (" const" if method["is_const"] else "")
 
-
         source.append("\t" + method_signature + ";")
 
     source.append(vararg_templates)
-    source.append("};")
-    source.append("")
 
+    if use_template_get_node and class_name == "Node":
+        # Extra definition for template get_node that calls the renamed get_node_internal; has a default template parameter for backwards compatibility.
+        source.append("\ttemplate <class T = Node>")
+        source.append("\tT *get_node(const NodePath path) const {")
+        source.append("\t\treturn Object::cast_to<T>(get_node_internal(path));")
+        source.append("\t}")
 
+        source.append("};")
+        source.append("")
+
+        # ...And a specialized version so we don't unnecessarily cast when using the default.
+        source.append("template <>")
+        source.append("inline Node *Node::get_node<Node>(const NodePath path) const {")
+        source.append("\treturn get_node_internal(path);")
+        source.append("}")
+        source.append("")
+    else:
+        source.append("};")
+        source.append("")
 
     source.append("}")
     source.append("")
 
     source.append("#endif")
 
-
     return "\n".join(source)
 
 
-
-
-
-def generate_class_implementation(icalls, used_classes, c):
+def generate_class_implementation(icalls, used_classes, c, use_template_get_node):
     class_name = strip_name(c["name"])
+
+    ref_allowed = class_name != "Object" and class_name != "Reference"
+
     source = []
-    source.append("#include \"" + class_name + ".hpp\"")
+    source.append('#include "' + class_name + '.hpp"')
     source.append("")
     source.append("")
 
@@ -310,8 +405,7 @@ def generate_class_implementation(icalls, used_classes, c):
     source.append("#include <core/Godot.hpp>")
     source.append("")
 
-
-    source.append("#include \"__icalls.hpp\"")
+    source.append('#include "__icalls.hpp"')
     source.append("")
     source.append("")
 
@@ -319,17 +413,15 @@ def generate_class_implementation(icalls, used_classes, c):
         if is_enum(used_class):
             continue
         else:
-            source.append("#include \"" + strip_name(used_class) + ".hpp\"")
+            source.append('#include "' + strip_name(used_class) + '.hpp"')
 
     source.append("")
     source.append("")
 
     source.append("namespace godot {")
 
-
     core_object_name = "this"
 
-
     source.append("")
     source.append("")
 
@@ -340,7 +432,7 @@ def generate_class_implementation(icalls, used_classes, c):
 
         # FIXME Test if inlining has a huge impact on binary size
         source.append(class_name + "::" + class_name + "() {")
-        source.append("\t_owner = godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");")
+        source.append('\t_owner = godot::api->godot_global_get_singleton((char *) "' + strip_name(c["name"]) + '");')
         source.append("}")
 
         source.append("")
@@ -350,10 +442,26 @@ def generate_class_implementation(icalls, used_classes, c):
     source.append(class_name + "::___method_bindings " + class_name + "::___mb = {};")
     source.append("")
 
+    source.append("void *" + class_name + "::_detail_class_tag = nullptr;")
+    source.append("")
+
     source.append("void " + class_name + "::___init_method_bindings() {")
 
     for method in c["methods"]:
-        source.append("\t___mb.mb_" + method["name"] + " = godot::api->godot_method_bind_get_method(\"" + c["name"] + "\", \"" + method["name"] + "\");")
+        source.append(
+            "\t___mb.mb_"
+            + method["name"]
+            + ' = godot::api->godot_method_bind_get_method("'
+            + c["name"]
+            + '", "'
+            + ("get_node" if use_template_get_node and method["name"] == "get_node_internal" else method["name"])
+            + '");'
+        )
+
+    source.append("\tgodot_string_name class_name;")
+    source.append('\tgodot::api->godot_string_name_new_data(&class_name, "' + c["name"] + '");')
+    source.append("\t_detail_class_tag = godot::core_1_2_api->godot_get_class_tag(&class_name);")
+    source.append("\tgodot::api->godot_string_name_destroy(&class_name);")
 
     source.append("}")
     source.append("")
@@ -361,18 +469,23 @@ def generate_class_implementation(icalls, used_classes, c):
     if c["instanciable"]:
         source.append(class_name + " *" + strip_name(c["name"]) + "::_new()")
         source.append("{")
-        source.append("\treturn (" + class_name + " *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, godot::api->godot_get_class_constructor((char *)\"" + c["name"] + "\")());")
+        source.append(
+            "\treturn ("
+            + class_name
+            + ' *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, godot::api->godot_get_class_constructor((char *)"'
+            + c["name"]
+            + '")());'
+        )
         source.append("}")
 
     for method in c["methods"]:
         method_signature = ""
 
-
-        method_signature += make_gdnative_type(method["return_type"])
+        method_signature += make_gdnative_type(method["return_type"], ref_allowed)
         method_signature += strip_name(c["name"]) + "::" + escape_cpp(method["name"]) + "("
 
         for i, argument in enumerate(method["arguments"]):
-            method_signature += "const " + make_gdnative_type(argument["type"])
+            method_signature += "const " + make_gdnative_type(argument["type"], ref_allowed)
             method_signature += escape_cpp(argument["name"])
 
             if i != len(method["arguments"]) - 1:
@@ -387,7 +500,6 @@ def generate_class_implementation(icalls, used_classes, c):
 
         source.append(method_signature + " {")
 
-
         if method["name"] == "free":
             # dirty hack because Object::free is marked virtual but doesn't actually exist...
             source.append("\tgodot::api->godot_object_destroy(_owner);")
@@ -396,15 +508,18 @@ def generate_class_implementation(icalls, used_classes, c):
             continue
 
         return_statement = ""
+        return_type_is_ref = is_reference_type(method["return_type"]) and ref_allowed
 
         if method["return_type"] != "void":
             if is_class_type(method["return_type"]):
                 if is_enum(method["return_type"]):
                     return_statement += "return (" + remove_enum_prefix(method["return_type"]) + ") "
-                elif is_reference_type(method["return_type"]):
-                    return_statement += "return Ref<" + strip_name(method["return_type"]) + ">::__internal_constructor(";
+                elif return_type_is_ref:
+                    return_statement += "return Ref<" + strip_name(method["return_type"]) + ">::__internal_constructor("
                 else:
-                    return_statement += "return " + ("(" + strip_name(method["return_type"]) + " *) " if is_class_type(method["return_type"]) else "")
+                    return_statement += "return " + (
+                        "(" + strip_name(method["return_type"]) + " *) " if is_class_type(method["return_type"]) else ""
+                    )
             else:
                 return_statement += "return "
 
@@ -415,8 +530,6 @@ def generate_class_implementation(icalls, used_classes, c):
                 return "Object"
             return name
 
-
-
         if method["has_varargs"]:
 
             if len(method["arguments"]) != 0:
@@ -427,7 +540,6 @@ def generate_class_implementation(icalls, used_classes, c):
 
             source.append("")
 
-
             for i, argument in enumerate(method["arguments"]):
                 source.append("\t__given_args[" + str(i) + "] = " + escape_cpp(argument["name"]) + ";")
 
@@ -439,7 +551,9 @@ def generate_class_implementation(icalls, used_classes, c):
             else:
                 size = "(" + str(len(method["arguments"])) + ")"
 
-            source.append("\tgodot_variant **__args = (godot_variant **) alloca(sizeof(godot_variant *) * " + size + ");")
+            source.append(
+                "\tgodot_variant **__args = (godot_variant **) alloca(sizeof(godot_variant *) * " + size + ");"
+            )
 
             source.append("")
 
@@ -450,24 +564,35 @@ def generate_class_implementation(icalls, used_classes, c):
 
             if method["has_varargs"]:
                 source.append("\tfor (int i = 0; i < __var_args.size(); i++) {")
-                source.append("\t\t__args[i + " + str(len(method["arguments"])) + "] = (godot_variant *) &((Array &) __var_args)[i];")
+                source.append(
+                    "\t\t__args[i + "
+                    + str(len(method["arguments"]))
+                    + "] = (godot_variant *) &((Array &) __var_args)[i];"
+                )
                 source.append("\t}")
 
             source.append("")
 
             source.append("\tVariant __result;")
-            source.append("\t*(godot_variant *) &__result = godot::api->godot_method_bind_call(___mb.mb_" + method["name"] + ", ((const Object *) " + core_object_name + ")->_owner, (const godot_variant **) __args, " + size + ", nullptr);")
+            source.append(
+                "\t*(godot_variant *) &__result = godot::api->godot_method_bind_call(___mb.mb_"
+                + method["name"]
+                + ", ((const Object *) "
+                + core_object_name
+                + ")->_owner, (const godot_variant **) __args, "
+                + size
+                + ", nullptr);"
+            )
 
             source.append("")
 
             if is_class_type(method["return_type"]):
                 source.append("\tObject *obj = Object::___get_from_variant(__result);")
-                source.append("\tif (obj->has_method(\"reference\"))")
-                source.append("\t\tobj->callv(\"reference\", Array());")
+                source.append('\tif (obj->has_method("reference"))')
+                source.append('\t\tobj->callv("reference", Array());')
 
                 source.append("")
 
-
             for i, argument in enumerate(method["arguments"]):
                 source.append("\tgodot::api->godot_variant_destroy((godot_variant *) &__given_args[" + str(i) + "]);")
 
@@ -476,16 +601,20 @@ def generate_class_implementation(icalls, used_classes, c):
             if method["return_type"] != "void":
                 cast = ""
                 if is_class_type(method["return_type"]):
-                    if is_reference_type(method["return_type"]):
+                    if return_type_is_ref:
                         cast += "Ref<" + strip_name(method["return_type"]) + ">::__internal_constructor(__result);"
                     else:
-                        cast += "(" + strip_name(method["return_type"]) + " *) " + strip_name(method["return_type"] + "::___get_from_variant(") + "__result);"
+                        cast += (
+                            "("
+                            + strip_name(method["return_type"])
+                            + " *) "
+                            + strip_name(method["return_type"] + "::___get_from_variant(")
+                            + "__result);"
+                        )
                 else:
                     cast += "__result;"
                 source.append("\treturn " + cast)
 
-
-
         else:
 
             args = []
@@ -503,26 +632,24 @@ def generate_class_implementation(icalls, used_classes, c):
             return_statement += icall_name + "(___mb.mb_" + method["name"] + ", (const Object *) " + core_object_name
 
             for arg in method["arguments"]:
-                return_statement += ", " + escape_cpp(arg["name"]) + (".ptr()" if is_reference_type(arg["type"]) else "")
+                arg_is_ref = is_reference_type(arg["type"]) and ref_allowed
+                return_statement += ", " + escape_cpp(arg["name"]) + (".ptr()" if arg_is_ref else "")
 
             return_statement += ")"
 
-            source.append("\t" + return_statement + (")" if is_reference_type(method["return_type"]) else "") + ";")
+            if return_type_is_ref:
+                return_statement += ")"
+
+            source.append("\t" + return_statement + ";")
 
         source.append("}")
         source.append("")
 
-
-
     source.append("}")
 
-
     return "\n".join(source)
 
 
-
-
-
 def generate_icall_header(icalls):
 
     source = []
@@ -537,7 +664,7 @@ def generate_icall_header(icalls):
 
     source.append("#include <core/GodotGlobal.hpp>")
     source.append("#include <core/CoreTypes.hpp>")
-    source.append("#include \"Object.hpp\"")
+    source.append('#include "Object.hpp"')
     source.append("")
     source.append("")
 
@@ -550,7 +677,9 @@ def generate_icall_header(icalls):
 
         method_signature = "static inline "
 
-        method_signature += get_icall_return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, const Object *inst"
+        method_signature += (
+            get_icall_return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, const Object *inst"
+        )
 
         for i, arg in enumerate(args):
             method_signature += ", const "
@@ -573,11 +702,12 @@ def generate_icall_header(icalls):
         source.append(method_signature + " {")
 
         if ret_type != "void":
-            source.append("\t" + ("godot_object *" if is_class_type(ret_type) else get_icall_return_type(ret_type)) + "ret;")
+            source.append(
+                "\t" + ("godot_object *" if is_class_type(ret_type) else get_icall_return_type(ret_type)) + "ret;"
+            )
             if is_class_type(ret_type):
                 source.append("\tret = nullptr;")
 
-
         source.append("\tconst void *args[" + ("1" if len(args) == 0 else "") + "] = {")
 
         for i, arg in enumerate(args):
@@ -594,12 +724,18 @@ def generate_icall_header(icalls):
         source.append("\t};")
         source.append("")
 
-        source.append("\tgodot::api->godot_method_bind_ptrcall(mb, inst->_owner, args, " + ("nullptr" if ret_type == "void" else "&ret") + ");")
+        source.append(
+            "\tgodot::api->godot_method_bind_ptrcall(mb, inst->_owner, args, "
+            + ("nullptr" if ret_type == "void" else "&ret")
+            + ");"
+        )
 
         if ret_type != "void":
             if is_class_type(ret_type):
                 source.append("\tif (ret) {")
-                source.append("\t\treturn (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, ret);")
+                source.append(
+                    "\t\treturn (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, ret);"
+                )
                 source.append("\t}")
                 source.append("")
                 source.append("\treturn (Object *) ret;")
@@ -620,7 +756,7 @@ def generate_icall_header(icalls):
 def generate_type_registry(classes):
     source = []
 
-    source.append("#include \"TagDB.hpp\"")
+    source.append('#include "TagDB.hpp"')
     source.append("#include <typeinfo>")
     source.append("\n")
 
@@ -646,14 +782,21 @@ def generate_type_registry(classes):
         if base_class_name == "":
             base_class_type_hash = "0"
 
-        source.append("\tgodot::_TagDB::register_global_type(\"" + c["name"] + "\", " + class_type_hash + ", " + base_class_type_hash + ");")
+        source.append(
+            '\tgodot::_TagDB::register_global_type("'
+            + c["name"]
+            + '", '
+            + class_type_hash
+            + ", "
+            + base_class_type_hash
+            + ");"
+        )
 
     source.append("}")
 
     source.append("")
     source.append("}")
 
-
     return "\n".join(source)
 
 
@@ -672,8 +815,6 @@ def generate_init_method_bindings(classes):
     source.append("{")
 
     for c in classes:
-        class_name = strip_name(c["name"])
-
         source.append("\t" + strip_name(c["name"]) + "::___init_method_bindings();")
 
     source.append("}")
@@ -706,10 +847,6 @@ def get_icall_name(sig):
     return name
 
 
-
-
-
-
 def get_used_classes(c):
     classes = []
     for method in c["methods"]:
@@ -722,88 +859,91 @@ def get_used_classes(c):
     return classes
 
 
-
-
-
-
-
-
 def strip_name(name):
     if len(name) == 0:
         return name
-    if name[0] == '_':
+    if name[0] == "_":
         return name[1:]
     return name
 
+
 def extract_nested_type(nested_type):
-    return strip_name(nested_type[:nested_type.find("::")])
+    return strip_name(nested_type[: nested_type.find("::")])
+
 
 def remove_nested_type_prefix(name):
-    return name if name.find("::") == -1 else strip_name(name[name.find("::") + 2:])
+    return name if name.find("::") == -1 else strip_name(name[name.find("::") + 2 :])
+
 
 def remove_enum_prefix(name):
-    return strip_name(name[name.find("enum.") + 5:])
+    return strip_name(name[name.find("enum.") + 5 :])
 
-def is_nested_type(name, type = ""):
+
+def is_nested_type(name, type=""):
     return name.find(type + "::") != -1
 
+
 def is_enum(name):
     return name.find("enum.") == 0
 
+
 def is_class_type(name):
     return not is_core_type(name) and not is_primitive(name)
 
+
 def is_core_type(name):
-    core_types = ["Array",
-                  "Basis",
-                  "Color",
-                  "Dictionary",
-                  "Error",
-                  "NodePath",
-                  "Plane",
-                  "PoolByteArray",
-                  "PoolIntArray",
-                  "PoolRealArray",
-                  "PoolStringArray",
-                  "PoolVector2Array",
-                  "PoolVector3Array",
-                  "PoolColorArray",
-                  "PoolIntArray",
-                  "PoolRealArray",
-                  "Quat",
-                  "Rect2",
-                  "AABB",
-                  "RID",
-                  "String",
-                  "Transform",
-                  "Transform2D",
-                  "Variant",
-                  "Vector2",
-                  "Vector3"]
+    core_types = [
+        "Array",
+        "Basis",
+        "Color",
+        "Dictionary",
+        "Error",
+        "NodePath",
+        "Plane",
+        "PoolByteArray",
+        "PoolIntArray",
+        "PoolRealArray",
+        "PoolStringArray",
+        "PoolVector2Array",
+        "PoolVector3Array",
+        "PoolColorArray",
+        "PoolIntArray",
+        "PoolRealArray",
+        "Quat",
+        "Rect2",
+        "AABB",
+        "RID",
+        "String",
+        "Transform",
+        "Transform2D",
+        "Variant",
+        "Vector2",
+        "Vector3",
+    ]
     return name in core_types
 
 
-
-
 def is_primitive(name):
     core_types = ["int", "bool", "real", "float", "void"]
     return name in core_types
 
+
 def escape_cpp(name):
     escapes = {
-        "class":    "_class",
-        "char":     "_char",
-        "short":    "_short",
-        "bool":     "_bool",
-        "int":      "_int",
-        "default":  "_default",
-        "case":     "_case",
-        "switch":   "_switch",
-        "export":   "_export",
+        "class": "_class",
+        "enum": "_enum",
+        "char": "_char",
+        "short": "_short",
+        "bool": "_bool",
+        "int": "_int",
+        "default": "_default",
+        "case": "_case",
+        "switch": "_switch",
+        "export": "_export",
         "template": "_template",
-        "new":      "new_",
+        "new": "new_",
         "operator": "_operator",
-        "typename": "_typename"
+        "typename": "_typename",
     }
     if name in escapes:
         return escapes[name]

include/core/AABB.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  AABB.hpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef AABB_H
 #define AABB_H
 
@@ -16,12 +46,10 @@ public:
 
 	real_t get_area() const; /// get area
 	inline bool has_no_area() const {
-
 		return (size.x <= CMP_EPSILON || size.y <= CMP_EPSILON || size.z <= CMP_EPSILON);
 	}
 
 	inline bool has_no_surface() const {
-
 		return (size.x <= CMP_EPSILON && size.y <= CMP_EPSILON && size.z <= CMP_EPSILON);
 	}
 

include/core/Array.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Array.hpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef ARRAY_H
 #define ARRAY_H
 
@@ -57,6 +87,13 @@ class Object;
 class Array {
 	godot_array _godot_array;
 
+	friend class Variant;
+	friend class Dictionary;
+	friend class String;
+	inline explicit Array(const godot_array &other) {
+		_godot_array = other;
+	}
+
 public:
 	Array();
 	Array(const Array &other);
@@ -83,7 +120,7 @@ public:
 
 	Variant &operator[](const int idx);
 
-	Variant operator[](const int idx) const;
+	const Variant &operator[](const int idx) const;
 
 	void append(const Variant &v);
 
@@ -99,9 +136,9 @@ public:
 
 	Variant back() const;
 
-	int find(const Variant &what, const int from = 0);
+	int find(const Variant &what, const int from = 0) const;
 
-	int find_last(const Variant &what);
+	int find_last(const Variant &what) const;
 
 	bool has(const Variant &what) const;
 
@@ -127,7 +164,7 @@ public:
 
 	void resize(const int size);
 
-	int rfind(const Variant &what, const int from = -1);
+	int rfind(const Variant &what, const int from = -1) const;
 
 	void sort();
 

include/core/Basis.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Basis.hpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef BASIS_H
 #define BASIS_H
 
@@ -13,6 +43,11 @@ class Quat;
 
 class Basis {
 private:
+	static const Basis IDENTITY;
+	static const Basis FLIP_X;
+	static const Basis FLIP_Y;
+	static const Basis FLIP_Z;
+
 	// This helper template is for mimicking the behavior difference between the engine
 	// and script interfaces that logically script sees matrices as column major, while
 	// the engine stores them in row major to efficiently take advantage of SIMD

include/core/CameraMatrix.hpp

@@ -0,0 +1,124 @@
+/*************************************************************************/
+/*  CameraMatrix.hpp                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef CAMERA_MATRIX_H
+#define CAMERA_MATRIX_H
+
+#include "Defs.hpp"
+#include "Math.hpp"
+#include "Plane.hpp"
+#include "Rect2.hpp"
+#include "Transform.hpp"
+
+#include <vector>
+
+namespace {
+using namespace godot;
+} // namespace
+
+struct CameraMatrix {
+	enum Planes {
+		PLANE_NEAR,
+		PLANE_FAR,
+		PLANE_LEFT,
+		PLANE_TOP,
+		PLANE_RIGHT,
+		PLANE_BOTTOM
+	};
+
+	real_t matrix[4][4];
+
+	void set_identity();
+	void set_zero();
+	void set_light_bias();
+	void set_light_atlas_rect(const Rect2 &p_rect);
+	void set_perspective(real_t p_fovy_degrees, real_t p_aspect, real_t p_z_near, real_t p_z_far, bool p_flip_fov = false);
+	void set_perspective(real_t p_fovy_degrees, real_t p_aspect, real_t p_z_near, real_t p_z_far, bool p_flip_fov, int p_eye, real_t p_intraocular_dist, real_t p_convergence_dist);
+	void set_for_hmd(int p_eye, real_t p_aspect, real_t p_intraocular_dist, real_t p_display_width, real_t p_display_to_lens, real_t p_oversample, real_t p_z_near, real_t p_z_far);
+	void set_orthogonal(real_t p_left, real_t p_right, real_t p_bottom, real_t p_top, real_t p_znear, real_t p_zfar);
+	void set_orthogonal(real_t p_size, real_t p_aspect, real_t p_znear, real_t p_zfar, bool p_flip_fov = false);
+	void set_frustum(real_t p_left, real_t p_right, real_t p_bottom, real_t p_top, real_t p_near, real_t p_far);
+	void set_frustum(real_t p_size, real_t p_aspect, Vector2 p_offset, real_t p_near, real_t p_far, bool p_flip_fov = false);
+
+	static real_t get_fovy(real_t p_fovx, real_t p_aspect) {
+		return Math::rad2deg(atan(p_aspect * tan(Math::deg2rad(p_fovx) * 0.5)) * 2.0);
+	}
+
+	static inline double absd(double g) {
+		union {
+			double d;
+			uint64_t i;
+		} u;
+		u.d = g;
+		u.i &= (uint64_t)9223372036854775807ll;
+		return u.d;
+	}
+
+	real_t get_z_far() const;
+	real_t get_z_near() const;
+	real_t get_aspect() const;
+	real_t get_fov() const;
+	bool is_orthogonal() const;
+
+	std::vector<Plane> get_projection_planes(const Transform &p_transform) const;
+
+	bool get_endpoints(const Transform &p_transform, Vector3 *p_8points) const;
+	Vector2 get_viewport_half_extents() const;
+
+	void invert();
+	CameraMatrix inverse() const;
+
+	CameraMatrix operator*(const CameraMatrix &p_matrix) const;
+
+	Plane xform4(const Plane &p_vec4) const;
+	inline Vector3 xform(const Vector3 &p_vec3) const;
+
+	operator String() const;
+
+	void scale_translate_to_fit(const AABB &p_aabb);
+	void make_scale(const Vector3 &p_scale);
+	int get_pixels_per_meter(int p_for_pixel_width) const;
+	operator Transform() const;
+
+	CameraMatrix();
+	CameraMatrix(const Transform &p_transform);
+	~CameraMatrix();
+};
+
+Vector3 CameraMatrix::xform(const Vector3 &p_vec3) const {
+	Vector3 ret;
+	ret.x = matrix[0][0] * p_vec3.x + matrix[1][0] * p_vec3.y + matrix[2][0] * p_vec3.z + matrix[3][0];
+	ret.y = matrix[0][1] * p_vec3.x + matrix[1][1] * p_vec3.y + matrix[2][1] * p_vec3.z + matrix[3][1];
+	ret.z = matrix[0][2] * p_vec3.x + matrix[1][2] * p_vec3.y + matrix[2][2] * p_vec3.z + matrix[3][2];
+	real_t w = matrix[0][3] * p_vec3.x + matrix[1][3] * p_vec3.y + matrix[2][3] * p_vec3.z + matrix[3][3];
+	return ret / w;
+}
+
+#endif

include/core/Color.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Color.hpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef COLOR_H
 #define COLOR_H
 
@@ -5,17 +35,16 @@
 
 #include <cmath>
 
+#include "Defs.hpp"
 #include "String.hpp"
 
 namespace godot {
 
 struct Color {
-
 private:
 	// static float _parse_col(const String& p_str, int p_ofs);
 public:
 	union {
-
 		struct {
 			float r;
 			float g;
@@ -73,6 +102,23 @@ public:
 		return components[idx];
 	}
 
+	Color operator+(const Color &p_color) const;
+	void operator+=(const Color &p_color);
+
+	Color operator-() const;
+	Color operator-(const Color &p_color) const;
+	void operator-=(const Color &p_color);
+
+	Color operator*(const Color &p_color) const;
+	Color operator*(const real_t &rvalue) const;
+	void operator*=(const Color &p_color);
+	void operator*=(const real_t &rvalue);
+
+	Color operator/(const Color &p_color) const;
+	Color operator/(const real_t &rvalue) const;
+	void operator/=(const Color &p_color);
+	void operator/=(const real_t &rvalue);
+
 	void invert();
 
 	void contrast();

include/core/CoreTypes.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  CoreTypes.hpp                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef CORETYPES_H
 #define CORETYPES_H
 

include/core/Defs.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Defs.hpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef DEFS_H
 #define DEFS_H
 
@@ -53,19 +83,28 @@ enum class Error {
 	ERR_HELP, ///< user requested help!!
 	ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior.
 	ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames
-	ERR_OMFG_THIS_IS_VERY_VERY_BAD, ///< shit happens, has never been used, though
-	ERR_WTF = ERR_OMFG_THIS_IS_VERY_VERY_BAD ///< short version of the above
 };
 
 } // namespace godot
 
 #include <GodotGlobal.hpp>
 
+// alloca() is non-standard. When using MSVC, it's in malloc.h.
+#if defined(__linux__) || defined(__APPLE__)
+#include <alloca.h>
+#else
+#include <malloc.h>
+#endif
+
 typedef float real_t;
 
-#define CMP_EPSILON 0.00001
+// This epsilon should match the one used by Godot for consistency.
+// Using `f` when `real_t` is float.
+#define CMP_EPSILON 0.00001f
 #define CMP_EPSILON2 (CMP_EPSILON * CMP_EPSILON)
-#define Math_PI 3.14159265358979323846
+
+#define Math_PI 3.1415926535897932384626433833
+#define Math_TAU 6.2831853071795864769252867666
 
 #define _PLANE_EQ_DOT_EPSILON 0.999
 #define _PLANE_EQ_D_EPSILON 0.0001
@@ -197,7 +236,7 @@ typedef float real_t;
 	do {                                     \
 		if (unlikely(cond)) {                \
 			FATAL_PRINT(ERR_MSG_COND(cond)); \
-			return;                          \
+			GENERATE_TRAP;                   \
 		}                                    \
 	} while (0)
 #endif

include/core/Dictionary.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Dictionary.hpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef DICTIONARY_H
 #define DICTIONARY_H
 
@@ -12,6 +42,11 @@ namespace godot {
 class Dictionary {
 	godot_dictionary _godot_dictionary;
 
+	friend Variant::operator Dictionary() const;
+	inline explicit Dictionary(const godot_dictionary &other) {
+		_godot_dictionary = other;
+	}
+
 public:
 	Dictionary();
 	Dictionary(const Dictionary &other);

include/core/Godot.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Godot.hpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef GODOT_HPP
 #define GODOT_HPP
 
@@ -17,60 +47,115 @@
 
 #include "GodotGlobal.hpp"
 
-#include <GDNativeLibrary.hpp>
-#include <NativeScript.hpp>
+#include <type_traits>
 
 namespace godot {
+namespace detail {
 
-template <class T>
-T *as(const Object *obj) {
-	return (obj) ? (T *)godot::nativescript_api->godot_nativescript_get_userdata(obj->_owner) : nullptr;
-}
-
+// Godot classes are wrapped by heap-allocated instances mimicking them through the C API.
+// They all inherit `_Wrapped`.
 template <class T>
 T *get_wrapper(godot_object *obj) {
 	return (T *)godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, obj);
 }
 
-#define GODOT_CLASS(Name, Base)                                                                                                                     \
-                                                                                                                                                    \
-public:                                                                                                                                             \
-	inline static const char *___get_type_name() { return static_cast<const char *>(#Name); }                                                       \
-	enum { ___CLASS_IS_SCRIPT = 1,                                                                                                                  \
-	};                                                                                                                                              \
-	inline static Name *_new() {                                                                                                                    \
-		godot::NativeScript *script = godot::NativeScript::_new();                                                                                  \
-		script->set_library(godot::get_wrapper<godot::GDNativeLibrary>((godot_object *)godot::gdnlib));                                             \
-		script->set_class_name(#Name);                                                                                                              \
-		Name *instance = godot::as<Name>(script->new_());                                                                                           \
-		return instance;                                                                                                                            \
-	}                                                                                                                                               \
-	inline static size_t ___get_id() { return typeid(Name).hash_code(); }                                                                          \
-	inline static size_t ___get_base_id() { return typeid(Base).hash_code(); }                                                                     \
-	inline static const char *___get_base_type_name() { return Base::___get_class_name(); }                                                         \
-	inline static Object *___get_from_variant(godot::Variant a) { return (godot::Object *)godot::as<Name>(godot::Object::___get_from_variant(a)); } \
-                                                                                                                                                    \
+// Custom class instances are not obtainable by just casting the pointer to the base class they inherit,
+// partly because in Godot, scripts are not instances of the classes themselves, they are only attached to them.
+// Yet we want to "fake" it as if they were the same entity.
+template <class T>
+T *get_custom_class_instance(const Object *obj) {
+	return (obj) ? (T *)godot::nativescript_api->godot_nativescript_get_userdata(obj->_owner) : nullptr;
+}
+
+template <class T>
+inline T *create_custom_class_instance() {
+	// Usually, script instances hold a reference to their NativeScript resource.
+	// that resource is obtained from a `.gdns` file, which in turn exists because
+	// of the resource system of Godot. We can't cleanly hardcode that here,
+	// so the easiest for now (though not really clean) is to create new resource instances,
+	// individually attached to the script instances.
+
+	// We cannot use wrappers because of https://github.com/godotengine/godot/issues/39181
+	//	godot::NativeScript *script = godot::NativeScript::_new();
+	//	script->set_library(get_wrapper<godot::GDNativeLibrary>((godot_object *)godot::gdnlib));
+	//	script->set_class_name(T::___get_class_name());
+
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+
+	// So we use the C API directly.
+	static godot_class_constructor script_constructor = godot::api->godot_get_class_constructor("NativeScript");
+	static godot_method_bind *mb_set_library = godot::api->godot_method_bind_get_method("NativeScript", "set_library");
+	static godot_method_bind *mb_set_class_name = godot::api->godot_method_bind_get_method("NativeScript", "set_class_name");
+	godot_object *script = script_constructor();
+	{
+		const void *args[] = { godot::gdnlib };
+		godot::api->godot_method_bind_ptrcall(mb_set_library, script, args, nullptr);
+	}
+	{
+		const String class_name = T::___get_class_name();
+		const void *args[] = { &class_name };
+		godot::api->godot_method_bind_ptrcall(mb_set_class_name, script, args, nullptr);
+	}
+
+	// Now to instanciate T, we initially did this, however in case of Reference it returns a variant with refcount
+	// already initialized, which woud cause inconsistent behavior compared to other classes (we still have to return a pointer).
+	//Variant instance_variant = script->new_();
+	//T *instance = godot::get_custom_class_instance<T>(instance_variant);
+
+	// So we should do this instead, however while convenient, it uses unnecessary wrapper objects.
+	//	Object *base_obj = T::___new_godot_base();
+	//	base_obj->set_script(script);
+	//	return get_custom_class_instance<T>(base_obj);
+
+	// Again using the C API to do exactly what we have to do.
+	static godot_class_constructor base_constructor = godot::api->godot_get_class_constructor(T::___get_godot_class_name());
+	static godot_method_bind *mb_set_script = godot::api->godot_method_bind_get_method("Object", "set_script");
+	godot_object *base_obj = base_constructor();
+	{
+		const void *args[] = { script };
+		godot::api->godot_method_bind_ptrcall(mb_set_script, base_obj, args, nullptr);
+	}
+
+	return (T *)godot::nativescript_api->godot_nativescript_get_userdata(base_obj);
+}
+
+} // namespace detail
+
+// Used in the definition of a custom class.
+//
+// Name:                       Name of your class, without namespace
+// Base:                       Name of the direct base class, with namespace if necessary
+//
+// ___get_class_name:          Name of the class
+// ___get_godot_class_name:    Name of the Godot base class this class inherits from (i.e not direct)
+// _new:                       Creates a new instance of the class
+// ___get_id:                  Gets the unique ID of the class. Godot and custom classes are both within that set.
+// ___get_base_id:             Gets the ID of the direct base class, as returned by ___get_id
+// ___get_base_class_name:     Name of the direct base class
+// ___get_from_variant:        Converts a Variant into an Object*. Will be non-null if the class matches.
+#define GODOT_CLASS(Name, Base)                                                              \
+                                                                                             \
+public:                                                                                      \
+	inline static const char *___get_class_name() { return #Name; }                          \
+	enum { ___CLASS_IS_SCRIPT = 1 };                                                         \
+	inline static const char *___get_godot_class_name() {                                    \
+		return Base::___get_godot_class_name();                                              \
+	}                                                                                        \
+	inline static Name *_new() {                                                             \
+		return godot::detail::create_custom_class_instance<Name>();                          \
+	}                                                                                        \
+	inline static size_t ___get_id() { return typeid(Name).hash_code(); }                    \
+	inline static size_t ___get_base_id() { return Base::___get_id(); }                      \
+	inline static const char *___get_base_class_name() { return Base::___get_class_name(); } \
+	inline static godot::Object *___get_from_variant(godot::Variant a) {                     \
+		return (godot::Object *)godot::detail::get_custom_class_instance<Name>(              \
+				godot::Object::___get_from_variant(a));                                      \
+	}                                                                                        \
+                                                                                             \
 private:
 
-#define GODOT_SUBCLASS(Name, Base)                                                                                                                  \
-                                                                                                                                                    \
-public:                                                                                                                                             \
-	inline static const char *___get_type_name() { return static_cast<const char *>(#Name); }                                                       \
-	enum { ___CLASS_IS_SCRIPT = 1,                                                                                                                  \
-	};                                                                                                                                              \
-	inline static Name *_new() {                                                                                                                    \
-		godot::NativeScript *script = godot::NativeScript::_new();                                                                                  \
-		script->set_library(godot::get_wrapper<godot::GDNativeLibrary>((godot_object *)godot::gdnlib));                                             \
-		script->set_class_name(#Name);                                                                                                              \
-		Name *instance = godot::as<Name>(script->new_());                                                                                           \
-		return instance;                                                                                                                            \
-	}                                                                                                                                               \
-	inline static size_t ___get_id() { return typeid(Name).hash_code(); };                                                                          \
-	inline static size_t ___get_base_id() { return typeid(Base).hash_code(); };                                                                     \
-	inline static const char *___get_base_type_name() { return #Base; }                                                                             \
-	inline static Object *___get_from_variant(godot::Variant a) { return (godot::Object *)godot::as<Name>(godot::Object::___get_from_variant(a)); } \
-                                                                                                                                                    \
-private:
+// Legacy compatibility
+#define GODOT_SUBCLASS(Name, Base) GODOT_CLASS(Name, Base)
 
 template <class T>
 struct _ArgCast {
@@ -96,7 +181,7 @@ struct _ArgCast<Variant> {
 // instance and destroy funcs
 
 template <class T>
-void *_godot_class_instance_func(godot_object *p, void *method_data) {
+void *_godot_class_instance_func(godot_object *p, void * /*method_data*/) {
 	T *d = new T();
 	d->_owner = p;
 	d->_type_tag = typeid(T).hash_code();
@@ -105,13 +190,15 @@ void *_godot_class_instance_func(godot_object *p, void *method_data) {
 }
 
 template <class T>
-void _godot_class_destroy_func(godot_object *p, void *method_data, void *data) {
+void _godot_class_destroy_func(godot_object * /*p*/, void * /*method_data*/, void *data) {
 	T *d = (T *)data;
 	delete d;
 }
 
 template <class T>
 void register_class() {
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+
 	godot_instance_create_func create = {};
 	create.create_func = _godot_class_instance_func<T>;
 
@@ -120,13 +207,19 @@ void register_class() {
 
 	_TagDB::register_type(T::___get_id(), T::___get_base_id());
 
-	godot::nativescript_api->godot_nativescript_register_class(godot::_RegisterState::nativescript_handle, T::___get_type_name(), T::___get_base_type_name(), create, destroy);
-	godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, T::___get_type_name(), (const void *)typeid(T).hash_code());
+	godot::nativescript_api->godot_nativescript_register_class(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), T::___get_base_class_name(), create, destroy);
+
+	godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), (const void *)T::___get_id());
+
 	T::_register_methods();
 }
 
 template <class T>
 void register_tool_class() {
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+
 	godot_instance_create_func create = {};
 	create.create_func = _godot_class_instance_func<T>;
 
@@ -135,8 +228,12 @@ void register_tool_class() {
 
 	_TagDB::register_type(T::___get_id(), T::___get_base_id());
 
-	godot::nativescript_api->godot_nativescript_register_tool_class(godot::_RegisterState::nativescript_handle, T::___get_type_name(), T::___get_base_type_name(), create, destroy);
-	godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, T::___get_type_name(), (const void *)typeid(T).hash_code());
+	godot::nativescript_api->godot_nativescript_register_tool_class(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), T::___get_base_class_name(), create, destroy);
+
+	godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), (const void *)T::___get_id());
+
 	T::_register_methods();
 }
 
@@ -146,12 +243,17 @@ typedef godot_variant (*__godot_wrapper_method)(godot_object *, void *, void *,
 
 template <class T, class R, class... args>
 const char *___get_method_class_name(R (T::*p)(args... a)) {
-	return T::___get_type_name();
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+	(void)p; // To avoid "unused parameter" warnings. `p` is required for template matching.
+	return T::___get_class_name();
 }
 
+// This second version is also required to match constant functions
 template <class T, class R, class... args>
 const char *___get_method_class_name(R (T::*p)(args... a) const) {
-	return T::___get_type_name();
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+	(void)p; // To avoid "unused parameter" warnings. `p` is required for template matching.
+	return T::___get_class_name();
 }
 
 // Okay, time for some template magic.
@@ -189,13 +291,13 @@ struct _WrappedMethod<T, void, As...> {
 	void (T::*f)(As...);
 
 	template <int... I>
-	void apply(Variant *ret, T *obj, Variant **args, __Sequence<I...>) {
+	void apply(Variant * /*ret*/, T *obj, Variant **args, __Sequence<I...>) {
 		(obj->*f)(_ArgCast<As>::_arg_cast(*args[I])...);
 	}
 };
 
 template <class T, class R, class... As>
-godot_variant __wrapped_method(godot_object *, void *method_data, void *user_data, int num_args, godot_variant **args) {
+godot_variant __wrapped_method(godot_object *, void *method_data, void *user_data, int /*num_args*/, godot_variant **args) {
 	godot_variant v;
 	godot::api->godot_variant_new_nil(&v);
 
@@ -219,7 +321,7 @@ void *___make_wrapper_function(R (T::*f)(As...)) {
 }
 
 template <class T, class R, class... As>
-__godot_wrapper_method ___get_wrapper_function(R (T::*f)(As...)) {
+__godot_wrapper_method ___get_wrapper_function(R (T::* /*f*/)(As...)) {
 	return (__godot_wrapper_method)&__wrapped_method<T, R, As...>;
 }
 
@@ -243,13 +345,22 @@ void register_method(const char *name, M method_ptr, godot_method_rpc_mode rpc_t
 	godot_method_attributes attr = {};
 	attr.rpc_type = rpc_type;
 
-	godot::nativescript_api->godot_nativescript_register_method(godot::_RegisterState::nativescript_handle, ___get_method_class_name(method_ptr), name, attr, method);
+	godot::nativescript_api->godot_nativescript_register_method(godot::_RegisterState::nativescript_handle,
+			___get_method_class_name(method_ptr), name, attr, method);
+}
+
+// User can specify a derived class D to register the method for, instead of it being inferred.
+template <class D, class B, class R, class... As>
+void register_method_explicit(const char *name, R (B::*method_ptr)(As...),
+		godot_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED) {
+	static_assert(std::is_base_of<B, D>::value, "Explicit class must derive from method class");
+	register_method(name, static_cast<R (D::*)(As...)>(method_ptr), rpc_type);
 }
 
 template <class T, class P>
 struct _PropertySetFunc {
 	void (T::*f)(P);
-	static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value) {
+	static void _wrapped_setter(godot_object * /*object*/, void *method_data, void *user_data, godot_variant *value) {
 		_PropertySetFunc<T, P> *set_func = (_PropertySetFunc<T, P> *)method_data;
 		T *obj = (T *)user_data;
 
@@ -263,7 +374,7 @@ template <class T, class P>
 struct _PropertyGetFunc {
 	P(T::*f)
 	();
-	static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data) {
+	static godot_variant _wrapped_getter(godot_object * /*object*/, void *method_data, void *user_data) {
 		_PropertyGetFunc<T, P> *get_func = (_PropertyGetFunc<T, P> *)method_data;
 		T *obj = (T *)user_data;
 
@@ -281,7 +392,7 @@ struct _PropertyGetFunc {
 template <class T, class P>
 struct _PropertyDefaultSetFunc {
 	P(T::*f);
-	static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value) {
+	static void _wrapped_setter(godot_object * /*object*/, void *method_data, void *user_data, godot_variant *value) {
 		_PropertyDefaultSetFunc<T, P> *set_func = (_PropertyDefaultSetFunc<T, P> *)method_data;
 		T *obj = (T *)user_data;
 
@@ -294,7 +405,7 @@ struct _PropertyDefaultSetFunc {
 template <class T, class P>
 struct _PropertyDefaultGetFunc {
 	P(T::*f);
-	static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data) {
+	static godot_variant _wrapped_getter(godot_object * /*object*/, void *method_data, void *user_data) {
 		_PropertyDefaultGetFunc<T, P> *get_func = (_PropertyDefaultGetFunc<T, P> *)method_data;
 		T *obj = (T *)user_data;
 
@@ -310,13 +421,18 @@ struct _PropertyDefaultGetFunc {
 };
 
 template <class T, class P>
-void register_property(const char *name, P(T::*var), P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
+void register_property(const char *name, P(T::*var), P default_value,
+		godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,
+		godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT,
+		godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+
 	Variant def_val = default_value;
 
 	usage = (godot_property_usage_flags)((int)usage | GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE);
 
 	if (def_val.get_type() == Variant::OBJECT) {
-		Object *o = get_wrapper<Object>(def_val.operator godot_object *());
+		Object *o = detail::get_wrapper<Object>(def_val.operator godot_object *());
 		if (o && o->is_class("Resource")) {
 			hint = (godot_property_hint)((int)hint | GODOT_PROPERTY_HINT_RESOURCE_TYPE);
 			hint_string = o->get_class();
@@ -338,10 +454,12 @@ void register_property(const char *name, P(T::*var), P default_value, godot_meth
 	attr.usage = usage;
 	attr.hint_string = *_hint_string;
 
-	_PropertyDefaultSetFunc<T, P> *wrapped_set = (_PropertyDefaultSetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultSetFunc<T, P>));
+	_PropertyDefaultSetFunc<T, P> *wrapped_set =
+			(_PropertyDefaultSetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultSetFunc<T, P>));
 	wrapped_set->f = var;
 
-	_PropertyDefaultGetFunc<T, P> *wrapped_get = (_PropertyDefaultGetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultGetFunc<T, P>));
+	_PropertyDefaultGetFunc<T, P> *wrapped_get =
+			(_PropertyDefaultGetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultGetFunc<T, P>));
 	wrapped_get->f = var;
 
 	godot_property_set_func set_func = {};
@@ -354,11 +472,17 @@ void register_property(const char *name, P(T::*var), P default_value, godot_meth
 	get_func.free_func = godot::api->godot_free;
 	get_func.get_func = &_PropertyDefaultGetFunc<T, P>::_wrapped_getter;
 
-	godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle, T::___get_type_name(), name, &attr, set_func, get_func);
+	godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), name, &attr, set_func, get_func);
 }
 
 template <class T, class P>
-void register_property(const char *name, void (T::*setter)(P), P (T::*getter)(), P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
+void register_property(const char *name, void (T::*setter)(P), P (T::*getter)(), P default_value,
+		godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,
+		godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT,
+		godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+
 	Variant def_val = default_value;
 
 	godot_string *_hint_string = (godot_string *)&hint_string;
@@ -391,16 +515,22 @@ void register_property(const char *name, void (T::*setter)(P), P (T::*getter)(),
 	get_func.free_func = godot::api->godot_free;
 	get_func.get_func = &_PropertyGetFunc<T, P>::_wrapped_getter;
 
-	godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle, T::___get_type_name(), name, &attr, set_func, get_func);
+	godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), name, &attr, set_func, get_func);
 }
 
 template <class T, class P>
-void register_property(const char *name, void (T::*setter)(P), P (T::*getter)() const, P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
+void register_property(const char *name, void (T::*setter)(P), P (T::*getter)() const, P default_value,
+		godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,
+		godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT,
+		godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
 	register_property(name, setter, (P(T::*)())getter, default_value, rpc_mode, usage, hint, hint_string);
 }
 
 template <class T>
-void register_signal(String name, Dictionary args = Dictionary()) {
+void register_signal(String name, Dictionary args) {
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+
 	godot_signal signal = {};
 	signal.name = *(godot_string *)&name;
 	signal.num_args = args.size();
@@ -425,7 +555,8 @@ void register_signal(String name, Dictionary args = Dictionary()) {
 		signal.args[i].type = args.values()[i];
 	}
 
-	godot::nativescript_api->godot_nativescript_register_signal(godot::_RegisterState::nativescript_handle, T::___get_type_name(), &signal);
+	godot::nativescript_api->godot_nativescript_register_signal(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), &signal);
 
 	for (int i = 0; i < signal.num_args; i++) {
 		godot::api->godot_string_destroy(&signal.args[i].name);
@@ -441,32 +572,48 @@ void register_signal(String name, Args... varargs) {
 	register_signal<T>(name, Dictionary::make(varargs...));
 }
 
+template <class T>
+void register_signal(String name) {
+	static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes");
+
+	godot_signal signal = {};
+	signal.name = *(godot_string *)&name;
+
+	godot::nativescript_api->godot_nativescript_register_signal(godot::_RegisterState::nativescript_handle,
+			T::___get_class_name(), &signal);
+}
+
 #ifndef GODOT_CPP_NO_OBJECT_CAST
 template <class T>
 T *Object::cast_to(const Object *obj) {
 	if (!obj)
 		return nullptr;
 
-	size_t have_tag = (size_t)godot::nativescript_1_1_api->godot_nativescript_get_type_tag(obj->_owner);
+	if (T::___CLASS_IS_SCRIPT) {
+		size_t have_tag = (size_t)godot::nativescript_1_1_api->godot_nativescript_get_type_tag(obj->_owner);
+		if (have_tag) {
+			if (!godot::_TagDB::is_type_known((size_t)have_tag)) {
+				have_tag = 0;
+			}
+		}
 
-	if (have_tag) {
-		if (!godot::_TagDB::is_type_known((size_t)have_tag)) {
-			have_tag = 0;
+		if (!have_tag) {
+			have_tag = obj->_type_tag;
+		}
+
+		if (godot::_TagDB::is_type_compatible(T::___get_id(), have_tag)) {
+			return detail::get_custom_class_instance<T>(obj);
+		}
+	} else {
+		if (godot::core_1_2_api->godot_object_cast_to(obj->_owner, (void *)T::___get_id())) {
+			return (T *)obj;
 		}
 	}
 
-	if (!have_tag) {
-		have_tag = obj->_type_tag;
-	}
-
-	if (godot::_TagDB::is_type_compatible(typeid(T).hash_code(), have_tag)) {
-		return (T::___CLASS_IS_SCRIPT) ? godot::as<T>(obj) : (T *)obj;
-	} else {
-		return nullptr;
-	}
+	return nullptr;
 }
 #endif
 
 } // namespace godot
 
-#endif // GODOT_H
+#endif // GODOT_HPP

include/core/GodotGlobal.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  GodotGlobal.hpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef GODOT_GLOBAL_HPP
 #define GODOT_GLOBAL_HPP
 
@@ -23,7 +53,6 @@ extern "C" const godot_gdnative_ext_net_3_2_api_struct *net_3_2_api;
 extern "C" const void *gdnlib;
 
 class Godot {
-
 public:
 	static void print(const String &message);
 	static void print_warning(const String &description, const String &function, const String &file, int line);

include/core/GodotProfiling.hpp

@@ -1,9 +1,38 @@
+/*************************************************************************/
+/*  GodotProfiling.hpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef GODOT_PROFILING_HPP
 #define GODOT_PROFILING_HPP
 
 #include "OS.hpp"
 
-
 namespace godot {
 
 class FunctionProfiling {
@@ -23,7 +52,7 @@ public:
 	}
 };
 
-}
+} // namespace godot
 
 #ifdef DEBUG_ENABLED
 #define GODOT_PROFILING_FUNCTION FunctionProfiling __function_profiling(__FUNCTION__, __LINE__);

include/core/Math.hpp

@@ -0,0 +1,302 @@
+/*************************************************************************/
+/*  Math.hpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef GODOT_MATH_H
+#define GODOT_MATH_H
+
+#include "Defs.hpp"
+#include <cmath>
+
+namespace godot {
+namespace Math {
+
+// Functions reproduced as in Godot's source code `math_funcs.h`.
+// Some are overloads to automatically support changing real_t into either double or float in the way Godot does.
+
+inline double fmod(double p_x, double p_y) {
+	return ::fmod(p_x, p_y);
+}
+inline float fmod(float p_x, float p_y) {
+	return ::fmodf(p_x, p_y);
+}
+
+inline double floor(double p_x) {
+	return ::floor(p_x);
+}
+inline float floor(float p_x) {
+	return ::floorf(p_x);
+}
+
+inline double exp(double p_x) {
+	return ::exp(p_x);
+}
+inline float exp(float p_x) {
+	return ::expf(p_x);
+}
+
+inline double sin(double p_x) {
+	return ::sin(p_x);
+}
+inline float sin(float p_x) {
+	return ::sinf(p_x);
+}
+
+inline double cos(double p_x) {
+	return ::cos(p_x);
+}
+inline float cos(float p_x) {
+	return ::cosf(p_x);
+}
+
+inline double tan(double p_x) {
+	return ::tan(p_x);
+}
+inline float tan(float p_x) {
+	return ::tanf(p_x);
+}
+
+inline double asin(double p_x) {
+	return ::asin(p_x);
+}
+inline float asin(float p_x) {
+	return ::asinf(p_x);
+}
+
+inline double acos(double p_x) {
+	return ::acos(p_x);
+}
+inline float acos(float p_x) {
+	return ::acosf(p_x);
+}
+
+inline double atan(double p_x) {
+	return ::atan(p_x);
+}
+inline float atan(float p_x) {
+	return ::atanf(p_x);
+}
+
+inline double atan2(double p_y, double p_x) {
+	return ::atan2(p_y, p_x);
+}
+inline float atan2(float p_y, float p_x) {
+	return ::atan2f(p_y, p_x);
+}
+
+inline double sqrt(double p_x) {
+	return ::sqrt(p_x);
+}
+inline float sqrt(float p_x) {
+	return ::sqrtf(p_x);
+}
+
+inline float lerp(float minv, float maxv, float t) {
+	return minv + t * (maxv - minv);
+}
+inline double lerp(double minv, double maxv, double t) {
+	return minv + t * (maxv - minv);
+}
+
+inline double lerp_angle(double p_from, double p_to, double p_weight) {
+	double difference = fmod(p_to - p_from, Math_TAU);
+	double distance = fmod(2.0 * difference, Math_TAU) - difference;
+	return p_from + distance * p_weight;
+}
+inline float lerp_angle(float p_from, float p_to, float p_weight) {
+	float difference = fmod(p_to - p_from, (float)Math_TAU);
+	float distance = fmod(2.0f * difference, (float)Math_TAU) - difference;
+	return p_from + distance * p_weight;
+}
+
+template <typename T>
+inline T clamp(T x, T minv, T maxv) {
+	if (x < minv) {
+		return minv;
+	}
+	if (x > maxv) {
+		return maxv;
+	}
+	return x;
+}
+
+template <typename T>
+inline T min(T a, T b) {
+	return a < b ? a : b;
+}
+
+template <typename T>
+inline T max(T a, T b) {
+	return a > b ? a : b;
+}
+
+template <typename T>
+inline T sign(T x) {
+	return static_cast<T>(x < 0 ? -1 : 1);
+}
+
+inline double deg2rad(double p_y) {
+	return p_y * Math_PI / 180.0;
+}
+inline float deg2rad(float p_y) {
+	return p_y * static_cast<float>(Math_PI) / 180.f;
+}
+
+inline double rad2deg(double p_y) {
+	return p_y * 180.0 / Math_PI;
+}
+inline float rad2deg(float p_y) {
+	return p_y * 180.f / static_cast<float>(Math_PI);
+}
+
+inline double inverse_lerp(double p_from, double p_to, double p_value) {
+	return (p_value - p_from) / (p_to - p_from);
+}
+inline float inverse_lerp(float p_from, float p_to, float p_value) {
+	return (p_value - p_from) / (p_to - p_from);
+}
+
+inline double range_lerp(double p_value, double p_istart, double p_istop, double p_ostart, double p_ostop) {
+	return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value));
+}
+inline float range_lerp(float p_value, float p_istart, float p_istop, float p_ostart, float p_ostop) {
+	return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value));
+}
+
+inline bool is_equal_approx(real_t a, real_t b) {
+	// Check for exact equality first, required to handle "infinity" values.
+	if (a == b) {
+		return true;
+	}
+	// Then check for approximate equality.
+	real_t tolerance = CMP_EPSILON * std::abs(a);
+	if (tolerance < CMP_EPSILON) {
+		tolerance = CMP_EPSILON;
+	}
+	return std::abs(a - b) < tolerance;
+}
+
+inline bool is_equal_approx(real_t a, real_t b, real_t tolerance) {
+	// Check for exact equality first, required to handle "infinity" values.
+	if (a == b) {
+		return true;
+	}
+	// Then check for approximate equality.
+	return std::abs(a - b) < tolerance;
+}
+
+inline bool is_zero_approx(real_t s) {
+	return std::abs(s) < CMP_EPSILON;
+}
+
+inline double smoothstep(double p_from, double p_to, double p_weight) {
+	if (is_equal_approx(static_cast<real_t>(p_from), static_cast<real_t>(p_to))) {
+		return p_from;
+	}
+	double x = clamp((p_weight - p_from) / (p_to - p_from), 0.0, 1.0);
+	return x * x * (3.0 - 2.0 * x);
+}
+inline float smoothstep(float p_from, float p_to, float p_weight) {
+	if (is_equal_approx(p_from, p_to)) {
+		return p_from;
+	}
+	float x = clamp((p_weight - p_from) / (p_to - p_from), 0.0f, 1.0f);
+	return x * x * (3.0f - 2.0f * x);
+}
+
+inline double move_toward(double p_from, double p_to, double p_delta) {
+	return std::abs(p_to - p_from) <= p_delta ? p_to : p_from + sign(p_to - p_from) * p_delta;
+}
+
+inline float move_toward(float p_from, float p_to, float p_delta) {
+	return std::abs(p_to - p_from) <= p_delta ? p_to : p_from + sign(p_to - p_from) * p_delta;
+}
+
+inline double linear2db(double p_linear) {
+	return log(p_linear) * 8.6858896380650365530225783783321;
+}
+inline float linear2db(float p_linear) {
+	return log(p_linear) * 8.6858896380650365530225783783321f;
+}
+
+inline double db2linear(double p_db) {
+	return exp(p_db * 0.11512925464970228420089957273422);
+}
+inline float db2linear(float p_db) {
+	return exp(p_db * 0.11512925464970228420089957273422f);
+}
+
+inline double round(double p_val) {
+	return (p_val >= 0) ? floor(p_val + 0.5) : -floor(-p_val + 0.5);
+}
+inline float round(float p_val) {
+	return (p_val >= 0) ? floor(p_val + 0.5f) : -floor(-p_val + 0.5f);
+}
+
+inline int64_t wrapi(int64_t value, int64_t min, int64_t max) {
+	int64_t range = max - min;
+	return range == 0 ? min : min + ((((value - min) % range) + range) % range);
+}
+
+inline float wrapf(real_t value, real_t min, real_t max) {
+	const real_t range = max - min;
+	return is_zero_approx(range) ? min : value - (range * floor((value - min) / range));
+}
+
+inline float stepify(float p_value, float p_step) {
+	if (p_step != 0) {
+		p_value = floor(p_value / p_step + 0.5f) * p_step;
+	}
+	return p_value;
+}
+inline double stepify(double p_value, double p_step) {
+	if (p_step != 0) {
+		p_value = floor(p_value / p_step + 0.5) * p_step;
+	}
+	return p_value;
+}
+
+inline unsigned int next_power_of_2(unsigned int x) {
+	if (x == 0)
+		return 0;
+
+	--x;
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+
+	return ++x;
+}
+
+} // namespace Math
+} // namespace godot
+
+#endif // GODOT_MATH_H

include/core/NodePath.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  NodePath.hpp                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef NODEPATH_H
 #define NODEPATH_H
 
@@ -10,6 +40,11 @@ namespace godot {
 class NodePath {
 	godot_node_path _node_path;
 
+	friend class Variant;
+	inline explicit NodePath(godot_node_path node_path) {
+		_node_path = node_path;
+	}
+
 public:
 	NodePath();
 

include/core/Plane.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Plane.hpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef PLANE_H
 #define PLANE_H
 

include/core/PoolArrays.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  PoolArrays.hpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef POOLARRAYS_H
 #define POOLARRAYS_H
 
@@ -18,9 +48,14 @@ class Array;
 class PoolByteArray {
 	godot_pool_byte_array _godot_array;
 
+	friend class String;
+	friend class Variant;
+	inline explicit PoolByteArray(godot_pool_byte_array a) {
+		_godot_array = a;
+	}
+
 public:
 	class Read {
-
 		friend class PoolByteArray;
 		godot_pool_byte_array_read_access *_read_access;
 
@@ -116,6 +151,11 @@ public:
 class PoolIntArray {
 	godot_pool_int_array _godot_array;
 
+	friend class Variant;
+	explicit inline PoolIntArray(godot_pool_int_array a) {
+		_godot_array = a;
+	}
+
 public:
 	class Read {
 		friend class PoolIntArray;
@@ -213,6 +253,11 @@ public:
 class PoolRealArray {
 	godot_pool_real_array _godot_array;
 
+	friend class Variant;
+	explicit inline PoolRealArray(godot_pool_real_array a) {
+		_godot_array = a;
+	}
+
 public:
 	class Read {
 		friend class PoolRealArray;
@@ -310,6 +355,12 @@ public:
 class PoolStringArray {
 	godot_pool_string_array _godot_array;
 
+	friend class String;
+	friend class Variant;
+	explicit inline PoolStringArray(godot_pool_string_array a) {
+		_godot_array = a;
+	}
+
 public:
 	class Read {
 		friend class PoolStringArray;
@@ -407,6 +458,11 @@ public:
 class PoolVector2Array {
 	godot_pool_vector2_array _godot_array;
 
+	friend class Variant;
+	explicit inline PoolVector2Array(godot_pool_vector2_array a) {
+		_godot_array = a;
+	}
+
 public:
 	class Read {
 		friend class PoolVector2Array;
@@ -504,6 +560,11 @@ public:
 class PoolVector3Array {
 	godot_pool_vector3_array _godot_array;
 
+	friend class Variant;
+	explicit inline PoolVector3Array(godot_pool_vector3_array a) {
+		_godot_array = a;
+	}
+
 public:
 	class Read {
 		friend class PoolVector3Array;
@@ -601,6 +662,11 @@ public:
 class PoolColorArray {
 	godot_pool_color_array _godot_array;
 
+	friend class Variant;
+	explicit inline PoolColorArray(godot_pool_color_array a) {
+		_godot_array = a;
+	}
+
 public:
 	class Read {
 		friend class PoolColorArray;

include/core/Quat.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Quat.hpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef QUAT_H
 #define QUAT_H
 
@@ -11,6 +41,8 @@ namespace godot {
 
 class Quat {
 public:
+	static const Quat IDENTITY;
+
 	real_t x, y, z, w;
 
 	real_t length_squared() const;

include/core/RID.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  RID.hpp                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef RID_H
 #define RID_H
 
@@ -15,7 +45,9 @@ public:
 
 	RID(Object *p);
 
-	int32_t get_rid() const;
+	godot_rid _get_godot_rid() const;
+
+	int32_t get_id() const;
 
 	inline bool is_valid() const {
 		// is_valid() is not available in the C API...

include/core/Rect2.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Rect2.hpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef RECT2_H
 #define RECT2_H
 
@@ -17,7 +47,6 @@ typedef Vector2 Point2;
 struct Transform2D;
 
 struct Rect2 {
-
 	Point2 position;
 	Size2 size;
 
@@ -48,14 +77,12 @@ struct Rect2 {
 	bool intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_position = nullptr, Point2 *r_normal = nullptr) const;
 
 	inline bool encloses(const Rect2 &p_rect) const {
-
 		return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) &&
 			   ((p_rect.position.x + p_rect.size.x) < (position.x + size.x)) &&
 			   ((p_rect.position.y + p_rect.size.y) < (position.y + size.y));
 	}
 
 	inline bool has_no_area() const {
-
 		return (size.x <= 0 || size.y <= 0);
 	}
 	Rect2 clip(const Rect2 &p_rect) const;
@@ -82,7 +109,6 @@ struct Rect2 {
 	inline bool operator!=(const Rect2 &p_rect) const { return position != p_rect.position || size != p_rect.size; }
 
 	inline Rect2 grow(real_t p_by) const {
-
 		Rect2 g = *this;
 		g.position.x -= p_by;
 		g.position.y -= p_by;
@@ -92,7 +118,6 @@ struct Rect2 {
 	}
 
 	inline Rect2 expand(const Vector2 &p_vector) const {
-
 		Rect2 r = *this;
 		r.expand_to(p_vector);
 		return r;

include/core/Ref.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Ref.hpp                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef REF_H
 #define REF_H
 
@@ -11,11 +41,14 @@ namespace godot {
 // Rewritten from f5234e70be7dec4930c2d5a0e829ff480d044b1d.
 template <class T>
 class Ref {
+	// TODO For this nice check to work, each class must actually #include Reference classes mentionned in its methods,
+	// which might be annoying for coders who prefer to forward-declare to reduce compile times
+	// static_assert(std::is_base_of<Reference, T>::value,
+	// 		"Ref<T> can only be used with classes deriving from Reference");
 
 	T *reference = nullptr;
 
 	void ref(const Ref &p_from) {
-
 		if (p_from.reference == reference)
 			return;
 
@@ -27,8 +60,7 @@ class Ref {
 	}
 
 	void ref_pointer(T *p_ref) {
-
-		ERR_FAIL_COND(!p_ref);
+		ERR_FAIL_COND(p_ref == nullptr);
 
 		if (p_ref->init_ref())
 			reference = p_ref;
@@ -36,44 +68,35 @@ class Ref {
 
 public:
 	inline bool operator<(const Ref<T> &p_r) const {
-
 		return reference < p_r.reference;
 	}
 	inline bool operator==(const Ref<T> &p_r) const {
-
 		return reference == p_r.reference;
 	}
 	inline bool operator!=(const Ref<T> &p_r) const {
-
 		return reference != p_r.reference;
 	}
 
 	inline T *operator->() {
-
 		return reference;
 	}
 
 	inline T *operator*() {
-
 		return reference;
 	}
 
 	inline const T *operator->() const {
-
 		return reference;
 	}
 
 	inline const T *ptr() const {
-
 		return reference;
 	}
 	inline T *ptr() {
-
 		return reference;
 	}
 
 	inline const T *operator*() const {
-
 		return reference;
 	}
 
@@ -84,68 +107,54 @@ public:
 	}
 
 	void operator=(const Ref &p_from) {
-
 		ref(p_from);
 	}
 
 	template <class T_Other>
 	void operator=(const Ref<T_Other> &p_from) {
-
-		// TODO We need a safe cast
 		Reference *refb = const_cast<Reference *>(static_cast<const Reference *>(p_from.ptr()));
-		if (!refb) {
+		if (refb == nullptr) {
 			unref();
 			return;
 		}
 		Ref r;
-		//r.reference = Object::cast_to<T>(refb);
-		r.reference = (T *)refb;
+		r.reference = Object::cast_to<T>(refb);
 		ref(r);
 		r.reference = nullptr;
 	}
 
 	void operator=(const Variant &p_variant) {
-
-		// TODO We need a safe cast
-		Reference *refb = (Reference *)T::___get_from_variant(p_variant);
-		if (!refb) {
+		Object *refb = T::___get_from_variant(p_variant);
+		if (refb == nullptr) {
 			unref();
 			return;
 		}
 		Ref r;
-		// TODO We need a safe cast
-		//r.reference = Object::cast_to<T>(refb);
-		r.reference = (T *)refb;
+		r.reference = Object::cast_to<T>(refb);
 		ref(r);
 		r.reference = nullptr;
 	}
 
 	Ref(const Ref &p_from) {
-
 		reference = nullptr;
 		ref(p_from);
 	}
 
 	template <class T_Other>
 	Ref(const Ref<T_Other> &p_from) {
-
 		reference = nullptr;
-		// TODO We need a safe cast
 		Reference *refb = const_cast<Reference *>(static_cast<const Reference *>(p_from.ptr()));
-		if (!refb) {
+		if (refb == nullptr) {
 			unref();
 			return;
 		}
 		Ref r;
-		// TODO We need a safe cast
-		//r.reference = Object::cast_to<T>(refb);
-		r.reference = (T *)refb;
+		r.reference = Object::cast_to<T>(refb);
 		ref(r);
 		r.reference = nullptr;
 	}
 
 	Ref(T *p_reference) {
-
 		if (p_reference)
 			ref_pointer(p_reference);
 		else
@@ -153,18 +162,14 @@ public:
 	}
 
 	Ref(const Variant &p_variant) {
-
 		reference = nullptr;
-		// TODO We need a safe cast
-		Reference *refb = (Reference *)T::___get_from_variant(p_variant);
-		if (!refb) {
+		Object *refb = T::___get_from_variant(p_variant);
+		if (refb == nullptr) {
 			unref();
 			return;
 		}
 		Ref r;
-		// TODO We need a safe cast
-		//r.reference = Object::cast_to<T>(refb);
-		r.reference = (T *)refb;
+		r.reference = Object::cast_to<T>(refb);
 		ref(r);
 		r.reference = nullptr;
 	}
@@ -178,7 +183,6 @@ public:
 		// mutexes will avoid more crashes?
 
 		if (reference && reference->unreference()) {
-
 			//memdelete(reference);
 			reference->free();
 		}
@@ -191,12 +195,10 @@ public:
 	}
 
 	Ref() {
-
 		reference = nullptr;
 	}
 
 	~Ref() {
-
 		unref();
 	}
 

include/core/String.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  String.hpp                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef STRING_H
 #define STRING_H
 
@@ -14,7 +44,6 @@ class PoolStringArray;
 class String;
 
 class CharString {
-
 	friend class String;
 
 	godot_char_string _char_string;
@@ -29,12 +58,19 @@ public:
 class String {
 	godot_string _godot_string;
 
+	friend class Dictionary;
+	friend class NodePath;
+	friend class Variant;
+	explicit inline String(godot_string contents) :
+			_godot_string(contents) {}
+
 public:
 	String();
 	String(const char *contents);
 	String(const wchar_t *contents);
 	String(const wchar_t c);
 	String(const String &other);
+	String(String &&other);
 
 	~String();
 
@@ -50,6 +86,7 @@ public:
 	wchar_t operator[](const int idx) const;
 
 	void operator=(const String &s);
+	void operator=(String &&s);
 	bool operator==(const String &s) const;
 	bool operator!=(const String &s) const;
 	String operator+(const String &s) const;
@@ -68,14 +105,14 @@ public:
 	CharString utf8() const;
 	CharString ascii(bool p_extended = false) const;
 
-	bool begins_with(String &s) const;
+	bool begins_with(const String &s) const;
 	bool begins_with_char_array(const char *p_char_array) const;
 	PoolStringArray bigrams() const;
 	String c_escape() const;
 	String c_unescape() const;
 	String capitalize() const;
 	bool empty() const;
-	bool ends_with(String &text) const;
+	bool ends_with(const String &text) const;
 	void erase(int position, int chars);
 	int find(String what, int from = 0) const;
 	int find_last(String what) const;

include/core/TagDB.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  TagDB.hpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef TAGDB_HPP
 #define TAGDB_HPP
 

include/core/Transform.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Transform.hpp                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef TRANSFORM_H
 #define TRANSFORM_H
 
@@ -10,6 +40,11 @@ namespace godot {
 
 class Transform {
 public:
+	static const Transform IDENTITY;
+	static const Transform FLIP_X;
+	static const Transform FLIP_Y;
+	static const Transform FLIP_Z;
+
 	Basis basis;
 	Vector3 origin;
 

include/core/Transform2D.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Transform2D.hpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef TRANSFORM2D_H
 #define TRANSFORM2D_H
 
@@ -10,6 +40,10 @@ typedef Vector2 Size2;
 struct Rect2;
 
 struct Transform2D {
+	static const Transform2D IDENTITY;
+	static const Transform2D FLIP_X;
+	static const Transform2D FLIP_Y;
+
 	// Warning #1: basis of Transform2D is stored differently from Basis. In terms of elements array, the basis matrix looks like "on paper":
 	// M = (elements[0][0] elements[1][0])
 	//     (elements[0][1] elements[1][1])

include/core/Variant.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Variant.hpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef VARIANT_H
 #define VARIANT_H
 
@@ -20,8 +50,6 @@
 #include "Vector2.hpp"
 #include "Vector3.hpp"
 
-#include <iostream>
-
 namespace godot {
 
 class Dictionary;
@@ -31,6 +59,11 @@ class Array;
 class Variant {
 	godot_variant _godot_variant;
 
+	friend class Array;
+	inline explicit Variant(godot_variant v) {
+		_godot_variant = v;
+	}
+
 public:
 	enum Type {
 
@@ -226,7 +259,9 @@ public:
 	operator NodePath() const;
 	operator RID() const;
 	operator godot_object *() const;
-	template <typename T> operator T*() const { return static_cast<T*>(T::___get_from_variant(*this)); }
+
+	template <typename T>
+	operator T *() const { return static_cast<T *>(T::___get_from_variant(*this)); }
 
 	operator Dictionary() const;
 	operator Array() const;

include/core/Vector2.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Vector2.hpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef VECTOR2_H
 #define VECTOR2_H
 
@@ -5,13 +35,28 @@
 
 #include "Defs.hpp"
 
-#include <cmath>
+#include <Math.hpp>
 
 namespace godot {
 
 class String;
 
 struct Vector2 {
+	enum Axis {
+		AXIS_X = 0,
+		AXIS_Y,
+		AXIS_COUNT
+	};
+
+	static const Vector2 ZERO;
+	static const Vector2 ONE;
+	static const Vector2 INF;
+
+	// Coordinate system of the 2D engine
+	static const Vector2 LEFT;
+	static const Vector2 RIGHT;
+	static const Vector2 UP;
+	static const Vector2 DOWN;
 
 	union {
 		real_t x;
@@ -138,6 +183,12 @@ struct Vector2 {
 		return atan2(y - p_vector2.y, x - p_vector2.x);
 	}
 
+	inline Vector2 direction_to(const Vector2 &p_b) const {
+		Vector2 ret(p_b.x - x, p_b.y - y);
+		ret.normalize();
+		return ret;
+	}
+
 	inline real_t dot(const Vector2 &p_other) const {
 		return x * p_other.x + y * p_other.y;
 	}
@@ -172,6 +223,13 @@ struct Vector2 {
 
 	Vector2 cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
 
+	Vector2 move_toward(const Vector2 &p_to, const real_t p_delta) const {
+		Vector2 v = *this;
+		Vector2 vd = p_to - v;
+		real_t len = vd.length();
+		return len <= p_delta || len < CMP_EPSILON ? p_to : v + vd / len * p_delta;
+	}
+
 	inline Vector2 slide(const Vector2 &p_vec) const {
 		return p_vec - *this * this->dot(p_vec);
 	}
@@ -180,8 +238,8 @@ struct Vector2 {
 		return -reflect(p_normal);
 	}
 
-	inline Vector2 reflect(const Vector2 &p_vec) const {
-		return p_vec - *this * this->dot(p_vec) * 2.0;
+	inline Vector2 reflect(const Vector2 &p_normal) const {
+		return -(*this - p_normal * this->dot(p_normal) * 2.0);
 	}
 
 	inline real_t angle() const {
@@ -209,13 +267,13 @@ struct Vector2 {
 	}
 
 	inline Vector2 floor() const {
-		return Vector2(::floor(x), ::floor(y));
+		return Vector2(Math::floor(x), Math::floor(y));
 	}
 
 	inline Vector2 snapped(const Vector2 &p_by) const {
 		return Vector2(
-				p_by.x != 0 ? ::floor(x / p_by.x + 0.5) * p_by.x : x,
-				p_by.y != 0 ? ::floor(y / p_by.y + 0.5) * p_by.y : y);
+				Math::stepify(x, p_by.x),
+				Math::stepify(y, p_by.y));
 	}
 
 	inline real_t aspect() const { return width / height; }
@@ -227,6 +285,22 @@ inline Vector2 operator*(real_t p_scalar, const Vector2 &p_vec) {
 	return p_vec * p_scalar;
 }
 
+namespace Math {
+
+// Convenience, since they exist in GDScript
+
+inline Vector2 cartesian2polar(Vector2 v) {
+	return Vector2(Math::sqrt(v.x * v.x + v.y * v.y), Math::atan2(v.y, v.x));
+}
+
+inline Vector2 polar2cartesian(Vector2 v) {
+	// x == radius
+	// y == angle
+	return Vector2(v.x * Math::cos(v.y), v.x * Math::sin(v.y));
+}
+
+} // namespace Math
+
 } // namespace godot
 
 #endif // VECTOR2_H

include/core/Vector3.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Vector3.hpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef VECTOR3_H
 #define VECTOR3_H
 
@@ -7,20 +37,32 @@
 
 #include "String.hpp"
 
-#include <cmath>
+#include <Math.hpp>
 
 namespace godot {
 
 class Basis;
 
 struct Vector3 {
-
 	enum Axis {
 		AXIS_X,
 		AXIS_Y,
 		AXIS_Z,
+		AXIS_COUNT
 	};
 
+	static const Vector3 ZERO;
+	static const Vector3 ONE;
+	static const Vector3 INF;
+
+	// Coordinate system of the 3D engine
+	static const Vector3 LEFT;
+	static const Vector3 RIGHT;
+	static const Vector3 UP;
+	static const Vector3 DOWN;
+	static const Vector3 FORWARD;
+	static const Vector3 BACK;
+
 	union {
 		struct {
 			real_t x;
@@ -165,8 +207,20 @@ struct Vector3 {
 				z + (p_t * (p_b.z - z)));
 	}
 
+	inline Vector3 slerp(const Vector3 &p_b, real_t p_t) const {
+		real_t theta = angle_to(p_b);
+		return rotated(cross(p_b).normalized(), theta * p_t);
+	}
+
 	Vector3 cubic_interpolate(const Vector3 &b, const Vector3 &pre_a, const Vector3 &post_b, const real_t t) const;
 
+	Vector3 move_toward(const Vector3 &p_to, const real_t p_delta) const {
+		Vector3 v = *this;
+		Vector3 vd = p_to - v;
+		real_t len = vd.length();
+		return len <= p_delta || len < CMP_EPSILON ? p_to : v + vd / len * p_delta;
+	}
+
 	Vector3 bounce(const Vector3 &p_normal) const {
 		return -reflect(p_normal);
 	}
@@ -199,10 +253,20 @@ struct Vector3 {
 		return x * b.x + y * b.y + z * b.z;
 	}
 
+	inline Vector3 project(const Vector3 &p_b) const {
+		return p_b * (dot(p_b) / p_b.length_squared());
+	}
+
 	inline real_t angle_to(const Vector3 &b) const {
 		return std::atan2(cross(b).length(), dot(b));
 	}
 
+	inline Vector3 direction_to(const Vector3 &p_b) const {
+		Vector3 ret(p_b.x - x, p_b.y - y, p_b.z - z);
+		ret.normalize();
+		return ret;
+	}
+
 	inline Vector3 floor() const {
 		return Vector3(::floor(x), ::floor(y), ::floor(z));
 	}
@@ -238,8 +302,8 @@ struct Vector3 {
 		return v;
 	}
 
-	inline Vector3 reflect(const Vector3 &by) const {
-		return by - *this * this->dot(by) * 2.f;
+	inline Vector3 reflect(const Vector3 &p_normal) const {
+		return -(*this - p_normal * this->dot(p_normal) * 2.0);
 	}
 
 	inline Vector3 rotated(const Vector3 &axis, const real_t phi) const {
@@ -251,7 +315,7 @@ struct Vector3 {
 	void rotate(const Vector3 &p_axis, real_t p_phi);
 
 	inline Vector3 slide(const Vector3 &by) const {
-		return by - *this * this->dot(by);
+		return *this - by * this->dot(by);
 	}
 
 	void snap(real_t p_val);
@@ -270,7 +334,6 @@ inline Vector3 operator*(real_t p_scalar, const Vector3 &p_vec) {
 }
 
 inline Vector3 vec3_cross(const Vector3 &p_a, const Vector3 &p_b) {
-
 	return p_a.cross(p_b);
 }
 

include/core/Wrapped.hpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Wrapped.hpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #ifndef WRAPPED_HPP
 #define WRAPPED_HPP
 
@@ -5,6 +35,7 @@
 
 namespace godot {
 
+// This is an internal base class used by the bindings. You should not need to access its members.
 class _Wrapped {
 public:
 	godot_object *_owner;

misc/ci/sources.list

@@ -0,0 +1,4 @@
+deb http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-backports main restricted universe multiverse

misc/scripts/clang_format.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+
+# This script runs clang-format on all relevant files in the repo.
+# This is the primary script responsible for fixing style violations.
+
+set -uo pipefail
+IFS=$'\n\t'
+
+CLANG_FORMAT_FILE_EXTS=(".c" ".h" ".cpp" ".hpp" ".cc" ".hh" ".cxx" ".m" ".mm" ".inc" ".java" ".glsl")
+
+# Loops through all text files tracked by Git.
+git grep -zIl '' |
+while IFS= read -rd '' f; do
+    # Exclude some files.
+    if [[ "$f" == "thirdparty"* ]]; then
+        continue
+    fi
+
+    for extension in ${CLANG_FORMAT_FILE_EXTS[@]}; do
+        if [[ "$f" == *"$extension" ]]; then
+            # Run clang-format.
+            clang-format -i "$f"
+            continue 2
+        fi
+    done
+done
+
+git diff > patch.patch
+
+# If no patch has been generated all is OK, clean up, and exit.
+if [ ! -s patch.patch ] ; then
+    printf "Files in this commit comply with the clang-format style rules.\n"
+    rm -f patch.patch
+    exit 0
+fi
+
+# A patch has been created, notify the user, clean up, and exit.
+printf "\n*** The following differences were found between the code "
+printf "and the formatting rules:\n\n"
+cat patch.patch
+printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+rm -f patch.patch
+exit 1

misc/travis/clang-format.sh

@@ -1,40 +0,0 @@
-#!/bin/sh
-
-CLANG_FORMAT=clang-format-6.0
-
-if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
-    # Check the whole commit range against $TRAVIS_BRANCH, the base merge branch
-    # We could use $TRAVIS_COMMIT_RANGE but it doesn't play well with force pushes
-    RANGE="$(git rev-parse $TRAVIS_BRANCH) HEAD"
-else
-    # Test only the last commit
-    RANGE=HEAD
-fi
-
-FILES=$(git diff-tree --no-commit-id --name-only -r $RANGE | grep -v thirdparty/ | grep -E "\.(c|h|cpp|hpp|cc|hh|cxx|m|mm|inc|java|glsl)$")
-echo "Checking files:\n$FILES"
-
-# create a random filename to store our generated patch
-prefix="static-check-clang-format"
-suffix="$(date +%s)"
-patch="/tmp/$prefix-$suffix.patch"
-
-for file in $FILES; do
-    "$CLANG_FORMAT" -style=file "$file" | \
-        diff -u "$file" - | \
-        sed -e "1s|--- |--- a/|" -e "2s|+++ -|+++ b/$file|" >> "$patch"
-done
-
-# if no patch has been generated all is ok, clean up the file stub and exit
-if [ ! -s "$patch" ] ; then
-    printf "Files in this commit comply with the clang-format rules.\n"
-    rm -f "$patch"
-    exit 0
-fi
-
-# a patch has been created, notify the user and exit
-printf "\n*** The following differences were found between the code to commit "
-printf "and the clang-format rules:\n\n"
-cat "$patch"
-printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
-exit 1

src/core/AABB.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  AABB.cpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "AABB.hpp"
 #include "Plane.hpp"
 #include "Vector3.hpp"
@@ -7,7 +37,6 @@
 namespace godot {
 
 bool AABB::intersects(const AABB &p_aabb) const {
-
 	if (position.x >= (p_aabb.position.x + p_aabb.size.x))
 		return false;
 	if ((position.x + size.x) <= p_aabb.position.x)
@@ -25,7 +54,6 @@ bool AABB::intersects(const AABB &p_aabb) const {
 }
 
 bool AABB::intersects_inclusive(const AABB &p_aabb) const {
-
 	if (position.x > (p_aabb.position.x + p_aabb.size.x))
 		return false;
 	if ((position.x + size.x) < p_aabb.position.x)
@@ -43,7 +71,6 @@ bool AABB::intersects_inclusive(const AABB &p_aabb) const {
 }
 
 bool AABB::encloses(const AABB &p_aabb) const {
-
 	Vector3 src_min = position;
 	Vector3 src_max = position + size;
 	Vector3 dst_min = p_aabb.position;
@@ -59,7 +86,6 @@ bool AABB::encloses(const AABB &p_aabb) const {
 }
 
 Vector3 AABB::get_support(const Vector3 &p_normal) const {
-
 	Vector3 half_extents = size * 0.5;
 	Vector3 ofs = position + half_extents;
 
@@ -71,23 +97,29 @@ Vector3 AABB::get_support(const Vector3 &p_normal) const {
 }
 
 Vector3 AABB::get_endpoint(int p_point) const {
-
 	switch (p_point) {
-		case 0: return Vector3(position.x, position.y, position.z);
-		case 1: return Vector3(position.x, position.y, position.z + size.z);
-		case 2: return Vector3(position.x, position.y + size.y, position.z);
-		case 3: return Vector3(position.x, position.y + size.y, position.z + size.z);
-		case 4: return Vector3(position.x + size.x, position.y, position.z);
-		case 5: return Vector3(position.x + size.x, position.y, position.z + size.z);
-		case 6: return Vector3(position.x + size.x, position.y + size.y, position.z);
-		case 7: return Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
+		case 0:
+			return Vector3(position.x, position.y, position.z);
+		case 1:
+			return Vector3(position.x, position.y, position.z + size.z);
+		case 2:
+			return Vector3(position.x, position.y + size.y, position.z);
+		case 3:
+			return Vector3(position.x, position.y + size.y, position.z + size.z);
+		case 4:
+			return Vector3(position.x + size.x, position.y, position.z);
+		case 5:
+			return Vector3(position.x + size.x, position.y, position.z + size.z);
+		case 6:
+			return Vector3(position.x + size.x, position.y + size.y, position.z);
+		case 7:
+			return Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
 	};
 
 	ERR_FAIL_V(Vector3());
 }
 
 bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) const {
-
 	Vector3 half_extents = size * 0.5;
 	Vector3 ofs = position + half_extents;
 
@@ -106,7 +138,6 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) con
 }
 
 bool AABB::has_point(const Vector3 &p_point) const {
-
 	if (p_point.x < position.x)
 		return false;
 	if (p_point.y < position.y)
@@ -124,7 +155,6 @@ bool AABB::has_point(const Vector3 &p_point) const {
 }
 
 void AABB::expand_to(const Vector3 &p_vector) {
-
 	Vector3 begin = position;
 	Vector3 end = position + size;
 
@@ -147,7 +177,6 @@ void AABB::expand_to(const Vector3 &p_vector) {
 }
 
 void AABB::project_range_in_plane(const Plane &p_plane, real_t &r_min, real_t &r_max) const {
-
 	Vector3 half_extents(size.x * 0.5, size.y * 0.5, size.z * 0.5);
 	Vector3 center(position.x + half_extents.x, position.y + half_extents.y, position.z + half_extents.z);
 
@@ -158,7 +187,6 @@ void AABB::project_range_in_plane(const Plane &p_plane, real_t &r_min, real_t &r
 }
 
 real_t AABB::get_longest_axis_size() const {
-
 	real_t max_size = size.x;
 
 	if (size.y > max_size) {
@@ -173,7 +201,6 @@ real_t AABB::get_longest_axis_size() const {
 }
 
 real_t AABB::get_shortest_axis_size() const {
-
 	real_t max_size = size.x;
 
 	if (size.y < max_size) {
@@ -188,7 +215,6 @@ real_t AABB::get_shortest_axis_size() const {
 }
 
 bool AABB::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t t0, real_t t1) const {
-
 	real_t divx = 1.0 / dir.x;
 	real_t divy = 1.0 / dir.y;
 	real_t divz = 1.0 / dir.z;
@@ -232,7 +258,6 @@ bool AABB::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t t
 }
 
 void AABB::grow_by(real_t p_amount) {
-
 	position.x -= p_amount;
 	position.y -= p_amount;
 	position.z -= p_amount;
@@ -242,21 +267,17 @@ void AABB::grow_by(real_t p_amount) {
 }
 
 real_t AABB::get_area() const {
-
 	return size.x * size.y * size.z;
 }
 
 bool AABB::operator==(const AABB &p_rval) const {
-
 	return ((position == p_rval.position) && (size == p_rval.size));
 }
 bool AABB::operator!=(const AABB &p_rval) const {
-
 	return ((position != p_rval.position) || (size != p_rval.size));
 }
 
 void AABB::merge_with(const AABB &p_aabb) {
-
 	Vector3 beg_1, beg_2;
 	Vector3 end_1, end_2;
 	Vector3 min, max;
@@ -279,7 +300,6 @@ void AABB::merge_with(const AABB &p_aabb) {
 }
 
 AABB AABB::intersection(const AABB &p_aabb) const {
-
 	Vector3 src_min = position;
 	Vector3 src_max = position + size;
 	Vector3 dst_min = p_aabb.position;
@@ -290,7 +310,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
 	if (src_min.x > dst_max.x || src_max.x < dst_min.x)
 		return AABB();
 	else {
-
 		min.x = (src_min.x > dst_min.x) ? src_min.x : dst_min.x;
 		max.x = (src_max.x < dst_max.x) ? src_max.x : dst_max.x;
 	}
@@ -298,7 +317,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
 	if (src_min.y > dst_max.y || src_max.y < dst_min.y)
 		return AABB();
 	else {
-
 		min.y = (src_min.y > dst_min.y) ? src_min.y : dst_min.y;
 		max.y = (src_max.y < dst_max.y) ? src_max.y : dst_max.y;
 	}
@@ -306,7 +324,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
 	if (src_min.z > dst_max.z || src_max.z < dst_min.z)
 		return AABB();
 	else {
-
 		min.z = (src_min.z > dst_min.z) ? src_min.z : dst_min.z;
 		max.z = (src_max.z < dst_max.z) ? src_max.z : dst_max.z;
 	}
@@ -315,7 +332,6 @@ AABB AABB::intersection(const AABB &p_aabb) const {
 }
 
 bool AABB::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip, Vector3 *r_normal) const {
-
 	Vector3 c1, c2;
 	Vector3 end = position + size;
 	real_t near = -1e20;
@@ -358,7 +374,6 @@ bool AABB::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *
 }
 
 bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip, Vector3 *r_normal) const {
-
 	real_t min = 0, max = 1;
 	int axis = 0;
 	real_t sign = 0;
@@ -372,7 +387,6 @@ bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector
 		real_t csign;
 
 		if (seg_from < seg_to) {
-
 			if (seg_from > box_end || seg_to < box_begin)
 				return false;
 			real_t length = seg_to - seg_from;
@@ -381,7 +395,6 @@ bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector
 			csign = -1.0;
 
 		} else {
-
 			if (seg_to > box_end || seg_from < box_begin)
 				return false;
 			real_t length = seg_to - seg_from;
@@ -416,7 +429,6 @@ bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector
 }
 
 bool AABB::intersects_plane(const Plane &p_plane) const {
-
 	Vector3 points[8] = {
 		Vector3(position.x, position.y, position.z),
 		Vector3(position.x, position.y, position.z + size.z),
@@ -432,7 +444,6 @@ bool AABB::intersects_plane(const Plane &p_plane) const {
 	bool under = false;
 
 	for (int i = 0; i < 8; i++) {
-
 		if (p_plane.distance_to(points[i]) > 0)
 			over = true;
 		else
@@ -443,7 +454,6 @@ bool AABB::intersects_plane(const Plane &p_plane) const {
 }
 
 Vector3 AABB::get_longest_axis() const {
-
 	Vector3 axis(1, 0, 0);
 	real_t max_size = size.x;
 
@@ -460,7 +470,6 @@ Vector3 AABB::get_longest_axis() const {
 	return axis;
 }
 int AABB::get_longest_axis_index() const {
-
 	int axis = 0;
 	real_t max_size = size.x;
 
@@ -478,7 +487,6 @@ int AABB::get_longest_axis_index() const {
 }
 
 Vector3 AABB::get_shortest_axis() const {
-
 	Vector3 axis(1, 0, 0);
 	real_t max_size = size.x;
 
@@ -495,7 +503,6 @@ Vector3 AABB::get_shortest_axis() const {
 	return axis;
 }
 int AABB::get_shortest_axis_index() const {
-
 	int axis = 0;
 	real_t max_size = size.x;
 
@@ -513,7 +520,6 @@ int AABB::get_shortest_axis_index() const {
 }
 
 AABB AABB::merge(const AABB &p_with) const {
-
 	AABB aabb = *this;
 	aabb.merge_with(p_with);
 	return aabb;
@@ -524,24 +530,19 @@ AABB AABB::expand(const Vector3 &p_vector) const {
 	return aabb;
 }
 AABB AABB::grow(real_t p_by) const {
-
 	AABB aabb = *this;
 	aabb.grow_by(p_by);
 	return aabb;
 }
 
 void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
-
 	ERR_FAIL_INDEX(p_edge, 12);
 	switch (p_edge) {
-
 		case 0: {
-
 			r_from = Vector3(position.x + size.x, position.y, position.z);
 			r_to = Vector3(position.x, position.y, position.z);
 		} break;
 		case 1: {
-
 			r_from = Vector3(position.x + size.x, position.y, position.z + size.z);
 			r_to = Vector3(position.x + size.x, position.y, position.z);
 		} break;
@@ -551,18 +552,15 @@ void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
 
 		} break;
 		case 3: {
-
 			r_from = Vector3(position.x, position.y, position.z);
 			r_to = Vector3(position.x, position.y, position.z + size.z);
 
 		} break;
 		case 4: {
-
 			r_from = Vector3(position.x, position.y + size.y, position.z);
 			r_to = Vector3(position.x + size.x, position.y + size.y, position.z);
 		} break;
 		case 5: {
-
 			r_from = Vector3(position.x + size.x, position.y + size.y, position.z);
 			r_to = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
 		} break;
@@ -572,31 +570,26 @@ void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
 
 		} break;
 		case 7: {
-
 			r_from = Vector3(position.x, position.y + size.y, position.z + size.z);
 			r_to = Vector3(position.x, position.y + size.y, position.z);
 
 		} break;
 		case 8: {
-
 			r_from = Vector3(position.x, position.y, position.z + size.z);
 			r_to = Vector3(position.x, position.y + size.y, position.z + size.z);
 
 		} break;
 		case 9: {
-
 			r_from = Vector3(position.x, position.y, position.z);
 			r_to = Vector3(position.x, position.y + size.y, position.z);
 
 		} break;
 		case 10: {
-
 			r_from = Vector3(position.x + size.x, position.y, position.z);
 			r_to = Vector3(position.x + size.x, position.y + size.y, position.z);
 
 		} break;
 		case 11: {
-
 			r_from = Vector3(position.x + size.x, position.y, position.z + size.z);
 			r_to = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
 
@@ -605,7 +598,6 @@ void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
 }
 
 AABB::operator String() const {
-
 	return String() + position + " - " + size;
 }
 

src/core/Array.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Array.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Array.hpp"
 #include "GodotGlobal.hpp"
 #include "Variant.hpp"
@@ -52,14 +82,16 @@ Array::Array(const PoolColorArray &a) {
 
 Variant &Array::operator[](const int idx) {
 	godot_variant *v = godot::api->godot_array_operator_index(&_godot_array, idx);
-	return *(Variant *)v;
+	// We assume it's ok to reinterpret because the value is a pointer whose data is already owned by the array,
+	// so can return a reference without constructing a Variant
+	return *reinterpret_cast<Variant *>(v);
 }
 
-Variant Array::operator[](const int idx) const {
+const Variant &Array::operator[](const int idx) const {
 	// Yes, I'm casting away the const... you can hate me now.
 	// since the result is
 	godot_variant *v = godot::api->godot_array_operator_index((godot_array *)&_godot_array, idx);
-	return *(Variant *)v;
+	return *reinterpret_cast<const Variant *>(v);
 }
 
 void Array::append(const Variant &v) {
@@ -84,19 +116,19 @@ void Array::erase(const Variant &v) {
 
 Variant Array::front() const {
 	godot_variant v = godot::api->godot_array_front(&_godot_array);
-	return *(Variant *)&v;
+	return Variant(v);
 }
 
 Variant Array::back() const {
 	godot_variant v = godot::api->godot_array_back(&_godot_array);
-	return *(Variant *)&v;
+	return Variant(v);
 }
 
-int Array::find(const Variant &what, const int from) {
+int Array::find(const Variant &what, const int from) const {
 	return godot::api->godot_array_find(&_godot_array, (godot_variant *)&what, from);
 }
 
-int Array::find_last(const Variant &what) {
+int Array::find_last(const Variant &what) const {
 	return godot::api->godot_array_find_last(&_godot_array, (godot_variant *)&what);
 }
 
@@ -118,12 +150,12 @@ void Array::invert() {
 
 Variant Array::pop_back() {
 	godot_variant v = godot::api->godot_array_pop_back(&_godot_array);
-	return *(Variant *)&v;
+	return Variant(v);
 }
 
 Variant Array::pop_front() {
 	godot_variant v = godot::api->godot_array_pop_front(&_godot_array);
-	return *(Variant *)&v;
+	return Variant(v);
 }
 
 void Array::push_back(const Variant &v) {
@@ -146,7 +178,7 @@ void Array::resize(const int size) {
 	godot::api->godot_array_resize(&_godot_array, size);
 }
 
-int Array::rfind(const Variant &what, const int from) {
+int Array::rfind(const Variant &what, const int from) const {
 	return godot::api->godot_array_rfind(&_godot_array, (godot_variant *)&what, from);
 }
 
@@ -170,17 +202,17 @@ int Array::bsearch_custom(const Variant &value, const Object *obj,
 
 Array Array::duplicate(const bool deep) const {
 	godot_array arr = godot::core_1_1_api->godot_array_duplicate(&_godot_array, deep);
-	return *(Array *)&arr;
+	return Array(arr);
 }
 
 Variant Array::max() const {
 	godot_variant v = godot::core_1_1_api->godot_array_max(&_godot_array);
-	return *(Variant *)&v;
+	return Variant(v);
 }
 
 Variant Array::min() const {
 	godot_variant v = godot::core_1_1_api->godot_array_min(&_godot_array);
-	return *(Variant *)&v;
+	return Variant(v);
 }
 
 void Array::shuffle() {

src/core/Basis.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Basis.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Basis.hpp"
 #include "Defs.hpp"
 #include "Quat.hpp"
@@ -7,6 +37,11 @@
 
 namespace godot {
 
+const Basis Basis::IDENTITY = Basis();
+const Basis Basis::FLIP_X = Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1);
+const Basis Basis::FLIP_Y = Basis(1, 0, 0, 0, -1, 0, 0, 0, 1);
+const Basis Basis::FLIP_Z = Basis(1, 0, 0, 0, 1, 0, 0, 0, -1);
+
 Basis::Basis(const Vector3 &row0, const Vector3 &row1, const Vector3 &row2) {
 	elements[0] = row0;
 	elements[1] = row1;
@@ -14,12 +49,10 @@ Basis::Basis(const Vector3 &row0, const Vector3 &row1, const Vector3 &row2) {
 }
 
 Basis::Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
-
 	set(xx, xy, xz, yx, yy, yz, zx, zy, zz);
 }
 
 Basis::Basis() {
-
 	elements[0][0] = 1;
 	elements[0][1] = 0;
 	elements[0][2] = 0;
@@ -53,7 +86,6 @@ void Basis::invert() {
 #undef cofac
 
 bool Basis::isequal_approx(const Basis &a, const Basis &b) const {
-
 	for (int i = 0; i < 3; i++) {
 		for (int j = 0; j < 3; j++) {
 			if ((::fabs(a.elements[i][j] - b.elements[i][j]) < CMP_EPSILON) == false)
@@ -169,7 +201,6 @@ Basis Basis::slerp(Basis b, float t) const {
 // the angles in the decomposition R = X(a1).Y(a2).Z(a3) where Z(a) rotates
 // around the z-axis by a and so on.
 Vector3 Basis::get_euler_xyz() const {
-
 	// Euler angles in XYZ convention.
 	// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
 	//
@@ -213,7 +244,6 @@ Vector3 Basis::get_euler_xyz() const {
 // and similar for other axes.
 // The current implementation uses XYZ convention (Z is the first rotation).
 void Basis::set_euler_xyz(const Vector3 &p_euler) {
-
 	real_t c, s;
 
 	c = ::cos(p_euler.x);
@@ -236,7 +266,6 @@ void Basis::set_euler_xyz(const Vector3 &p_euler) {
 // as in first-Z, then-X, last-Y. The angles for X, Y, and Z rotations are returned
 // as the x, y, and z components of a Vector3 respectively.
 Vector3 Basis::get_euler_yxz() const {
-
 	// Euler angles in YXZ convention.
 	// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
 	//
@@ -282,7 +311,6 @@ Vector3 Basis::get_euler_yxz() const {
 // and similar for other axes.
 // The current implementation uses YXZ convention (Z is the first rotation).
 void Basis::set_euler_yxz(const Vector3 &p_euler) {
-
 	real_t c, s;
 
 	c = ::cos(p_euler.x);
@@ -328,7 +356,6 @@ bool Basis::operator!=(const Basis &p_matrix) const {
 }
 
 Vector3 Basis::xform(const Vector3 &p_vector) const {
-
 	return Vector3(
 			elements[0].dot(p_vector),
 			elements[1].dot(p_vector),
@@ -336,7 +363,6 @@ Vector3 Basis::xform(const Vector3 &p_vector) const {
 }
 
 Vector3 Basis::xform_inv(const Vector3 &p_vector) const {
-
 	return Vector3(
 			(elements[0][0] * p_vector.x) + (elements[1][0] * p_vector.y) + (elements[2][0] * p_vector.z),
 			(elements[0][1] * p_vector.x) + (elements[1][1] * p_vector.y) + (elements[2][1] * p_vector.z),
@@ -357,42 +383,36 @@ Basis Basis::operator*(const Basis &p_matrix) const {
 }
 
 void Basis::operator+=(const Basis &p_matrix) {
-
 	elements[0] += p_matrix.elements[0];
 	elements[1] += p_matrix.elements[1];
 	elements[2] += p_matrix.elements[2];
 }
 
 Basis Basis::operator+(const Basis &p_matrix) const {
-
 	Basis ret(*this);
 	ret += p_matrix;
 	return ret;
 }
 
 void Basis::operator-=(const Basis &p_matrix) {
-
 	elements[0] -= p_matrix.elements[0];
 	elements[1] -= p_matrix.elements[1];
 	elements[2] -= p_matrix.elements[2];
 }
 
 Basis Basis::operator-(const Basis &p_matrix) const {
-
 	Basis ret(*this);
 	ret -= p_matrix;
 	return ret;
 }
 
 void Basis::operator*=(real_t p_val) {
-
 	elements[0] *= p_val;
 	elements[1] *= p_val;
 	elements[2] *= p_val;
 }
 
 Basis Basis::operator*(real_t p_val) const {
-
 	Basis ret(*this);
 	ret *= p_val;
 	return ret;
@@ -401,9 +421,7 @@ Basis Basis::operator*(real_t p_val) const {
 Basis::operator String() const {
 	String s;
 	for (int i = 0; i < 3; i++) {
-
 		for (int j = 0; j < 3; j++) {
-
 			if (i != 0 || j != 0)
 				s += ", ";
 
@@ -416,7 +434,6 @@ Basis::operator String() const {
 /* create / set */
 
 void Basis::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
-
 	elements[0][0] = xx;
 	elements[0][1] = xy;
 	elements[0][2] = xz;
@@ -428,12 +445,10 @@ void Basis::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz
 	elements[2][2] = zz;
 }
 Vector3 Basis::get_column(int i) const {
-
 	return Vector3(elements[0][i], elements[1][i], elements[2][i]);
 }
 
 Vector3 Basis::get_row(int i) const {
-
 	return Vector3(elements[i][0], elements[i][1], elements[i][2]);
 }
 Vector3 Basis::get_main_diagonal() const {
@@ -588,7 +603,6 @@ int Basis::get_orthogonal_index() const {
 	Basis orth = *this;
 	for (int i = 0; i < 3; i++) {
 		for (int j = 0; j < 3; j++) {
-
 			real_t v = orth[i][j];
 			if (v > 0.5)
 				v = 1.0;
@@ -602,7 +616,6 @@ int Basis::get_orthogonal_index() const {
 	}
 
 	for (int i = 0; i < 24; i++) {
-
 		if (_ortho_bases[i] == orth)
 			return i;
 	}
@@ -611,7 +624,6 @@ int Basis::get_orthogonal_index() const {
 }
 
 void Basis::set_orthogonal_index(int p_index) {
-
 	//there only exist 24 orthogonal bases in r3
 	ERR_FAIL_COND(p_index >= 24);
 
@@ -619,7 +631,6 @@ void Basis::set_orthogonal_index(int p_index) {
 }
 
 Basis::Basis(const Vector3 &p_euler) {
-
 	set_euler(p_euler);
 }
 
@@ -630,7 +641,6 @@ Basis::Basis(const Vector3 &p_euler) {
 namespace godot {
 
 Basis::Basis(const Quat &p_quat) {
-
 	real_t d = p_quat.length_squared();
 	real_t s = 2.0 / d;
 	real_t xs = p_quat.x * s, ys = p_quat.y * s, zs = p_quat.z * s;
@@ -680,8 +690,8 @@ Basis::operator Quat() const {
 		temp[2] = ((elements[1][0] - elements[0][1]) * s);
 	} else {
 		int i = elements[0][0] < elements[1][1] ?
-						(elements[1][1] < elements[2][2] ? 2 : 1) :
-						(elements[0][0] < elements[2][2] ? 2 : 0);
+						  (elements[1][1] < elements[2][2] ? 2 : 1) :
+						  (elements[0][0] < elements[2][2] ? 2 : 0);
 		int j = (i + 1) % 3;
 		int k = (i + 2) % 3;
 

src/core/CameraMatrix.cpp

@@ -0,0 +1,655 @@
+/*************************************************************************/
+/*  CameraMatrix.cpp                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "CameraMatrix.hpp"
+
+void CameraMatrix::set_identity() {
+	for (int i = 0; i < 4; i++) {
+		for (int j = 0; j < 4; j++) {
+			matrix[i][j] = (i == j) ? 1 : 0;
+		}
+	}
+}
+
+void CameraMatrix::set_zero() {
+	for (int i = 0; i < 4; i++) {
+		for (int j = 0; j < 4; j++) {
+			matrix[i][j] = 0;
+		}
+	}
+}
+
+Plane CameraMatrix::xform4(const Plane &p_vec4) const {
+	Plane ret;
+
+	ret.normal.x = matrix[0][0] * p_vec4.normal.x + matrix[1][0] * p_vec4.normal.y + matrix[2][0] * p_vec4.normal.z + matrix[3][0] * p_vec4.d;
+	ret.normal.y = matrix[0][1] * p_vec4.normal.x + matrix[1][1] * p_vec4.normal.y + matrix[2][1] * p_vec4.normal.z + matrix[3][1] * p_vec4.d;
+	ret.normal.z = matrix[0][2] * p_vec4.normal.x + matrix[1][2] * p_vec4.normal.y + matrix[2][2] * p_vec4.normal.z + matrix[3][2] * p_vec4.d;
+	ret.d = matrix[0][3] * p_vec4.normal.x + matrix[1][3] * p_vec4.normal.y + matrix[2][3] * p_vec4.normal.z + matrix[3][3] * p_vec4.d;
+	return ret;
+}
+
+void CameraMatrix::set_perspective(real_t p_fovy_degrees, real_t p_aspect, real_t p_z_near, real_t p_z_far, bool p_flip_fov) {
+	if (p_flip_fov) {
+		p_fovy_degrees = get_fovy(p_fovy_degrees, 1.0 / p_aspect);
+	}
+
+	real_t sine, cotangent, deltaZ;
+	real_t radians = p_fovy_degrees / 2.0 * Math_PI / 180.0;
+
+	deltaZ = p_z_far - p_z_near;
+	sine = sin(radians);
+
+	if ((deltaZ == 0) || (sine == 0) || (p_aspect == 0)) {
+		return;
+	}
+	cotangent = cos(radians) / sine;
+
+	set_identity();
+
+	matrix[0][0] = cotangent / p_aspect;
+	matrix[1][1] = cotangent;
+	matrix[2][2] = -(p_z_far + p_z_near) / deltaZ;
+	matrix[2][3] = -1;
+	matrix[3][2] = -2 * p_z_near * p_z_far / deltaZ;
+	matrix[3][3] = 0;
+}
+
+void CameraMatrix::set_perspective(real_t p_fovy_degrees, real_t p_aspect, real_t p_z_near, real_t p_z_far, bool p_flip_fov, int p_eye, real_t p_intraocular_dist, real_t p_convergence_dist) {
+	if (p_flip_fov) {
+		p_fovy_degrees = get_fovy(p_fovy_degrees, 1.0 / p_aspect);
+	}
+
+	real_t left, right, modeltranslation, ymax, xmax, frustumshift;
+
+	ymax = p_z_near * tan(p_fovy_degrees * Math_PI / 360.0f);
+	xmax = ymax * p_aspect;
+	frustumshift = (p_intraocular_dist / 2.0) * p_z_near / p_convergence_dist;
+
+	switch (p_eye) {
+		case 1: { // left eye
+			left = -xmax + frustumshift;
+			right = xmax + frustumshift;
+			modeltranslation = p_intraocular_dist / 2.0;
+		}; break;
+		case 2: { // right eye
+			left = -xmax - frustumshift;
+			right = xmax - frustumshift;
+			modeltranslation = -p_intraocular_dist / 2.0;
+		}; break;
+		default: { // mono, should give the same result as set_perspective(p_fovy_degrees,p_aspect,p_z_near,p_z_far,p_flip_fov)
+			left = -xmax;
+			right = xmax;
+			modeltranslation = 0.0;
+		}; break;
+	};
+
+	set_frustum(left, right, -ymax, ymax, p_z_near, p_z_far);
+
+	// translate matrix by (modeltranslation, 0.0, 0.0)
+	CameraMatrix cm;
+	cm.set_identity();
+	cm.matrix[3][0] = modeltranslation;
+	*this = *this * cm;
+}
+
+void CameraMatrix::set_for_hmd(int p_eye, real_t p_aspect, real_t p_intraocular_dist, real_t p_display_width, real_t p_display_to_lens, real_t p_oversample, real_t p_z_near, real_t p_z_far) {
+	// we first calculate our base frustum on our values without taking our lens magnification into account.
+	real_t f1 = (p_intraocular_dist * 0.5) / p_display_to_lens;
+	real_t f2 = ((p_display_width - p_intraocular_dist) * 0.5) / p_display_to_lens;
+	real_t f3 = (p_display_width / 4.0) / p_display_to_lens;
+
+	// now we apply our oversample factor to increase our FOV. how much we oversample is always a balance we strike between performance and how much
+	// we're willing to sacrifice in FOV.
+	real_t add = ((f1 + f2) * (p_oversample - 1.0)) / 2.0;
+	f1 += add;
+	f2 += add;
+	f3 *= p_oversample;
+
+	// always apply KEEP_WIDTH aspect ratio
+	f3 /= p_aspect;
+
+	switch (p_eye) {
+		case 1: { // left eye
+			set_frustum(-f2 * p_z_near, f1 * p_z_near, -f3 * p_z_near, f3 * p_z_near, p_z_near, p_z_far);
+		}; break;
+		case 2: { // right eye
+			set_frustum(-f1 * p_z_near, f2 * p_z_near, -f3 * p_z_near, f3 * p_z_near, p_z_near, p_z_far);
+		}; break;
+		default: { // mono, does not apply here!
+		}; break;
+	};
+};
+
+void CameraMatrix::set_orthogonal(real_t p_left, real_t p_right, real_t p_bottom, real_t p_top, real_t p_znear, real_t p_zfar) {
+	set_identity();
+
+	matrix[0][0] = 2.0 / (p_right - p_left);
+	matrix[3][0] = -((p_right + p_left) / (p_right - p_left));
+	matrix[1][1] = 2.0 / (p_top - p_bottom);
+	matrix[3][1] = -((p_top + p_bottom) / (p_top - p_bottom));
+	matrix[2][2] = -2.0 / (p_zfar - p_znear);
+	matrix[3][2] = -((p_zfar + p_znear) / (p_zfar - p_znear));
+	matrix[3][3] = 1.0;
+}
+
+void CameraMatrix::set_orthogonal(real_t p_size, real_t p_aspect, real_t p_znear, real_t p_zfar, bool p_flip_fov) {
+	if (!p_flip_fov) {
+		p_size *= p_aspect;
+	}
+
+	set_orthogonal(-p_size / 2, +p_size / 2, -p_size / p_aspect / 2, +p_size / p_aspect / 2, p_znear, p_zfar);
+}
+
+void CameraMatrix::set_frustum(real_t p_left, real_t p_right, real_t p_bottom, real_t p_top, real_t p_near, real_t p_far) {
+	ERR_FAIL_COND(p_right <= p_left);
+	ERR_FAIL_COND(p_top <= p_bottom);
+	ERR_FAIL_COND(p_far <= p_near);
+
+	real_t *te = &matrix[0][0];
+	real_t x = 2 * p_near / (p_right - p_left);
+	real_t y = 2 * p_near / (p_top - p_bottom);
+
+	real_t a = (p_right + p_left) / (p_right - p_left);
+	real_t b = (p_top + p_bottom) / (p_top - p_bottom);
+	real_t c = -(p_far + p_near) / (p_far - p_near);
+	real_t d = -2 * p_far * p_near / (p_far - p_near);
+
+	te[0] = x;
+	te[1] = 0;
+	te[2] = 0;
+	te[3] = 0;
+	te[4] = 0;
+	te[5] = y;
+	te[6] = 0;
+	te[7] = 0;
+	te[8] = a;
+	te[9] = b;
+	te[10] = c;
+	te[11] = -1;
+	te[12] = 0;
+	te[13] = 0;
+	te[14] = d;
+	te[15] = 0;
+}
+
+void CameraMatrix::set_frustum(real_t p_size, real_t p_aspect, Vector2 p_offset, real_t p_near, real_t p_far, bool p_flip_fov) {
+	if (!p_flip_fov) {
+		p_size *= p_aspect;
+	}
+
+	set_frustum(-p_size / 2 + p_offset.x, +p_size / 2 + p_offset.x, -p_size / p_aspect / 2 + p_offset.y, +p_size / p_aspect / 2 + p_offset.y, p_near, p_far);
+}
+
+real_t CameraMatrix::get_z_far() const {
+	const real_t *matrix = (const real_t *)this->matrix;
+	Plane new_plane = Plane(matrix[3] - matrix[2],
+			matrix[7] - matrix[6],
+			matrix[11] - matrix[10],
+			matrix[15] - matrix[14]);
+
+	new_plane.normal = -new_plane.normal;
+	new_plane.normalize();
+
+	return new_plane.d;
+}
+real_t CameraMatrix::get_z_near() const {
+	const real_t *matrix = (const real_t *)this->matrix;
+	Plane new_plane = Plane(matrix[3] + matrix[2],
+			matrix[7] + matrix[6],
+			matrix[11] + matrix[10],
+			-matrix[15] - matrix[14]);
+
+	new_plane.normalize();
+	return new_plane.d;
+}
+
+Vector2 CameraMatrix::get_viewport_half_extents() const {
+	const real_t *matrix = (const real_t *)this->matrix;
+	///////--- Near Plane ---///////
+	Plane near_plane = Plane(matrix[3] + matrix[2],
+			matrix[7] + matrix[6],
+			matrix[11] + matrix[10],
+			-matrix[15] - matrix[14]);
+	near_plane.normalize();
+
+	///////--- Right Plane ---///////
+	Plane right_plane = Plane(matrix[3] - matrix[0],
+			matrix[7] - matrix[4],
+			matrix[11] - matrix[8],
+			-matrix[15] + matrix[12]);
+	right_plane.normalize();
+
+	Plane top_plane = Plane(matrix[3] - matrix[1],
+			matrix[7] - matrix[5],
+			matrix[11] - matrix[9],
+			-matrix[15] + matrix[13]);
+	top_plane.normalize();
+
+	Vector3 res;
+	near_plane.intersect_3(right_plane, top_plane, &res);
+
+	return Vector2(res.x, res.y);
+}
+
+bool CameraMatrix::get_endpoints(const Transform &p_transform, Vector3 *p_8points) const {
+	std::vector<Plane> planes = get_projection_planes(Transform());
+	const Planes intersections[8][3] = {
+		{ PLANE_FAR, PLANE_LEFT, PLANE_TOP },
+		{ PLANE_FAR, PLANE_LEFT, PLANE_BOTTOM },
+		{ PLANE_FAR, PLANE_RIGHT, PLANE_TOP },
+		{ PLANE_FAR, PLANE_RIGHT, PLANE_BOTTOM },
+		{ PLANE_NEAR, PLANE_LEFT, PLANE_TOP },
+		{ PLANE_NEAR, PLANE_LEFT, PLANE_BOTTOM },
+		{ PLANE_NEAR, PLANE_RIGHT, PLANE_TOP },
+		{ PLANE_NEAR, PLANE_RIGHT, PLANE_BOTTOM },
+	};
+
+	for (int i = 0; i < 8; i++) {
+		Vector3 point;
+		bool res = planes[intersections[i][0]].intersect_3(planes[intersections[i][1]], planes[intersections[i][2]], &point);
+		ERR_FAIL_COND_V(!res, false);
+		p_8points[i] = p_transform.xform(point);
+	}
+
+	return true;
+}
+
+std::vector<Plane> CameraMatrix::get_projection_planes(const Transform &p_transform) const {
+	/** Fast Plane Extraction from combined modelview/projection matrices.
+	 * References:
+	 * https://web.archive.org/web/20011221205252/http://www.markmorley.com/opengl/frustumculling.html
+	 * https://web.archive.org/web/20061020020112/http://www2.ravensoft.com/users/ggribb/plane%20extraction.pdf
+	 */
+
+	std::vector<Plane> planes;
+
+	const real_t *matrix = (const real_t *)this->matrix;
+
+	Plane new_plane;
+
+	///////--- Near Plane ---///////
+	new_plane = Plane(matrix[3] + matrix[2],
+			matrix[7] + matrix[6],
+			matrix[11] + matrix[10],
+			matrix[15] + matrix[14]);
+
+	new_plane.normal = -new_plane.normal;
+	new_plane.normalize();
+
+	planes.push_back(p_transform.xform(new_plane));
+
+	///////--- Far Plane ---///////
+	new_plane = Plane(matrix[3] - matrix[2],
+			matrix[7] - matrix[6],
+			matrix[11] - matrix[10],
+			matrix[15] - matrix[14]);
+
+	new_plane.normal = -new_plane.normal;
+	new_plane.normalize();
+
+	planes.push_back(p_transform.xform(new_plane));
+
+	///////--- Left Plane ---///////
+	new_plane = Plane(matrix[3] + matrix[0],
+			matrix[7] + matrix[4],
+			matrix[11] + matrix[8],
+			matrix[15] + matrix[12]);
+
+	new_plane.normal = -new_plane.normal;
+	new_plane.normalize();
+
+	planes.push_back(p_transform.xform(new_plane));
+
+	///////--- Top Plane ---///////
+	new_plane = Plane(matrix[3] - matrix[1],
+			matrix[7] - matrix[5],
+			matrix[11] - matrix[9],
+			matrix[15] - matrix[13]);
+
+	new_plane.normal = -new_plane.normal;
+	new_plane.normalize();
+
+	planes.push_back(p_transform.xform(new_plane));
+
+	///////--- Right Plane ---///////
+	new_plane = Plane(matrix[3] - matrix[0],
+			matrix[7] - matrix[4],
+			matrix[11] - matrix[8],
+			matrix[15] - matrix[12]);
+
+	new_plane.normal = -new_plane.normal;
+	new_plane.normalize();
+
+	planes.push_back(p_transform.xform(new_plane));
+
+	///////--- Bottom Plane ---///////
+	new_plane = Plane(matrix[3] + matrix[1],
+			matrix[7] + matrix[5],
+			matrix[11] + matrix[9],
+			matrix[15] + matrix[13]);
+
+	new_plane.normal = -new_plane.normal;
+	new_plane.normalize();
+
+	planes.push_back(p_transform.xform(new_plane));
+
+	return planes;
+}
+
+CameraMatrix CameraMatrix::inverse() const {
+	CameraMatrix cm = *this;
+	cm.invert();
+	return cm;
+}
+
+void CameraMatrix::invert() {
+	int i, j, k;
+	int pvt_i[4], pvt_j[4]; /* Locations of pivot matrix */
+	real_t pvt_val; /* Value of current pivot element */
+	real_t hold; /* Temporary storage */
+	real_t determinat; /* Determinant */
+
+	determinat = 1.0;
+	for (k = 0; k < 4; k++) {
+		/** Locate k'th pivot element **/
+		pvt_val = matrix[k][k]; /** Initialize for search **/
+		pvt_i[k] = k;
+		pvt_j[k] = k;
+		for (i = k; i < 4; i++) {
+			for (j = k; j < 4; j++) {
+				if (absd(matrix[i][j]) > absd(pvt_val)) {
+					pvt_i[k] = i;
+					pvt_j[k] = j;
+					pvt_val = matrix[i][j];
+				}
+			}
+		}
+
+		/** Product of pivots, gives determinant when finished **/
+		determinat *= pvt_val;
+		if (absd(determinat) < 1e-7) {
+			return; //(false);  /** Matrix is singular (zero determinant). **/
+		}
+
+		/** "Interchange" rows (with sign change stuff) **/
+		i = pvt_i[k];
+		if (i != k) { /** If rows are different **/
+			for (j = 0; j < 4; j++) {
+				hold = -matrix[k][j];
+				matrix[k][j] = matrix[i][j];
+				matrix[i][j] = hold;
+			}
+		}
+
+		/** "Interchange" columns **/
+		j = pvt_j[k];
+		if (j != k) { /** If columns are different **/
+			for (i = 0; i < 4; i++) {
+				hold = -matrix[i][k];
+				matrix[i][k] = matrix[i][j];
+				matrix[i][j] = hold;
+			}
+		}
+
+		/** Divide column by minus pivot value **/
+		for (i = 0; i < 4; i++) {
+			if (i != k)
+				matrix[i][k] /= (-pvt_val);
+		}
+
+		/** Reduce the matrix **/
+		for (i = 0; i < 4; i++) {
+			hold = matrix[i][k];
+			for (j = 0; j < 4; j++) {
+				if (i != k && j != k)
+					matrix[i][j] += hold * matrix[k][j];
+			}
+		}
+
+		/** Divide row by pivot **/
+		for (j = 0; j < 4; j++) {
+			if (j != k)
+				matrix[k][j] /= pvt_val;
+		}
+
+		/** Replace pivot by reciprocal (at last we can touch it). **/
+		matrix[k][k] = 1.0 / pvt_val;
+	}
+
+	/* That was most of the work, one final pass of row/column interchange */
+	/* to finish */
+	for (k = 4 - 2; k >= 0; k--) { /* Don't need to work with 1 by 1 corner*/
+		i = pvt_j[k]; /* Rows to swap correspond to pivot COLUMN */
+		if (i != k) { /* If rows are different */
+			for (j = 0; j < 4; j++) {
+				hold = matrix[k][j];
+				matrix[k][j] = -matrix[i][j];
+				matrix[i][j] = hold;
+			}
+		}
+
+		j = pvt_i[k]; /* Columns to swap correspond to pivot ROW */
+		if (j != k) /* If columns are different */
+			for (i = 0; i < 4; i++) {
+				hold = matrix[i][k];
+				matrix[i][k] = -matrix[i][j];
+				matrix[i][j] = hold;
+			}
+	}
+}
+
+CameraMatrix::CameraMatrix() {
+	set_identity();
+}
+
+CameraMatrix CameraMatrix::operator*(const CameraMatrix &p_matrix) const {
+	CameraMatrix new_matrix;
+
+	for (int j = 0; j < 4; j++) {
+		for (int i = 0; i < 4; i++) {
+			real_t ab = 0;
+			for (int k = 0; k < 4; k++)
+				ab += matrix[k][i] * p_matrix.matrix[j][k];
+			new_matrix.matrix[j][i] = ab;
+		}
+	}
+
+	return new_matrix;
+}
+
+void CameraMatrix::set_light_bias() {
+	real_t *m = &matrix[0][0];
+
+	m[0] = 0.5;
+	m[1] = 0.0;
+	m[2] = 0.0;
+	m[3] = 0.0;
+	m[4] = 0.0;
+	m[5] = 0.5;
+	m[6] = 0.0;
+	m[7] = 0.0;
+	m[8] = 0.0;
+	m[9] = 0.0;
+	m[10] = 0.5;
+	m[11] = 0.0;
+	m[12] = 0.5;
+	m[13] = 0.5;
+	m[14] = 0.5;
+	m[15] = 1.0;
+}
+
+void CameraMatrix::set_light_atlas_rect(const Rect2 &p_rect) {
+	real_t *m = &matrix[0][0];
+
+	m[0] = p_rect.size.width;
+	m[1] = 0.0;
+	m[2] = 0.0;
+	m[3] = 0.0;
+	m[4] = 0.0;
+	m[5] = p_rect.size.height;
+	m[6] = 0.0;
+	m[7] = 0.0;
+	m[8] = 0.0;
+	m[9] = 0.0;
+	m[10] = 1.0;
+	m[11] = 0.0;
+	m[12] = p_rect.position.x;
+	m[13] = p_rect.position.y;
+	m[14] = 0.0;
+	m[15] = 1.0;
+}
+
+CameraMatrix::operator String() const {
+	String str;
+	for (int i = 0; i < 4; i++)
+		for (int j = 0; j < 4; j++)
+			str += String((j > 0) ? ", " : "\n") + String::num(matrix[i][j]);
+
+	return str;
+}
+
+real_t CameraMatrix::get_aspect() const {
+	Vector2 vp_he = get_viewport_half_extents();
+	return vp_he.x / vp_he.y;
+}
+
+int CameraMatrix::get_pixels_per_meter(int p_for_pixel_width) const {
+	Vector3 result = xform(Vector3(1, 0, -1));
+
+	return int((result.x * 0.5 + 0.5) * p_for_pixel_width);
+}
+
+bool CameraMatrix::is_orthogonal() const {
+	return matrix[3][3] == 1.0;
+}
+
+real_t CameraMatrix::get_fov() const {
+	const real_t *matrix = (const real_t *)this->matrix;
+
+	Plane right_plane = Plane(matrix[3] - matrix[0],
+			matrix[7] - matrix[4],
+			matrix[11] - matrix[8],
+			-matrix[15] + matrix[12]);
+	right_plane.normalize();
+
+	if ((matrix[8] == 0) && (matrix[9] == 0)) {
+		return Math::rad2deg(acos(std::abs(right_plane.normal.x))) * 2.0;
+	} else {
+		// our frustum is asymmetrical need to calculate the left planes angle separately..
+		Plane left_plane = Plane(matrix[3] + matrix[0],
+				matrix[7] + matrix[4],
+				matrix[11] + matrix[8],
+				matrix[15] + matrix[12]);
+		left_plane.normalize();
+
+		return Math::rad2deg(acos(std::abs(left_plane.normal.x))) + Math::rad2deg(acos(std::abs(right_plane.normal.x)));
+	}
+}
+
+void CameraMatrix::make_scale(const Vector3 &p_scale) {
+	set_identity();
+	matrix[0][0] = p_scale.x;
+	matrix[1][1] = p_scale.y;
+	matrix[2][2] = p_scale.z;
+}
+
+void CameraMatrix::scale_translate_to_fit(const AABB &p_aabb) {
+	Vector3 min = p_aabb.position;
+	Vector3 max = p_aabb.position + p_aabb.size;
+
+	matrix[0][0] = 2 / (max.x - min.x);
+	matrix[1][0] = 0;
+	matrix[2][0] = 0;
+	matrix[3][0] = -(max.x + min.x) / (max.x - min.x);
+
+	matrix[0][1] = 0;
+	matrix[1][1] = 2 / (max.y - min.y);
+	matrix[2][1] = 0;
+	matrix[3][1] = -(max.y + min.y) / (max.y - min.y);
+
+	matrix[0][2] = 0;
+	matrix[1][2] = 0;
+	matrix[2][2] = 2 / (max.z - min.z);
+	matrix[3][2] = -(max.z + min.z) / (max.z - min.z);
+
+	matrix[0][3] = 0;
+	matrix[1][3] = 0;
+	matrix[2][3] = 0;
+	matrix[3][3] = 1;
+}
+
+CameraMatrix::operator Transform() const {
+	Transform tr;
+	const real_t *m = &matrix[0][0];
+
+	tr.basis.elements[0][0] = m[0];
+	tr.basis.elements[1][0] = m[1];
+	tr.basis.elements[2][0] = m[2];
+
+	tr.basis.elements[0][1] = m[4];
+	tr.basis.elements[1][1] = m[5];
+	tr.basis.elements[2][1] = m[6];
+
+	tr.basis.elements[0][2] = m[8];
+	tr.basis.elements[1][2] = m[9];
+	tr.basis.elements[2][2] = m[10];
+
+	tr.origin.x = m[12];
+	tr.origin.y = m[13];
+	tr.origin.z = m[14];
+
+	return tr;
+}
+
+CameraMatrix::CameraMatrix(const Transform &p_transform) {
+	const Transform &tr = p_transform;
+	real_t *m = &matrix[0][0];
+
+	m[0] = tr.basis.elements[0][0];
+	m[1] = tr.basis.elements[1][0];
+	m[2] = tr.basis.elements[2][0];
+	m[3] = 0.0;
+	m[4] = tr.basis.elements[0][1];
+	m[5] = tr.basis.elements[1][1];
+	m[6] = tr.basis.elements[2][1];
+	m[7] = 0.0;
+	m[8] = tr.basis.elements[0][2];
+	m[9] = tr.basis.elements[1][2];
+	m[10] = tr.basis.elements[2][2];
+	m[11] = 0.0;
+	m[12] = tr.origin.x;
+	m[13] = tr.origin.y;
+	m[14] = tr.origin.z;
+	m[15] = 1.0;
+}
+
+CameraMatrix::~CameraMatrix() {
+}

src/core/Color.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Color.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Color.hpp"
 #include "Defs.hpp"
 #include "String.hpp"
@@ -13,11 +43,9 @@ namespace godot {
 static String _to_hex(float p_val);
 
 static float _parse_col(const String &p_str, int p_ofs) {
-
 	int ig = 0;
 
 	for (int i = 0; i < 2; i++) {
-
 		int c = (int)(wchar_t)p_str[i + p_ofs];
 		int v = 0;
 
@@ -43,7 +71,6 @@ static float _parse_col(const String &p_str, int p_ofs) {
 }
 
 uint32_t Color::to_32() const {
-
 	uint32_t c = (uint8_t)(a * 255);
 	c <<= 8;
 	c |= (uint8_t)(r * 255);
@@ -148,7 +175,6 @@ uint8_t Color::get_a8() const {
 }
 
 float Color::get_h() const {
-
 	float min = MIN(r, g);
 	min = MIN(min, b);
 	float max = MAX(r, g);
@@ -334,7 +360,6 @@ Color Color::contrasted() const {
 }
 
 Color Color::linear_interpolate(const Color &p_b, float p_t) const {
-
 	Color res = *this;
 
 	res.r += (p_t * (p_b.r - r));
@@ -346,7 +371,6 @@ Color Color::linear_interpolate(const Color &p_b, float p_t) const {
 }
 
 Color Color::blend(const Color &p_over) const {
-
 	Color res;
 	float sa = 1.0 - p_over.a;
 	res.a = a * sa + p_over.a;
@@ -361,7 +385,6 @@ Color Color::blend(const Color &p_over) const {
 }
 
 Color Color::to_linear() const {
-
 	return Color(
 			r < 0.04045 ? r * (1.0 / 12.92) : ::pow((r + 0.055) * (1.0 / (1 + 0.055)), 2.4),
 			g < 0.04045 ? g * (1.0 / 12.92) : ::pow((g + 0.055) * (1.0 / (1 + 0.055)), 2.4),
@@ -477,13 +500,11 @@ bool Color::html_is_valid(const String &p_color) {
 #define CLAMP(m_a, m_min, m_max) (((m_a) < (m_min)) ? (m_min) : (((m_a) > (m_max)) ? m_max : m_a))
 #endif
 static String _to_hex(float p_val) {
-
 	int v = p_val * 255;
 	v = CLAMP(v, 0, 255);
 	String ret;
 
 	for (int i = 0; i < 2; i++) {
-
 		wchar_t c[2] = { 0, 0 };
 		int lv = v & 0xF;
 		if (lv < 10)
@@ -514,7 +535,6 @@ Color::operator String() const {
 }
 
 bool Color::operator<(const Color &p_color) const {
-
 	if (r == p_color.r) {
 		if (g == p_color.g) {
 			if (b == p_color.b) {
@@ -527,4 +547,109 @@ bool Color::operator<(const Color &p_color) const {
 		return r < p_color.r;
 }
 
+Color Color::operator+(const Color &p_color) const {
+	return Color(
+			r + p_color.r,
+			g + p_color.g,
+			b + p_color.b,
+			a + p_color.a);
+}
+
+void Color::operator+=(const Color &p_color) {
+	r = r + p_color.r;
+	g = g + p_color.g;
+	b = b + p_color.b;
+	a = a + p_color.a;
+}
+
+Color Color::operator-(const Color &p_color) const {
+	return Color(
+			r - p_color.r,
+			g - p_color.g,
+			b - p_color.b,
+			a - p_color.a);
+}
+
+void Color::operator-=(const Color &p_color) {
+	r = r - p_color.r;
+	g = g - p_color.g;
+	b = b - p_color.b;
+	a = a - p_color.a;
+}
+
+Color Color::operator*(const Color &p_color) const {
+	return Color(
+			r * p_color.r,
+			g * p_color.g,
+			b * p_color.b,
+			a * p_color.a);
+}
+
+Color Color::operator*(const real_t &rvalue) const {
+	return Color(
+			r * rvalue,
+			g * rvalue,
+			b * rvalue,
+			a * rvalue);
+}
+
+void Color::operator*=(const Color &p_color) {
+	r = r * p_color.r;
+	g = g * p_color.g;
+	b = b * p_color.b;
+	a = a * p_color.a;
+}
+
+void Color::operator*=(const real_t &rvalue) {
+	r = r * rvalue;
+	g = g * rvalue;
+	b = b * rvalue;
+	a = a * rvalue;
+}
+
+Color Color::operator/(const Color &p_color) const {
+	return Color(
+			r / p_color.r,
+			g / p_color.g,
+			b / p_color.b,
+			a / p_color.a);
+}
+
+Color Color::operator/(const real_t &rvalue) const {
+	return Color(
+			r / rvalue,
+			g / rvalue,
+			b / rvalue,
+			a / rvalue);
+}
+
+void Color::operator/=(const Color &p_color) {
+	r = r / p_color.r;
+	g = g / p_color.g;
+	b = b / p_color.b;
+	a = a / p_color.a;
+}
+
+void Color::operator/=(const real_t &rvalue) {
+	if (rvalue == 0) {
+		r = 1.0;
+		g = 1.0;
+		b = 1.0;
+		a = 1.0;
+	} else {
+		r = r / rvalue;
+		g = g / rvalue;
+		b = b / rvalue;
+		a = a / rvalue;
+	}
+}
+
+Color Color::operator-() const {
+	return Color(
+			1.0 - r,
+			1.0 - g,
+			1.0 - b,
+			1.0 - a);
+}
+
 } // namespace godot

src/core/Dictionary.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Dictionary.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Dictionary.hpp"
 #include "Array.hpp"
 #include "GodotGlobal.hpp"
@@ -45,16 +75,18 @@ uint32_t Dictionary::hash() const {
 
 Array Dictionary::keys() const {
 	godot_array a = godot::api->godot_dictionary_keys(&_godot_dictionary);
-	return *(Array *)&a;
+	return Array(a);
 }
 
 Variant &Dictionary::operator[](const Variant &key) {
-	return *(Variant *)godot::api->godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *)&key);
+	godot_variant *v = godot::api->godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *)&key);
+	return *reinterpret_cast<Variant *>(v);
 }
 
 const Variant &Dictionary::operator[](const Variant &key) const {
 	// oops I did it again
-	return *(Variant *)godot::api->godot_dictionary_operator_index((godot_dictionary *)&_godot_dictionary, (godot_variant *)&key);
+	godot_variant *v = godot::api->godot_dictionary_operator_index((godot_dictionary *)&_godot_dictionary, (godot_variant *)&key);
+	return *reinterpret_cast<Variant *>(v);
 }
 
 int Dictionary::size() const {
@@ -63,12 +95,12 @@ int Dictionary::size() const {
 
 String Dictionary::to_json() const {
 	godot_string s = godot::api->godot_dictionary_to_json(&_godot_dictionary);
-	return *(String *)&s;
+	return String(s);
 }
 
 Array Dictionary::values() const {
 	godot_array a = godot::api->godot_dictionary_values(&_godot_dictionary);
-	return *(Array *)&a;
+	return Array(a);
 }
 
 Dictionary::~Dictionary() {

src/core/GodotGlobal.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  GodotGlobal.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "GodotGlobal.hpp"
 
 #include "String.hpp"
@@ -55,9 +85,12 @@ void Godot::print_warning(const String &description, const String &function, con
 		godot::api->godot_print_warning(c_desc, c_func, c_file, line);
 	};
 
-	if (c_desc != nullptr) godot::api->godot_free(c_desc);
-	if (c_func != nullptr) godot::api->godot_free(c_func);
-	if (c_file != nullptr) godot::api->godot_free(c_file);
+	if (c_desc != nullptr)
+		godot::api->godot_free(c_desc);
+	if (c_func != nullptr)
+		godot::api->godot_free(c_func);
+	if (c_file != nullptr)
+		godot::api->godot_free(c_file);
 }
 
 void Godot::print_error(const String &description, const String &function, const String &file, int line) {
@@ -71,9 +104,12 @@ void Godot::print_error(const String &description, const String &function, const
 		godot::api->godot_print_error(c_desc, c_func, c_file, line);
 	};
 
-	if (c_desc != nullptr) godot::api->godot_free(c_desc);
-	if (c_func != nullptr) godot::api->godot_free(c_func);
-	if (c_file != nullptr) godot::api->godot_free(c_file);
+	if (c_desc != nullptr)
+		godot::api->godot_free(c_desc);
+	if (c_func != nullptr)
+		godot::api->godot_free(c_func);
+	if (c_file != nullptr)
+		godot::api->godot_free(c_file);
 }
 
 void ___register_types();
@@ -136,10 +172,18 @@ void Godot::gdnative_init(godot_gdnative_init_options *options) {
 				}
 			} break;
 
-			default: break;
+			default:
+				break;
 		}
 	}
 
+	// Initialize the `language_index` here since `__register_types()` makes use of it.
+	godot_instance_binding_functions binding_funcs = {};
+	binding_funcs.alloc_instance_binding_data = wrapper_create;
+	binding_funcs.free_instance_binding_data = wrapper_destroy;
+
+	godot::_RegisterState::language_index = godot::nativescript_1_1_api->godot_nativescript_register_instance_binding_data_functions(binding_funcs);
+
 	// register these now
 	___register_types();
 	___init_method_bindings();
@@ -155,12 +199,6 @@ void Godot::gdnative_profiling_add_data(const char *p_signature, uint64_t p_time
 
 void Godot::nativescript_init(void *handle) {
 	godot::_RegisterState::nativescript_handle = handle;
-
-	godot_instance_binding_functions binding_funcs = {};
-	binding_funcs.alloc_instance_binding_data = wrapper_create;
-	binding_funcs.free_instance_binding_data = wrapper_destroy;
-
-	godot::_RegisterState::language_index = godot::nativescript_1_1_api->godot_nativescript_register_instance_binding_data_functions(binding_funcs);
 }
 
 void Godot::nativescript_terminate(void *handle) {

src/core/NodePath.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  NodePath.cpp                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "NodePath.hpp"
 #include "GodotGlobal.hpp"
 #include "String.hpp"
@@ -27,8 +57,7 @@ NodePath::NodePath(const char *contents) {
 
 String NodePath::get_name(const int idx) const {
 	godot_string str = godot::api->godot_node_path_get_name(&_node_path, idx);
-
-	return *(String *)&str;
+	return String(str);
 }
 
 int NodePath::get_name_count() const {
@@ -37,7 +66,7 @@ int NodePath::get_name_count() const {
 
 String NodePath::get_subname(const int idx) const {
 	godot_string str = godot::api->godot_node_path_get_subname(&_node_path, idx);
-	return *(String *)&str;
+	return String(str);
 }
 
 int NodePath::get_subname_count() const {
@@ -54,17 +83,16 @@ bool NodePath::is_empty() const {
 
 NodePath NodePath::get_as_property_path() const {
 	godot_node_path path = godot::core_1_1_api->godot_node_path_get_as_property_path(&_node_path);
-	return *(NodePath *)&path;
+	return NodePath(path);
 }
 String NodePath::get_concatenated_subnames() const {
 	godot_string str = godot::api->godot_node_path_get_concatenated_subnames(&_node_path);
-	return *(String *)&str;
+	return String(str);
 }
 
 NodePath::operator String() const {
 	godot_string str = godot::api->godot_node_path_as_string(&_node_path);
-
-	return *(String *)&str;
+	return String(str);
 }
 
 bool NodePath::operator==(const NodePath &other) {

src/core/Plane.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Plane.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Plane.hpp"
 #include "Vector3.hpp"
 
@@ -10,12 +40,10 @@ void Plane::set_normal(const Vector3 &p_normal) {
 }
 
 Vector3 Plane::project(const Vector3 &p_point) const {
-
 	return p_point - normal * distance_to(p_point);
 }
 
 void Plane::normalize() {
-
 	real_t l = normal.length();
 	if (l == 0) {
 		*this = Plane(0, 0, 0, 0);
@@ -26,19 +54,16 @@ void Plane::normalize() {
 }
 
 Plane Plane::normalized() const {
-
 	Plane p = *this;
 	p.normalize();
 	return p;
 }
 
 Vector3 Plane::get_any_point() const {
-
 	return get_normal() * d;
 }
 
 Vector3 Plane::get_any_perpendicular_normal() const {
-
 	static const Vector3 p1 = Vector3(1, 0, 0);
 	static const Vector3 p2 = Vector3(0, 1, 0);
 	Vector3 p;
@@ -57,7 +82,6 @@ Vector3 Plane::get_any_perpendicular_normal() const {
 /* intersections */
 
 bool Plane::intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result) const {
-
 	const Plane &p_plane0 = *this;
 	Vector3 normal0 = p_plane0.normal;
 	Vector3 normal1 = p_plane1.normal;
@@ -79,13 +103,11 @@ bool Plane::intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r
 }
 
 bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3 *p_intersection) const {
-
 	Vector3 segment = p_dir;
 	real_t den = normal.dot(segment);
 
 	//printf("den is %i\n",den);
 	if (::fabs(den) <= CMP_EPSILON) {
-
 		return false;
 	}
 
@@ -104,13 +126,11 @@ bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3 *p_intersectio
 }
 
 bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_intersection) const {
-
 	Vector3 segment = p_begin - p_end;
 	real_t den = normal.dot(segment);
 
 	//printf("den is %i\n",den);
 	if (::fabs(den) <= CMP_EPSILON) {
-
 		return false;
 	}
 
@@ -118,7 +138,6 @@ bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_inters
 	//printf("dist is %i\n",dist);
 
 	if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) {
-
 		return false;
 	}
 
@@ -131,47 +150,39 @@ bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_inters
 /* misc */
 
 bool Plane::is_almost_like(const Plane &p_plane) const {
-
 	return (normal.dot(p_plane.normal) > _PLANE_EQ_DOT_EPSILON && ::fabs(d - p_plane.d) < _PLANE_EQ_D_EPSILON);
 }
 
 Plane::operator String() const {
-
 	// return normal.operator String() + ", " + rtos(d);
 	return String(); // @Todo
 }
 
 bool Plane::is_point_over(const Vector3 &p_point) const {
-
 	return (normal.dot(p_point) > d);
 }
 
 real_t Plane::distance_to(const Vector3 &p_point) const {
-
 	return (normal.dot(p_point) - d);
 }
 
 bool Plane::has_point(const Vector3 &p_point, real_t _epsilon) const {
-
 	real_t dist = normal.dot(p_point) - d;
 	dist = ::fabs(dist);
 	return (dist <= _epsilon);
 }
 
 Plane::Plane(const Vector3 &p_normal, real_t p_d) {
-
 	normal = p_normal;
 	d = p_d;
 }
 
 Plane::Plane(const Vector3 &p_point, const Vector3 &p_normal) {
-
 	normal = p_normal;
 	d = p_normal.dot(p_point);
 }
 
 Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3, ClockDirection p_dir) {
-
 	if (p_dir == CLOCKWISE)
 		normal = (p_point1 - p_point3).cross(p_point1 - p_point2);
 	else
@@ -182,12 +193,10 @@ Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_
 }
 
 bool Plane::operator==(const Plane &p_plane) const {
-
 	return normal == p_plane.normal && d == p_plane.d;
 }
 
 bool Plane::operator!=(const Plane &p_plane) const {
-
 	return normal != p_plane.normal || d != p_plane.d;
 }
 

src/core/PoolArrays.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  PoolArrays.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "PoolArrays.hpp"
 #include "Color.hpp"
 #include "Defs.hpp"

src/core/Quat.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Quat.cpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Quat.hpp"
 #include "Basis.hpp"
 #include "Defs.hpp"
@@ -7,6 +37,8 @@
 
 namespace godot {
 
+const Quat Quat::IDENTITY = Quat();
+
 // set_euler_xyz expects a vector containing the Euler angles in the format
 // (ax,ay,az), where ax is the angle of rotation around x axis,
 // and similar for other axes.
@@ -98,7 +130,6 @@ Quat Quat::inverse() const {
 }
 
 Quat Quat::slerp(const Quat &q, const real_t &t) const {
-
 	Quat to1;
 	real_t omega, cosom, sinom, scale0, scale1;
 
@@ -142,12 +173,12 @@ Quat Quat::slerp(const Quat &q, const real_t &t) const {
 }
 
 Quat Quat::slerpni(const Quat &q, const real_t &t) const {
-
 	const Quat &from = *this;
 
 	real_t dot = from.dot(q);
 
-	if (::fabs(dot) > 0.9999) return from;
+	if (::fabs(dot) > 0.9999)
+		return from;
 
 	real_t theta = ::acos(dot),
 		   sinT = 1.0 / ::sin(theta),
@@ -198,7 +229,6 @@ Quat Quat::operator*(const Vector3 &v) const {
 }
 
 Vector3 Quat::xform(const Vector3 &v) const {
-
 	Quat q = *this * v;
 	q *= this->inverse();
 	return Vector3(q.x, q.y, q.z);
@@ -232,7 +262,6 @@ Quat::Quat(const Vector3 &v0, const Vector3 &v1) // shortest arc
 		z = 0;
 		w = 0;
 	} else {
-
 		real_t s = ::sqrt((1.0 + d) * 2.0);
 		real_t rs = 1.0 / s;
 
@@ -280,7 +309,6 @@ void Quat::operator*=(const real_t &s) {
 }
 
 void Quat::operator/=(const real_t &s) {
-
 	*this *= 1.0 / s;
 }
 

src/core/RID.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  RID.cpp                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "RID.hpp"
 
 #include <gdnative/rid.h>
@@ -14,7 +44,11 @@ RID::RID(Object *p) {
 	godot::api->godot_rid_new_with_resource(&_godot_rid, (const godot_object *)p);
 }
 
-int32_t RID::get_rid() const {
+godot_rid RID::_get_godot_rid() const {
+	return _godot_rid;
+}
+
+int32_t RID::get_id() const {
 	return godot::api->godot_rid_get_id(&_godot_rid);
 }
 

src/core/Rect2.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Rect2.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Rect2.hpp"
 #include "String.hpp"
 #include "Transform2D.hpp"
@@ -16,26 +46,35 @@ namespace godot {
 #endif
 
 real_t Rect2::distance_to(const Vector2 &p_point) const {
-
-	real_t dist = 1e20;
+	real_t dist = 0.0;
+	bool inside = true;
 
 	if (p_point.x < position.x) {
-		dist = MIN(dist, position.x - p_point.x);
+		real_t d = position.x - p_point.x;
+		dist = d;
+		inside = false;
 	}
 	if (p_point.y < position.y) {
-		dist = MIN(dist, position.y - p_point.y);
+		real_t d = position.y - p_point.y;
+		dist = inside ? d : MIN(dist, d);
+		inside = false;
 	}
 	if (p_point.x >= (position.x + size.x)) {
-		dist = MIN(p_point.x - (position.x + size.x), dist);
+		real_t d = p_point.x - (position.x + size.x);
+		dist = inside ? d : MIN(dist, d);
+		inside = false;
 	}
 	if (p_point.y >= (position.y + size.y)) {
-		dist = MIN(p_point.y - (position.y + size.y), dist);
+		real_t d = p_point.y - (position.y + size.y);
+		dist = inside ? d : MIN(dist, d);
+		inside = false;
 	}
 
-	if (dist == 1e20)
+	if (inside) {
 		return 0;
-	else
+	} else {
 		return dist;
+	}
 }
 
 Rect2 Rect2::clip(const Rect2 &p_rect) const { /// return a clipped rect
@@ -77,7 +116,6 @@ Rect2::operator String() const {
 }
 
 bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_position, Point2 *r_normal) const {
-
 	real_t min = 0, max = 1;
 	int axis = 0;
 	real_t sign = 0;
@@ -91,7 +129,6 @@ bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2
 		real_t csign;
 
 		if (seg_from < seg_to) {
-
 			if (seg_from > box_end || seg_to < box_begin)
 				return false;
 			real_t length = seg_to - seg_from;
@@ -100,7 +137,6 @@ bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2
 			csign = -1.0;
 
 		} else {
-
 			if (seg_to > box_end || seg_from < box_begin)
 				return false;
 			real_t length = seg_to - seg_from;
@@ -135,7 +171,6 @@ bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2
 }
 
 bool Rect2::intersects_transformed(const Transform2D &p_xform, const Rect2 &p_rect) const {
-
 	//SAT intersection between local and transformed rect2
 
 	Vector2 xf_points[4] = {

src/core/String.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  String.cpp                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "String.hpp"
 
 #include "Array.hpp"
@@ -25,52 +55,31 @@ const char *godot::CharString::get_data() const {
 }
 
 String String::num(double p_num, int p_decimals) {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_num_with_decimals(p_num, p_decimals);
-
-	return new_string;
+	return String(godot::api->godot_string_num_with_decimals(p_num, p_decimals));
 }
 
 String String::num_scientific(double p_num) {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_num_scientific(p_num);
-
-	return new_string;
+	return String(godot::api->godot_string_num_scientific(p_num));
 }
 
 String String::num_real(double p_num) {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_num_real(p_num);
-
-	return new_string;
+	return String(godot::api->godot_string_num_real(p_num));
 }
 
 String String::num_int64(int64_t p_num, int base, bool capitalize_hex) {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_num_int64_capitalized(p_num, base, capitalize_hex);
-
-	return new_string;
+	return String(godot::api->godot_string_num_int64_capitalized(p_num, base, capitalize_hex));
 }
 
 String String::chr(godot_char_type p_char) {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_chr(p_char);
-
-	return new_string;
+	return String(godot::api->godot_string_chr(p_char));
 }
 
 String String::md5(const uint8_t *p_md5) {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_md5(p_md5);
-
-	return new_string;
+	return String(godot::api->godot_string_md5(p_md5));
 }
 
 String String::hex_encode_buffer(const uint8_t *p_buffer, int p_len) {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_hex_encode_buffer(p_buffer, p_len);
-
-	return new_string;
+	return String(godot::api->godot_string_hex_encode_buffer(p_buffer, p_len));
 }
 
 godot::String::String() {
@@ -94,6 +103,10 @@ String::String(const String &other) {
 	godot::api->godot_string_new_copy(&_godot_string, &other._godot_string);
 }
 
+String::String(String &&other) {
+	godot::api->godot_string_new_copy(&_godot_string, &other._godot_string);
+}
+
 String::~String() {
 	godot::api->godot_string_destroy(&_godot_string);
 }
@@ -115,6 +128,11 @@ void String::operator=(const String &s) {
 	godot::api->godot_string_new_copy(&_godot_string, &s._godot_string);
 }
 
+void String::operator=(String &&s) {
+	godot::api->godot_string_destroy(&_godot_string);
+	godot::api->godot_string_new_copy(&_godot_string, &s._godot_string);
+}
+
 bool String::operator==(const String &s) const {
 	return godot::api->godot_string_operator_equal(&_godot_string, &s._godot_string);
 }
@@ -124,18 +142,16 @@ bool String::operator!=(const String &s) const {
 }
 
 String String::operator+(const String &s) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_operator_plus(&_godot_string, &s._godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_operator_plus(&_godot_string, &s._godot_string));
 }
 
 void String::operator+=(const String &s) {
-	_godot_string = godot::api->godot_string_operator_plus(&_godot_string, &s._godot_string);
+	*this = String(godot::api->godot_string_operator_plus(&_godot_string, &s._godot_string));
 }
 
 void String::operator+=(const wchar_t c) {
-	// @Todo
+	String _to_be_added = String(c);
+	*this = String(godot::api->godot_string_operator_plus(&_godot_string, &_to_be_added._godot_string));
 }
 
 bool String::operator<(const String &s) const {
@@ -164,7 +180,6 @@ const wchar_t *String::unicode_str() const {
 }
 
 char *String::alloc_c_string() const {
-
 	godot_char_string contents = godot::api->godot_string_utf8(&_godot_string);
 
 	int length = godot::api->godot_char_string_length(&contents);
@@ -189,7 +204,6 @@ CharString String::utf8() const {
 }
 
 CharString String::ascii(bool p_extended) const {
-
 	CharString ret;
 
 	if (p_extended)
@@ -208,7 +222,7 @@ String operator+(const wchar_t *a, const String &b) {
 	return String(a) + b;
 }
 
-bool String::begins_with(String &p_string) const {
+bool String::begins_with(const String &p_string) const {
 	return godot::api->godot_string_begins_with(&_godot_string, &p_string._godot_string);
 }
 
@@ -218,36 +232,26 @@ bool String::begins_with_char_array(const char *p_char_array) const {
 
 PoolStringArray String::bigrams() const {
 	godot_array arr = godot::api->godot_string_bigrams(&_godot_string);
-
-	return *(Array *)&arr;
+	return Array(arr);
 }
 
 String String::c_escape() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_c_escape(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_c_escape(&_godot_string));
 }
 
 String String::c_unescape() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_c_unescape(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_c_unescape(&_godot_string));
 }
 
 String String::capitalize() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_capitalize(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_capitalize(&_godot_string));
 }
 
 bool String::empty() const {
 	return godot::api->godot_string_empty(&_godot_string);
 }
 
-bool String::ends_with(String &p_string) const {
+bool String::ends_with(const String &p_string) const {
 	return godot::api->godot_string_ends_with(&_godot_string, &p_string._godot_string);
 }
 
@@ -268,41 +272,31 @@ int String::findn(String p_what, int p_from) const {
 }
 
 String String::format(Variant values) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_format(&_godot_string, (godot_variant *)&values);
-
-	return new_string;
+	return String(godot::api->godot_string_format(&_godot_string, (godot_variant *)&values));
 }
 
 String String::format(Variant values, String placeholder) const {
-	String new_string;
 	godot_char_string contents = godot::api->godot_string_utf8(&placeholder._godot_string);
-	new_string._godot_string = godot::api->godot_string_format_with_custom_placeholder(&_godot_string, (godot_variant *)&values, godot::api->godot_char_string_get_data(&contents));
+	String new_string(godot::api->godot_string_format_with_custom_placeholder(&_godot_string, (godot_variant *)&values, godot::api->godot_char_string_get_data(&contents)));
 	godot::api->godot_char_string_destroy(&contents);
 
 	return new_string;
 }
 
 String String::get_base_dir() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_get_base_dir(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_get_base_dir(&_godot_string));
 }
 
 String String::get_basename() const {
-	godot_string new_string = godot::api->godot_string_get_basename(&_godot_string);
-	return *(String *)&new_string;
+	return String(godot::api->godot_string_get_basename(&_godot_string));
 }
 
 String String::get_extension() const {
-	godot_string new_string = godot::api->godot_string_get_extension(&_godot_string);
-	return *(String *)&new_string;
+	return String(godot::api->godot_string_get_extension(&_godot_string));
 }
 
 String String::get_file() const {
-	godot_string new_string = godot::api->godot_string_get_file(&_godot_string);
-	return *(String *)&new_string;
+	return String(godot::api->godot_string_get_file(&_godot_string));
 }
 
 int String::hash() const {
@@ -314,10 +308,7 @@ int String::hex_to_int() const {
 }
 
 String String::insert(int position, String what) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_insert(&_godot_string, position, what._godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_insert(&_godot_string, position, what._godot_string));
 }
 
 bool String::is_abs_path() const {
@@ -357,17 +348,11 @@ bool String::is_valid_ip_address() const {
 }
 
 String String::json_escape() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_json_escape(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_json_escape(&_godot_string));
 }
 
 String String::left(int position) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_left(&_godot_string, position);
-
-	return new_string;
+	return String(godot::api->godot_string_left(&_godot_string, position));
 }
 
 bool String::match(String expr) const {
@@ -380,14 +365,11 @@ bool String::matchn(String expr) const {
 
 PoolByteArray String::md5_buffer() const {
 	godot_pool_byte_array arr = godot::api->godot_string_md5_buffer(&_godot_string);
-	return *(PoolByteArray *)&arr;
+	return PoolByteArray(arr);
 }
 
 String String::md5_text() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_md5_text(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_md5_text(&_godot_string));
 }
 
 int String::ord_at(int at) const {
@@ -395,52 +377,31 @@ int String::ord_at(int at) const {
 }
 
 String String::pad_decimals(int digits) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_pad_decimals(&_godot_string, digits);
-
-	return new_string;
+	return String(godot::api->godot_string_pad_decimals(&_godot_string, digits));
 }
 
 String String::pad_zeros(int digits) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_pad_zeros(&_godot_string, digits);
-
-	return new_string;
+	return String(godot::api->godot_string_pad_zeros(&_godot_string, digits));
 }
 
 String String::percent_decode() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_percent_decode(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_percent_decode(&_godot_string));
 }
 
 String String::percent_encode() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_percent_encode(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_percent_encode(&_godot_string));
 }
 
 String String::plus_file(String file) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_plus_file(&_godot_string, &file._godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_plus_file(&_godot_string, &file._godot_string));
 }
 
 String String::replace(String p_key, String p_with) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_replace(&_godot_string, p_key._godot_string, p_with._godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_replace(&_godot_string, p_key._godot_string, p_with._godot_string));
 }
 
 String String::replacen(String what, String forwhat) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_replacen(&_godot_string, what._godot_string, forwhat._godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_replacen(&_godot_string, what._godot_string, forwhat._godot_string));
 }
 
 int String::rfind(String p_what, int p_from) const {
@@ -452,59 +413,48 @@ int String::rfindn(String p_what, int p_from) const {
 }
 
 String String::right(int position) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_right(&_godot_string, position);
-
-	return new_string;
+	return String(godot::api->godot_string_right(&_godot_string, position));
 }
 
 PoolByteArray String::sha256_buffer() const {
 	godot_pool_byte_array arr = godot::api->godot_string_sha256_buffer(&_godot_string);
-
-	return *(PoolByteArray *)&arr;
+	return PoolByteArray(arr);
 }
 
 String String::sha256_text() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_sha256_text(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_sha256_text(&_godot_string));
 }
 
 float String::similarity(String text) const {
 	return godot::api->godot_string_similarity(&_godot_string, &text._godot_string);
 }
 
-PoolStringArray String::split(String divisor, bool allow_empty) const {
+// TODO Suport allow_empty
+PoolStringArray String::split(String divisor, bool /*allow_empty*/) const {
 	godot_array arr = godot::api->godot_string_split(&_godot_string, &divisor._godot_string);
-
-	return *(Array *)&arr;
+	return Array(arr);
 }
 
-PoolIntArray String::split_ints(String divisor, bool allow_empty) const {
+// TODO Suport allow_empty
+PoolIntArray String::split_ints(String divisor, bool /*allow_empty*/) const {
 	godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string);
-
-	return *(Array *)&arr;
+	return Array(arr);
 }
 
-PoolRealArray String::split_floats(String divisor, bool allow_empty) const {
+// TODO Suport allow_empty
+PoolRealArray String::split_floats(String divisor, bool /*allow_empty*/) const {
+	// TODO The GDNative API returns godot_array, when according to the doc, it should have been godot_pool_real_array
 	godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string);
-
-	return *(Array *)&arr;
+	Array wrapped_array(arr);
+	return PoolRealArray(wrapped_array);
 }
 
 String String::strip_edges(bool left, bool right) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_strip_edges(&_godot_string, left, right);
-
-	return new_string;
+	return String(godot::api->godot_string_strip_edges(&_godot_string, left, right));
 }
 
 String String::substr(int from, int len) const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_substr(&_godot_string, from, len);
-
-	return new_string;
+	return String(godot::api->godot_string_substr(&_godot_string, from, len));
 }
 
 float String::to_float() const {
@@ -516,31 +466,19 @@ int64_t String::to_int() const {
 }
 
 String String::to_lower() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_to_lower(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_to_lower(&_godot_string));
 }
 
 String String::to_upper() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_to_upper(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_to_upper(&_godot_string));
 }
 
 String String::xml_escape() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_xml_escape(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_xml_escape(&_godot_string));
 }
 
 String String::xml_unescape() const {
-	String new_string;
-	new_string._godot_string = godot::api->godot_string_xml_unescape(&_godot_string);
-
-	return new_string;
+	return String(godot::api->godot_string_xml_unescape(&_godot_string));
 }
 
 signed char String::casecmp_to(String p_str) const {
@@ -556,33 +494,29 @@ signed char String::naturalnocasecmp_to(String p_str) const {
 }
 
 String String::dedent() const {
-	String new_string;
-	new_string._godot_string = godot::core_1_1_api->godot_string_dedent(&_godot_string);
-	return new_string;
+	godot_string s = godot::core_1_1_api->godot_string_dedent(&_godot_string);
+	return String(s);
 }
 
-PoolStringArray String::rsplit(const String &divisor, const bool allow_empty,
-		const int maxsplit) const {
-	godot_pool_string_array arr = godot::core_1_1_api->godot_string_rsplit(&_godot_string, &divisor._godot_string, allow_empty, maxsplit);
-	return *(PoolStringArray *)&arr;
+PoolStringArray String::rsplit(const String &divisor, const bool allow_empty, const int maxsplit) const {
+	godot_pool_string_array arr =
+			godot::core_1_1_api->godot_string_rsplit(&_godot_string, &divisor._godot_string, allow_empty, maxsplit);
+	return PoolStringArray(arr);
 }
 
 String String::rstrip(const String &chars) const {
-	String new_string;
-	new_string._godot_string = godot::core_1_1_api->godot_string_rstrip(&_godot_string, &chars._godot_string);
-	return new_string;
+	godot_string s = godot::core_1_1_api->godot_string_rstrip(&_godot_string, &chars._godot_string);
+	return String(s);
 }
 
 String String::trim_prefix(const String &prefix) const {
-	String new_string;
-	new_string._godot_string = godot::core_1_1_api->godot_string_trim_prefix(&_godot_string, &prefix._godot_string);
-	return new_string;
+	godot_string s = godot::core_1_1_api->godot_string_trim_prefix(&_godot_string, &prefix._godot_string);
+	return String(s);
 }
 
 String String::trim_suffix(const String &suffix) const {
-	String new_string;
-	new_string._godot_string = godot::core_1_1_api->godot_string_trim_suffix(&_godot_string, &suffix._godot_string);
-	return new_string;
+	godot_string s = godot::core_1_1_api->godot_string_trim_suffix(&_godot_string, &suffix._godot_string);
+	return String(s);
 }
 
 } // namespace godot

src/core/TagDB.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  TagDP.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "TagDB.hpp"
 
 #include <unordered_map>
@@ -22,14 +52,12 @@ bool is_type_known(size_t type_tag) {
 }
 
 void register_global_type(const char *name, size_t type_tag, size_t base_type_tag) {
-
 	godot::nativescript_1_1_api->godot_nativescript_set_global_type_tag(godot::_RegisterState::language_index, name, (const void *)type_tag);
 
 	register_type(type_tag, base_type_tag);
 }
 
 bool is_type_compatible(size_t ask_tag, size_t have_tag) {
-
 	if (have_tag == 0)
 		return false;
 

src/core/Transform.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Transform.cpp                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Transform.hpp"
 
 #include "Basis.hpp"
@@ -9,15 +39,18 @@
 
 namespace godot {
 
-Transform Transform::inverse_xform(const Transform &t) const {
+const Transform Transform::IDENTITY = Transform();
+const Transform Transform::FLIP_X = Transform(-1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0);
+const Transform Transform::FLIP_Y = Transform(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0);
+const Transform Transform::FLIP_Z = Transform(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0);
 
+Transform Transform::inverse_xform(const Transform &t) const {
 	Vector3 v = t.origin - origin;
 	return Transform(basis.transpose_xform(t.basis),
 			basis.xform(v));
 }
 
 void Transform::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t tx, real_t ty, real_t tz) {
-
 	basis.elements[0][0] = xx;
 	basis.elements[0][1] = xy;
 	basis.elements[0][2] = xz;
@@ -33,14 +66,12 @@ void Transform::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_
 }
 
 Vector3 Transform::xform(const Vector3 &p_vector) const {
-
 	return Vector3(
 			basis.elements[0].dot(p_vector) + origin.x,
 			basis.elements[1].dot(p_vector) + origin.y,
 			basis.elements[2].dot(p_vector) + origin.z);
 }
 Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
-
 	Vector3 v = p_vector - origin;
 
 	return Vector3(
@@ -50,7 +81,6 @@ Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
 }
 
 Plane Transform::xform(const Plane &p_plane) const {
-
 	Vector3 point = p_plane.normal * p_plane.d;
 	Vector3 point_dir = point + p_plane.normal;
 	point = xform(point);
@@ -63,7 +93,6 @@ Plane Transform::xform(const Plane &p_plane) const {
 	return Plane(normal, d);
 }
 Plane Transform::xform_inv(const Plane &p_plane) const {
-
 	Vector3 point = p_plane.normal * p_plane.d;
 	Vector3 point_dir = point + p_plane.normal;
 	point = xform_inv(point);
@@ -95,7 +124,6 @@ AABB Transform::xform(const AABB &p_aabb) const {
 	return new_aabb;
 }
 AABB Transform::xform_inv(const AABB &p_aabb) const {
-
 	/* define vertices */
 	Vector3 vertices[8] = {
 		Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z + p_aabb.size.z),
@@ -113,7 +141,6 @@ AABB Transform::xform_inv(const AABB &p_aabb) const {
 	ret.position = xform_inv(vertices[0]);
 
 	for (int i = 1; i < 8; i++) {
-
 		ret.expand_to(xform_inv(vertices[i]));
 	}
 
@@ -121,20 +148,17 @@ AABB Transform::xform_inv(const AABB &p_aabb) const {
 }
 
 void Transform::affine_invert() {
-
 	basis.invert();
 	origin = basis.xform(-origin);
 }
 
 Transform Transform::affine_inverse() const {
-
 	Transform ret = *this;
 	ret.affine_invert();
 	return ret;
 }
 
 void Transform::invert() {
-
 	basis.transpose();
 	origin = basis.xform(-origin);
 }
@@ -148,29 +172,24 @@ Transform Transform::inverse() const {
 }
 
 void Transform::rotate(const Vector3 &p_axis, real_t p_phi) {
-
 	*this = rotated(p_axis, p_phi);
 }
 
 Transform Transform::rotated(const Vector3 &p_axis, real_t p_phi) const {
-
 	return Transform(Basis(p_axis, p_phi), Vector3()) * (*this);
 }
 
 void Transform::rotate_basis(const Vector3 &p_axis, real_t p_phi) {
-
 	basis.rotate(p_axis, p_phi);
 }
 
 Transform Transform::looking_at(const Vector3 &p_target, const Vector3 &p_up) const {
-
 	Transform t = *this;
 	t.set_look_at(origin, p_target, p_up);
 	return t;
 }
 
 void Transform::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const Vector3 &p_up) {
-
 	// Reference: MESA source code
 	Vector3 v_x, v_y, v_z;
 
@@ -198,7 +217,6 @@ void Transform::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const
 }
 
 Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c) const {
-
 	/* not sure if very "efficient" but good enough? */
 
 	Vector3 src_scale = basis.get_scale();
@@ -218,20 +236,17 @@ Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c)
 }
 
 void Transform::scale(const Vector3 &p_scale) {
-
 	basis.scale(p_scale);
 	origin *= p_scale;
 }
 
 Transform Transform::scaled(const Vector3 &p_scale) const {
-
 	Transform t = *this;
 	t.scale(p_scale);
 	return t;
 }
 
 void Transform::scale_basis(const Vector3 &p_scale) {
-
 	basis.scale(p_scale);
 }
 
@@ -239,60 +254,50 @@ void Transform::translate(real_t p_tx, real_t p_ty, real_t p_tz) {
 	translate(Vector3(p_tx, p_ty, p_tz));
 }
 void Transform::translate(const Vector3 &p_translation) {
-
 	for (int i = 0; i < 3; i++) {
 		origin[i] += basis.elements[i].dot(p_translation);
 	}
 }
 
 Transform Transform::translated(const Vector3 &p_translation) const {
-
 	Transform t = *this;
 	t.translate(p_translation);
 	return t;
 }
 
 void Transform::orthonormalize() {
-
 	basis.orthonormalize();
 }
 
 Transform Transform::orthonormalized() const {
-
 	Transform _copy = *this;
 	_copy.orthonormalize();
 	return _copy;
 }
 
 bool Transform::operator==(const Transform &p_transform) const {
-
 	return (basis == p_transform.basis && origin == p_transform.origin);
 }
 bool Transform::operator!=(const Transform &p_transform) const {
-
 	return (basis != p_transform.basis || origin != p_transform.origin);
 }
 
 void Transform::operator*=(const Transform &p_transform) {
-
 	origin = xform(p_transform.origin);
 	basis *= p_transform.basis;
 }
 
 Transform Transform::operator*(const Transform &p_transform) const {
-
 	Transform t = *this;
 	t *= p_transform;
 	return t;
 }
 
 Transform::operator String() const {
-
 	return basis.operator String() + " - " + origin.operator String();
 }
 
 Transform::Transform(const Basis &p_basis, const Vector3 &p_origin) {
-
 	basis = p_basis;
 	origin = p_origin;
 }

src/core/Transform2D.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Transform2D.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Transform2D.hpp"
 #include "Rect2.hpp"
 #include "String.hpp"
@@ -7,8 +37,11 @@
 
 namespace godot {
 
-Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) {
+const Transform2D Transform2D::IDENTITY;
+const Transform2D Transform2D::FLIP_X = Transform2D(-1, 0, 0, 1, 0, 0);
+const Transform2D Transform2D::FLIP_Y = Transform2D(1, 0, 0, -1, 0, 0);
 
+Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) {
 	elements[0][0] = xx;
 	elements[0][1] = xy;
 	elements[1][0] = yx;
@@ -18,28 +51,24 @@ Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox,
 }
 
 Vector2 Transform2D::basis_xform(const Vector2 &v) const {
-
 	return Vector2(
 			tdotx(v),
 			tdoty(v));
 }
 
 Vector2 Transform2D::basis_xform_inv(const Vector2 &v) const {
-
 	return Vector2(
 			elements[0].dot(v),
 			elements[1].dot(v));
 }
 
 Vector2 Transform2D::xform(const Vector2 &v) const {
-
 	return Vector2(
 				   tdotx(v),
 				   tdoty(v)) +
 		   elements[2];
 }
 Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
-
 	Vector2 v = p_vec - elements[2];
 
 	return Vector2(
@@ -47,7 +76,6 @@ Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
 			elements[1].dot(v));
 }
 Rect2 Transform2D::xform(const Rect2 &p_rect) const {
-
 	Vector2 x = elements[0] * p_rect.size.x;
 	Vector2 y = elements[1] * p_rect.size.y;
 	Vector2 position = xform(p_rect.position);
@@ -61,7 +89,6 @@ Rect2 Transform2D::xform(const Rect2 &p_rect) const {
 }
 
 void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) {
-
 	elements[0][0] = ::cos(p_rot) * p_scale.x;
 	elements[1][1] = ::cos(p_rot) * p_scale.y;
 	elements[1][0] = -::sin(p_rot) * p_scale.y;
@@ -69,7 +96,6 @@ void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) {
 }
 
 Rect2 Transform2D::xform_inv(const Rect2 &p_rect) const {
-
 	Vector2 ends[4] = {
 		xform_inv(p_rect.position),
 		xform_inv(Vector2(p_rect.position.x, p_rect.position.y + p_rect.size.y)),
@@ -94,14 +120,12 @@ void Transform2D::invert() {
 }
 
 Transform2D Transform2D::inverse() const {
-
 	Transform2D inv = *this;
 	inv.invert();
 	return inv;
 }
 
 void Transform2D::affine_invert() {
-
 	real_t det = basis_determinant();
 	ERR_FAIL_COND(det == 0);
 	real_t idet = 1.0 / det;
@@ -114,7 +138,6 @@ void Transform2D::affine_invert() {
 }
 
 Transform2D Transform2D::affine_inverse() const {
-
 	Transform2D inv = *this;
 	inv.affine_invert();
 	return inv;
@@ -134,7 +157,6 @@ real_t Transform2D::get_rotation() const {
 }
 
 void Transform2D::set_rotation(real_t p_rot) {
-
 	real_t cr = ::cos(p_rot);
 	real_t sr = ::sin(p_rot);
 	elements[0][0] = cr;
@@ -144,7 +166,6 @@ void Transform2D::set_rotation(real_t p_rot) {
 }
 
 Transform2D::Transform2D(real_t p_rot, const Vector2 &p_position) {
-
 	real_t cr = ::cos(p_rot);
 	real_t sr = ::sin(p_rot);
 	elements[0][0] = cr;
@@ -164,23 +185,19 @@ void Transform2D::scale(const Size2 &p_scale) {
 	elements[2] *= p_scale;
 }
 void Transform2D::scale_basis(const Size2 &p_scale) {
-
 	elements[0][0] *= p_scale.x;
 	elements[0][1] *= p_scale.y;
 	elements[1][0] *= p_scale.x;
 	elements[1][1] *= p_scale.y;
 }
 void Transform2D::translate(real_t p_tx, real_t p_ty) {
-
 	translate(Vector2(p_tx, p_ty));
 }
 void Transform2D::translate(const Vector2 &p_translation) {
-
 	elements[2] += basis_xform(p_translation);
 }
 
 void Transform2D::orthonormalize() {
-
 	// Gram-Schmidt Process
 
 	Vector2 x = elements[0];
@@ -194,14 +211,12 @@ void Transform2D::orthonormalize() {
 	elements[1] = y;
 }
 Transform2D Transform2D::orthonormalized() const {
-
 	Transform2D on = *this;
 	on.orthonormalize();
 	return on;
 }
 
 bool Transform2D::operator==(const Transform2D &p_transform) const {
-
 	for (int i = 0; i < 3; i++) {
 		if (elements[i] != p_transform.elements[i])
 			return false;
@@ -211,7 +226,6 @@ bool Transform2D::operator==(const Transform2D &p_transform) const {
 }
 
 bool Transform2D::operator!=(const Transform2D &p_transform) const {
-
 	for (int i = 0; i < 3; i++) {
 		if (elements[i] != p_transform.elements[i])
 			return true;
@@ -221,7 +235,6 @@ bool Transform2D::operator!=(const Transform2D &p_transform) const {
 }
 
 void Transform2D::operator*=(const Transform2D &p_transform) {
-
 	elements[2] = xform(p_transform.elements[2]);
 
 	real_t x0, x1, y0, y1;
@@ -238,54 +251,46 @@ void Transform2D::operator*=(const Transform2D &p_transform) {
 }
 
 Transform2D Transform2D::operator*(const Transform2D &p_transform) const {
-
 	Transform2D t = *this;
 	t *= p_transform;
 	return t;
 }
 
 Transform2D Transform2D::scaled(const Size2 &p_scale) const {
-
 	Transform2D copy = *this;
 	copy.scale(p_scale);
 	return copy;
 }
 
 Transform2D Transform2D::basis_scaled(const Size2 &p_scale) const {
-
 	Transform2D copy = *this;
 	copy.scale_basis(p_scale);
 	return copy;
 }
 
 Transform2D Transform2D::untranslated() const {
-
 	Transform2D copy = *this;
 	copy.elements[2] = Vector2();
 	return copy;
 }
 
 Transform2D Transform2D::translated(const Vector2 &p_offset) const {
-
 	Transform2D copy = *this;
 	copy.translate(p_offset);
 	return copy;
 }
 
 Transform2D Transform2D::rotated(real_t p_phi) const {
-
 	Transform2D copy = *this;
 	copy.rotate(p_phi);
 	return copy;
 }
 
 real_t Transform2D::basis_determinant() const {
-
 	return elements[0].x * elements[1].y - elements[0].y * elements[1].x;
 }
 
 Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t p_c) const {
-
 	//extract parameters
 	Vector2 p1 = get_origin();
 	Vector2 p2 = p_transform.get_origin();
@@ -321,7 +326,6 @@ Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t
 }
 
 Transform2D::operator String() const {
-
 	return String(String() + elements[0] + ", " + elements[1] + ", " + elements[2]);
 }
 

src/core/Variant.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Variant.cpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Variant.hpp"
 
 #include <gdnative/variant.h>
@@ -7,8 +37,6 @@
 #include "GodotGlobal.hpp"
 #include "Object.hpp"
 
-#include <iostream>
-
 namespace godot {
 
 Variant::Variant() {
@@ -160,6 +188,7 @@ Variant::Variant(const PoolColorArray &p_color_array) {
 }
 
 Variant &Variant::operator=(const Variant &v) {
+	godot::api->godot_variant_destroy(&_godot_variant);
 	godot::api->godot_variant_new_copy(&_godot_variant, &v._godot_variant);
 	return *this;
 }
@@ -205,9 +234,8 @@ Variant::operator double() const {
 	return godot::api->godot_variant_as_real(&_godot_variant);
 }
 Variant::operator String() const {
-	String ret;
-	*(godot_string *)&ret = godot::api->godot_variant_as_string(&_godot_variant);
-	return ret;
+	godot_string s = godot::api->godot_variant_as_string(&_godot_variant);
+	return String(s);
 }
 Variant::operator Vector2() const {
 	godot_vector2 s = godot::api->godot_variant_as_vector2(&_godot_variant);
@@ -251,9 +279,8 @@ Variant::operator Color() const {
 	return *(Color *)&s;
 }
 Variant::operator NodePath() const {
-	NodePath ret;
-	*(godot_node_path *)&ret = godot::api->godot_variant_as_node_path(&_godot_variant);
-	return ret;
+	godot_node_path ret = godot::api->godot_variant_as_node_path(&_godot_variant);
+	return NodePath(ret);
 }
 Variant::operator RID() const {
 	godot_rid s = godot::api->godot_variant_as_rid(&_godot_variant);
@@ -261,64 +288,55 @@ Variant::operator RID() const {
 }
 
 Variant::operator Dictionary() const {
-	Dictionary ret;
-	*(godot_dictionary *)&ret = godot::api->godot_variant_as_dictionary(&_godot_variant);
+	Dictionary ret(godot::api->godot_variant_as_dictionary(&_godot_variant));
 	return ret;
 }
 
 Variant::operator Array() const {
-	Array ret;
-	*(godot_array *)&ret = godot::api->godot_variant_as_array(&_godot_variant);
+	Array ret(godot::api->godot_variant_as_array(&_godot_variant));
 	return ret;
 }
 
 Variant::operator PoolByteArray() const {
-	PoolByteArray ret;
-	*(godot_pool_byte_array *)&ret = godot::api->godot_variant_as_pool_byte_array(&_godot_variant);
-	return ret;
+	godot_pool_byte_array ret = godot::api->godot_variant_as_pool_byte_array(&_godot_variant);
+	return PoolByteArray(ret);
 }
 Variant::operator PoolIntArray() const {
-	PoolIntArray ret;
-	*(godot_pool_int_array *)&ret = godot::api->godot_variant_as_pool_int_array(&_godot_variant);
-	return ret;
+	godot_pool_int_array ret = godot::api->godot_variant_as_pool_int_array(&_godot_variant);
+	return PoolIntArray(ret);
 }
 Variant::operator PoolRealArray() const {
-	PoolRealArray ret;
-	*(godot_pool_real_array *)&ret = godot::api->godot_variant_as_pool_real_array(&_godot_variant);
-	return ret;
+	godot_pool_real_array ret = godot::api->godot_variant_as_pool_real_array(&_godot_variant);
+	return PoolRealArray(ret);
 }
 Variant::operator PoolStringArray() const {
-	PoolStringArray ret;
-	*(godot_pool_string_array *)&ret = godot::api->godot_variant_as_pool_string_array(&_godot_variant);
-	return ret;
+	godot_pool_string_array ret = godot::api->godot_variant_as_pool_string_array(&_godot_variant);
+	return PoolStringArray(ret);
 }
 Variant::operator PoolVector2Array() const {
-	PoolVector2Array ret;
-	*(godot_pool_vector2_array *)&ret = godot::api->godot_variant_as_pool_vector2_array(&_godot_variant);
-	return ret;
+	godot_pool_vector2_array ret = godot::api->godot_variant_as_pool_vector2_array(&_godot_variant);
+	return PoolVector2Array(ret);
 }
 Variant::operator PoolVector3Array() const {
-	PoolVector3Array ret;
-	*(godot_pool_vector3_array *)&ret = godot::api->godot_variant_as_pool_vector3_array(&_godot_variant);
-	return ret;
+	godot_pool_vector3_array ret = godot::api->godot_variant_as_pool_vector3_array(&_godot_variant);
+	return PoolVector3Array(ret);
 }
 Variant::operator PoolColorArray() const {
-	PoolColorArray ret;
-	*(godot_pool_color_array *)&ret = godot::api->godot_variant_as_pool_color_array(&_godot_variant);
-	return ret;
+	godot_pool_color_array ret = godot::api->godot_variant_as_pool_color_array(&_godot_variant);
+	return PoolColorArray(ret);
 }
 Variant::operator godot_object *() const {
 	return godot::api->godot_variant_as_object(&_godot_variant);
 }
 
 Variant::Type Variant::get_type() const {
-	return (Type)godot::api->godot_variant_get_type(&_godot_variant);
+	return static_cast<Type>(godot::api->godot_variant_get_type(&_godot_variant));
 }
 
 Variant Variant::call(const String &method, const Variant **args, const int arg_count) {
-	Variant v;
-	*(godot_variant *)&v = godot::api->godot_variant_call(&_godot_variant, (godot_string *)&method, (const godot_variant **)args, arg_count, nullptr);
-	return v;
+	godot_variant v = godot::api->godot_variant_call(
+			&_godot_variant, (godot_string *)&method, (const godot_variant **)args, arg_count, nullptr);
+	return Variant(v);
 }
 
 bool Variant::has_method(const String &method) {

src/core/Vector2.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Vector2.cpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Vector2.hpp"
 
 #include <gdnative/vector2.h>
@@ -6,6 +36,15 @@
 
 namespace godot {
 
+const Vector2 Vector2::ZERO = Vector2();
+const Vector2 Vector2::ONE = Vector2(1, 1);
+const Vector2 Vector2::INF = Vector2(INFINITY, INFINITY);
+
+const Vector2 Vector2::LEFT = Vector2(-1, 0);
+const Vector2 Vector2::RIGHT = Vector2(1, 0);
+const Vector2 Vector2::UP = Vector2(0, -1);
+const Vector2 Vector2::DOWN = Vector2(0, 1);
+
 bool Vector2::operator==(const Vector2 &p_vec2) const {
 	return x == p_vec2.x && y == p_vec2.y;
 }

src/core/Vector3.cpp

@@ -1,3 +1,33 @@
+/*************************************************************************/
+/*  Vector3.cpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
 #include "Vector3.hpp"
 
 #include "String.hpp"
@@ -8,6 +38,17 @@
 
 namespace godot {
 
+const Vector3 Vector3::ZERO = Vector3();
+const Vector3 Vector3::ONE = Vector3(1, 1, 1);
+const Vector3 Vector3::INF = Vector3(INFINITY, INFINITY, INFINITY);
+
+const Vector3 Vector3::LEFT = Vector3(-1, 0, 0);
+const Vector3 Vector3::RIGHT = Vector3(1, 0, 0);
+const Vector3 Vector3::UP = Vector3(0, 1, 0);
+const Vector3 Vector3::DOWN = Vector3(0, -1, 0);
+const Vector3 Vector3::FORWARD = Vector3(0, 0, -1);
+const Vector3 Vector3::BACK = Vector3(0, 0, 1);
+
 bool Vector3::operator<(const Vector3 &p_v) const {
 	if (x == p_v.x) {
 		if (y == p_v.y)
@@ -67,17 +108,12 @@ void Vector3::rotate(const Vector3 &p_axis, real_t p_phi) {
 	*this = Basis(p_axis, p_phi).xform(*this);
 }
 
-// this is ugly as well, but hey, I'm a simple man
-#define _ugly_stepify(val, step) (step != 0 ? ::floor(val / step + 0.5) * step : val)
-
 void Vector3::snap(real_t p_val) {
-	x = _ugly_stepify(x, p_val);
-	y = _ugly_stepify(y, p_val);
-	z = _ugly_stepify(z, p_val);
+	x = Math::stepify(x, p_val);
+	y = Math::stepify(y, p_val);
+	z = Math::stepify(z, p_val);
 }
 
-#undef _ugly_stepify
-
 Vector3::operator String() const {
 	return String::num(x) + ", " + String::num(y) + ", " + String::num(z);
 }

test/.gitignore

@@ -0,0 +1,21 @@
+# Godot 4+ specific ignores
+.godot/
+
+# Godot-specific ignores
+.import/
+export.cfg
+export_presets.cfg
+# Dummy HTML5 export presets file for continuous integration
+!.github/dist/export_presets.cfg
+
+# Imported translations (automatically generated from CSV files)
+*.translation
+
+# Mono-specific ignores
+.mono/
+data_*/
+mono_crash.*.json
+
+# System/tool-specific ignores
+.directory
+*~

test/SConstruct

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+
+env = SConscript("../SConstruct")
+
+# 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')
+
+library = env.SharedLibrary(
+    "bin/libgdexample.{}.{}.{}{}".format(
+        env["platform"], env["target"], env["arch_suffix"], env["SHLIBSUFFIX"]
+    ),
+    source=sources,
+)
+
+Default(library)

test/gdexample.gdnlib

@@ -0,0 +1,20 @@
+[general]
+
+singleton=false
+load_once=true
+symbol_prefix="godot_"
+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"
+
+[dependencies]
+
+X11.64=[]
+Server.64=[]
+Windows.64=[]
+OSX.64=[]

test/gdexample.gdns

@@ -0,0 +1,9 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://gdexample.gdnlib" type="GDNativeLibrary" id=1]
+
+[resource]
+
+resource_name = "gdexample"
+class_name = "SimpleClass"
+library = ExtResource( 1 )

test/project.godot

@@ -0,0 +1,17 @@
+; Engine configuration file.
+; It's best edited using the editor UI and not directly,
+; since the parameters that go here are not all obvious.
+;
+; Format:
+;   [section] ; section goes between []
+;   param=value ; assign values to parameters
+
+config_version=4
+
+_global_script_classes=[  ]
+_global_script_class_icons={
+}
+
+[application]
+
+config/name="Test CI project"

test/script.gd

@@ -0,0 +1,30 @@
+extends MainLoop
+
+
+func _initialize():
+	OS.exit_code = 1
+	var native_script = load("res://gdexample.gdns")
+	print("Native Script ", native_script)
+	if not native_script || !is_instance_valid(native_script):
+		return
+	print("Library ", native_script.library)
+	if not native_script.library || !is_instance_valid(native_script.library):
+		return
+	var ref = native_script.new()
+	print("Reference ", ref)
+	if not ref || !is_instance_valid(ref):
+		return
+	print("Reference name ", ref.name)
+	if ref.name != "SimpleClass":
+		return
+	print("Reference value ", ref.value)
+	if ref.value != 0:
+		return
+	print("Call method ", ref.method(1))
+	if ref.method(1) != 1:
+		return
+	OS.exit_code = 0
+
+
+func _idle(_delta):
+	return true

test/src/init.cpp

@@ -0,0 +1,103 @@
+/*************************************************************************/
+/*  init.cpp                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include <Godot.hpp>
+#include <Reference.hpp>
+
+using namespace godot;
+
+class SimpleClass : public Reference {
+	GODOT_CLASS(SimpleClass, Reference);
+
+public:
+	SimpleClass() {}
+
+	/** `_init` must exist as it is called by Godot. */
+	void _init() {
+		_name = String("SimpleClass");
+		_value = 0;
+	}
+
+	void test_void_method() {
+		Godot::print("This is test");
+	}
+
+	Variant method(Variant arg) {
+		Variant ret;
+		ret = arg;
+
+		return ret;
+	}
+
+	static void _register_methods() {
+		register_method("method", &SimpleClass::method);
+
+		/**
+		 * The line below is equivalent to the following GDScript export:
+		 *	 export var _name = "SimpleClass"
+		 **/
+		register_property<SimpleClass, String>("name", &SimpleClass::_name, String("SimpleClass"));
+
+		/** Alternatively, with getter and setter methods: */
+		register_property<SimpleClass, int>("value", &SimpleClass::set_value, &SimpleClass::get_value, 0);
+
+		/** Registering a signal: **/
+		register_signal<SimpleClass>("signal_name0"); // windows: error C2668: 'godot::register_signal': ambiguous call to overloaded function
+		register_signal<SimpleClass>("signal_name1", "string_argument", GODOT_VARIANT_TYPE_STRING);
+	}
+
+	String _name;
+	int _value;
+
+	void set_value(int p_value) {
+		_value = p_value;
+	}
+
+	int get_value() const {
+		return _value;
+	}
+};
+
+/** GDNative Initialize **/
+extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
+	godot::Godot::gdnative_init(o);
+}
+
+/** GDNative Terminate **/
+extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
+	godot::Godot::gdnative_terminate(o);
+}
+
+/** NativeScript Initialize **/
+extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
+	godot::Godot::nativescript_init(handle);
+
+	godot::register_class<SimpleClass>();
+}