gdextension: Sync with upstream commit 399c9dc393f6f84c0b4e4d4117906c70c048ecf2 (4.1.2-stable)

Cherry-picks for the godot-cpp 4.1 branch - 3rd batch

.editorconfig

@@ -1,16 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 4
-indent_style = tab
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[{*.py,SConstruct}]
-indent_style = space
-
-[*.{yml,yaml}]
-indent_size = 2
-indent_style = space

.gitattributes

@@ -1,2 +1,6 @@
-# Normalize EOL for all files that Git considers text files
-* text=auto eol=lf
+*.c eol=lf
+*.cpp eol=lf
+*.gd eol=lf
+*.tscn eol=lf
+*.cfg eol=lf
+*.godot eol=lf

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

@@ -1,24 +0,0 @@
-name: Restore Godot build cache
-description: Restore Godot build cache.
-inputs:
-  cache-name:
-    description: The cache base name (job name by default).
-    default: ${{ github.job }}
-  scons-cache:
-    description: The SCons cache path.
-    default: ${{ github.workspace }}/.scons-cache/
-
-runs:
-  using: composite
-  steps:
-    - name: Restore SCons cache directory
-      uses: actions/cache/restore@v4
-      with:
-        path: ${{ inputs.scons-cache }}
-        key: ${{ inputs.cache-name }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}
-
-        restore-keys: |
-          ${{ inputs.cache-name }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}
-          ${{ inputs.cache-name }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}
-          ${{ inputs.cache-name }}-${{ env.GODOT_BASE_BRANCH }}-refs/heads/${{ env.GODOT_BASE_BRANCH }}
-          ${{ inputs.cache-name }}-${{ env.GODOT_BASE_BRANCH }}

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

@@ -1,18 +0,0 @@
-name: Save Godot build cache
-description: Save Godot build cache.
-inputs:
-  cache-name:
-    description: The cache base name (job name by default).
-    default: ${{ github.job }}
-  scons-cache:
-    description: The SCons cache path.
-    default: ${{ github.workspace }}/.scons-cache/
-
-runs:
-  using: composite
-  steps:
-    - name: Save SCons cache directory
-      uses: actions/cache/save@v4
-      with:
-        path: ${{ inputs.scons-cache }}
-        key: ${{ inputs.cache-name }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}

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

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

.github/actions/setup-godot-cpp/action.yml

@@ -1,62 +0,0 @@
-name: Setup godot-cpp
-description: Setup build dependencies for godot-cpp.
-
-inputs:
-  platform:
-    required: true
-    description: Target platform.
-  em-version:
-    default: 3.1.62
-    description: Emscripten version.
-  windows-compiler:
-    required: true
-    description: The compiler toolchain to use on Windows ('mingw' or 'msvc').
-    type: choice
-    options:
-      - mingw
-      - msvc
-    default: mingw
-  mingw-version:
-    default: 12.2.0
-    description: MinGW version.
-  ndk-version:
-    default: r23c
-    description: Android NDK version.
-  scons-version:
-    default: 4.4.0
-    description: SCons version.
-
-runs:
-  using: composite
-  steps:
-    - name: Setup Python (for SCons)
-      uses: actions/setup-python@v5
-      with:
-        python-version: 3.x
-
-    - name: Setup Android dependencies
-      if: inputs.platform == 'android'
-      uses: nttld/setup-ndk@v1
-      with:
-        ndk-version: ${{ inputs.ndk-version }}
-        link-to-sdk: true
-
-    - name: Setup Web dependencies
-      if: inputs.platform == 'web'
-      uses: mymindstorm/setup-emsdk@v14
-      with:
-        version: ${{ inputs.em-version }}
-        no-cache: true
-
-    - name: Setup MinGW for Windows/MinGW build
-      if: inputs.platform == 'windows' && inputs.windows-compiler == 'mingw'
-      uses: egor-tensin/setup-mingw@v2
-      with:
-        version: ${{ inputs.mingw-version }}
-
-    - name: Setup SCons
-      shell: bash
-      run: |
-        python -c "import sys; print(sys.version)"
-        python -m pip install scons==${{ inputs.scons-version }}
-        scons --version

.github/workflows/ci.yml

@@ -1,15 +1,12 @@
 name: Continuous integration
-on:
-  workflow_call:
+on: [push, pull_request]
 
 env:
   # Only used for the cache key. Increment version to force clean build.
   GODOT_BASE_BRANCH: master
-  # Used to select the version of Godot to run the tests with.
-  GODOT_TEST_VERSION: 4.2.2-stable
 
 concurrency:
-  group: ci-${{ github.actor }}-${{ github.head_ref || github.run_number }}-${{ github.ref }}
+  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}
   cancel-in-progress: true
 
 jobs:
@@ -55,7 +52,7 @@ jobs:
             cache-name: windows-x86_64-mingw
 
           - name: 🍎 macOS (universal)
-            os: macos-latest
+            os: macos-11
             platform: macos
             artifact-name: godot-cpp-macos-universal-release
             artifact-path: bin/libgodot-cpp.macos.template_release.universal.a
@@ -68,12 +65,12 @@ jobs:
             platform: android
             artifact-name: godot-cpp-android-arm64-release
             artifact-path: bin/libgodot-cpp.android.template_release.arm64.a
-            flags: arch=arm64
+            flags: ANDROID_NDK_ROOT=$ANDROID_NDK_LATEST_HOME arch=arm64
             run-tests: false
             cache-name: android-arm64
 
           - name: 🍏 iOS (arm64)
-            os: macos-latest
+            os: macos-11
             platform: ios
             artifact-name: godot-cpp-ios-arm64-release
             artifact-path: bin/libgodot-cpp.ios.template_release.arm64.a
@@ -81,17 +78,8 @@ jobs:
             run-tests: false
             cache-name: ios-arm64
 
-          - name: 🌐 Web (wasm32)
-            os: ubuntu-20.04
-            platform: web
-            artifact-name: godot-cpp-web-wasm32-release
-            artifact-path: bin/libgodot-cpp.web.template_release.wasm32.a
-            run-tests: false
-            cache-name: web-wasm32
-
     env:
       SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
-      EM_VERSION: 3.1.39
 
     steps:
       - name: Checkout
@@ -99,46 +87,53 @@ jobs:
         with:
           submodules: recursive
 
-      - name: Restore Godot build cache
-        uses: ./.github/actions/godot-cache-restore
+      - name: Setup Godot build cache
+        uses: ./.github/actions/godot-cache
         with:
           cache-name: ${{ matrix.cache-name }}
         continue-on-error: true
 
-      - name: Setup godot-cpp
-        uses: ./.github/actions/setup-godot-cpp
+      - name: Set up Python (for SCons)
+        uses: actions/setup-python@v4
         with:
-          platform: ${{ matrix.platform }}
-          windows-compiler: ${{ contains(matrix.flags, 'use_mingw=yes') && 'mingw' || 'msvc' }}
+          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==4.0.0
+
+      - name: Setup MinGW for Windows/MinGW build
+        if: ${{ matrix.platform == 'windows' && matrix.flags == 'use_mingw=yes' }}
+        uses: egor-tensin/setup-mingw@v2
 
       - name: Generate godot-cpp sources only
         run: |
-          scons platform=${{ matrix.platform }} verbose=yes build_library=no ${{ matrix.flags }}
+          scons platform=${{ matrix.platform }} build_library=no ${{ matrix.flags }}
           scons -c
 
       - name: Build godot-cpp (debug)
         run: |
-          scons platform=${{ matrix.platform }} verbose=yes target=template_debug ${{ matrix.flags }}
+          scons platform=${{ matrix.platform }} target=template_debug ${{ matrix.flags }}
 
       - name: Build test without rebuilding godot-cpp (debug)
         run: |
           cd test
-          scons platform=${{ matrix.platform }} verbose=yes target=template_debug ${{ matrix.flags }} build_library=no
+          scons platform=${{ matrix.platform }} target=template_debug ${{ matrix.flags }} build_library=no
 
       - name: Build test and godot-cpp (release)
         run: |
           cd test
-          scons platform=${{ matrix.platform }} verbose=yes target=template_release ${{ matrix.flags }}
-
-      - name: Save Godot build cache
-        uses: ./.github/actions/godot-cache-save
-        with:
-          cache-name: ${{ matrix.cache-name }}
-        continue-on-error: true
+          scons platform=${{ matrix.platform }} target=template_release ${{ matrix.flags }}
 
       - name: Download latest Godot artifacts
         uses: dsnopek/action-download-artifact@1322f74e2dac9feed2ee76a32d9ae1ca3b4cf4e9
-        if: matrix.run-tests && env.GODOT_TEST_VERSION == 'master'
+        if: ${{ matrix.run-tests }}
         with:
           repo: godotengine/godot
           branch: master
@@ -151,28 +146,15 @@ jobs:
           ensure_latest: true
           path: godot-artifacts
 
-      - name: Prepare Godot artifacts for testing
-        if: matrix.run-tests && env.GODOT_TEST_VERSION == 'master'
+      - name: Run tests
+        if: ${{ matrix.run-tests }}
         run: |
           chmod +x ./godot-artifacts/godot.linuxbsd.editor.x86_64.mono
-          echo "GODOT=$(pwd)/godot-artifacts/godot.linuxbsd.editor.x86_64.mono" >> $GITHUB_ENV
-
-      - name: Download requested Godot version for testing
-        if: matrix.run-tests && env.GODOT_TEST_VERSION != 'master'
-        run: |
-          wget "https://github.com/godotengine/godot-builds/releases/download/${GODOT_TEST_VERSION}/Godot_v${GODOT_TEST_VERSION}_linux.x86_64.zip" -O Godot.zip
-          unzip -a Godot.zip
-          chmod +x "Godot_v${GODOT_TEST_VERSION}_linux.x86_64"
-          echo "GODOT=$(pwd)/Godot_v${GODOT_TEST_VERSION}_linux.x86_64" >> $GITHUB_ENV
-
-      - name: Run tests
-        if: matrix.run-tests
-        run: |
-          $GODOT --headless --version
+          ./godot-artifacts/godot.linuxbsd.editor.x86_64.mono --headless --version
           cd test
           # Need to run the editor so .godot is generated... but it crashes! Ignore that :-)
-          (cd project && (timeout 30 $GODOT --editor --headless --quit >/dev/null 2>&1 || true))
-          ./run-tests.sh
+          (cd project && (../../godot-artifacts/godot.linuxbsd.editor.x86_64.mono --editor --headless --quit >/dev/null 2>&1 || true))
+          GODOT=../godot-artifacts/godot.linuxbsd.editor.x86_64.mono ./run-tests.sh
 
       - name: Upload artifact
         uses: actions/upload-artifact@v3
@@ -241,9 +223,9 @@ jobs:
       - name: Build godot-cpp
         run: |
           cmake -DCMAKE_BUILD_TYPE=Release -G"Visual Studio 16 2019" .
-          cmake --build . --verbose --config Release
+          cmake --build . --verbose
 
       - name: Build test GDExtension library
         run: |
           cd test && cmake -DCMAKE_BUILD_TYPE=Release -DGODOT_HEADERS_PATH="../godot-headers" -DCPP_BINDINGS_PATH=".." -G"Visual Studio 16 2019" .
-          cmake --build . --verbose --config Release
+          cmake --build . --verbose

.github/workflows/runner.yml

@@ -1,21 +0,0 @@
-name: 🔗 GHA
-on: [push, pull_request, merge_group]
-
-concurrency:
-  group: ci-${{ github.actor }}-${{ github.head_ref || github.run_number }}-${{ github.ref }}-runner
-  cancel-in-progress: true
-
-jobs:
-  # First stage: Only static checks, fast and prevent expensive builds from running.
-
-  static-checks:
-    if: '!vars.DISABLE_GODOT_CI'
-    name: 📊 Static Checks
-    uses: ./.github/workflows/static_checks.yml
-
-  # Second stage: Run all the builds and some of the tests.
-
-  ci:
-    name: 🛠️ Continuous Integration
-    needs: static-checks
-    uses: ./.github/workflows/ci.yml

.github/workflows/static_checks.yml

@@ -1,38 +1,54 @@
 name: 📊 Static Checks
-on:
-  workflow_call:
+on: [push, pull_request]
 
 concurrency:
-  group: ci-${{ github.actor }}-${{ github.head_ref || github.run_number }}-${{ github.ref }}-static
+  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-static
   cancel-in-progress: true
 
 jobs:
   static-checks:
-    name: Format (clang-format, ruff format, file format)
-    runs-on: ubuntu-22.04
+    name: Format (clang-format, black format, file format)
+    runs-on: ubuntu-20.04
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
 
-      - name: Get changed files
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      # Azure repositories are not reliable, we need to prevent Azure giving us packages.
+      - name: Make apt sources.list use the default Ubuntu repositories
         run: |
-          if [ "${{ github.event_name }}" == "pull_request" ]; then
-            files=$(git diff-tree --no-commit-id --name-only -r HEAD^1..HEAD 2> /dev/null || true)
-          elif [ "${{ github.event_name }}" == "push" -a "${{ github.event.forced }}" == "false" -a "${{ github.event.created }}" == "false" ]; then
-            files=$(git diff-tree --no-commit-id --name-only -r ${{ github.event.before }}..${{ github.event.after }} 2> /dev/null || true)
-          fi
-          files=$(echo "$files" | grep -v 'thirdparty' | xargs -I {} sh -c 'echo "\"./{}\""' | tr '\n' ' ')
-          echo "CHANGED_FILES=$files" >> $GITHUB_ENV
+          sudo rm -f /etc/apt/sources.list.d/*
+          sudo cp -f misc/ci/sources.list /etc/apt/sources.list
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+          sudo apt-add-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-15 main"
+          sudo apt-get update
 
-      - name: Style checks via pre-commit
-        uses: pre-commit/action@v3.0.1
-        with:
-          extra_args: --verbose --hook-stage manual --files ${{ env.CHANGED_FILES }}
+      - name: Install dependencies
+        run: |
+          sudo apt-get install -qq dos2unix recode clang-format-15 libxml2-utils python3-pip moreutils
+          sudo update-alternatives --remove-all clang-format || true
+          sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-15 100
+          sudo pip3 install black==22.3.0 pygments pytest==7.1.2 mypy==0.971
 
-      - name: Check generated files consistency
-        run:
-          python misc/scripts/check_get_file_list.py
+      - name: File formatting checks (file_format.sh)
+        run: |
+          bash ./misc/scripts/file_format.sh
+
+      - name: Header guards formatting checks (header_guards.sh)
+        run: |
+          bash ./misc/scripts/header_guards.sh
+
+      - name: Python style checks via black (black_format.sh)
+        run: |
+          bash ./misc/scripts/black_format.sh
+
+      - name: Python scripts static analysis (mypy_check.sh)
+        run: |
+          bash ./misc/scripts/mypy_check.sh
+
+      - name: Bindings generation checks (ensures get_file_list returns all generated files)
+        run: |
+          python ./misc/scripts/check_get_file_list.py
+
+      - name: Style checks via clang-format (clang_format.sh)
+        run: |
+          bash ./misc/scripts/clang_format.sh

.gitignore

@@ -8,7 +8,7 @@
 include/gen
 src/gen
 
-# Build configuration.
+# Build configuarion.
 /custom.py
 
 # Misc
@@ -191,11 +191,3 @@ godot.creator.*
 
 # compile commands (https://clang.llvm.org/docs/JSONCompilationDatabase.html)
 compile_commands.json
-
-# Python development
-.venv
-venv
-
-# Clion Configuration
-.idea/
-cmake-build-*

.pre-commit-config.yaml

@@ -1,64 +0,0 @@
-default_language_version:
-  python: python3
-
-exclude: |
-  (?x)^(
-    gdextension/extension_api\.json|
-    gdextension/gdextension_interface\.h
-  )$
-
-repos:
-  - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v17.0.6
-    hooks:
-      - id: clang-format
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.4
-    hooks:
-      - id: ruff
-        args: [--fix]
-      - id: ruff-format
-
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.971
-    hooks:
-      - id: mypy
-        files: \.py$
-        types_or: [text]
-
-  - repo: https://github.com/codespell-project/codespell
-    rev: v2.3.0
-    hooks:
-      - id: codespell
-        additional_dependencies: [tomli]
-
-  - repo: local
-    hooks:
-      - id: copyright-headers
-        name: copyright-headers
-        language: python
-        entry: python misc/scripts/copyright_headers.py
-        files: \.(c|h)pp$
-        exclude: ^test/
-
-      - id: header-guards
-        name: header-guards
-        language: python
-        entry: python misc/scripts/header_guards.py
-        files: \.hpp$
-        exclude: ^test/
-
-      - id: file-format
-        name: file-format
-        language: python
-        entry: python misc/scripts/file_format.py
-        types_or: [text]
-
-      - id: check-get-file-list
-        name: check-get-file-list
-        language: python
-        entry: python misc/scripts/check_get_file_list.py
-        pass_filenames: false
-        always_run: true
-        stages: [manual]

CMakeLists.txt

@@ -1,24 +1,212 @@
-cmake_minimum_required(VERSION 3.13)
+# cmake arguments
+# CMAKE_BUILD_TYPE:			Compilation target (Debug or Release defaults to Debug)
+#
+# godot-cpp cmake arguments
+# GODOT_GDEXTENSION_DIR:		Path to the directory containing GDExtension interface header and API JSON file
+# GODOT_CPP_SYSTEM_HEADERS		Mark the header files as SYSTEM. This may be useful to supress warnings in projects including this one.
+# GODOT_CPP_WARNING_AS_ERROR	Treat any warnings as errors
+# GODOT_CUSTOM_API_FILE:		Path to a custom GDExtension API JSON file (takes precedence over `gdextension_dir`)
+# FLOAT_PRECISION:				Floating-point precision level ("single", "double")
+#
+# 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.
+
+cmake_minimum_required(VERSION 3.12)
 project(godot-cpp LANGUAGES CXX)
 
-# Configure CMake
-# https://discourse.cmake.org/t/how-do-i-remove-compile-options-from-target/5965
-# https://stackoverflow.com/questions/74426638/how-to-remove-rtc1-from-specific-target-or-file-in-cmake
-if(${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC)
-    if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
-        STRING(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        string(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
-    endif ()
+option(GENERATE_TEMPLATE_GET_NODE "Generate a template version of the Node class's get_node." ON)
+option(GODOT_CPP_SYSTEM_HEADERS "Expose headers as SYSTEM." ON)
+option(GODOT_CPP_WARNING_AS_ERROR "Treat warnings as errors" OFF)
+
+# Add path to modules
+list( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/" )
+
+# Check if we are building ourself or being included
+if(${PROJECT_NAME} STREQUAL ${CMAKE_PROJECT_NAME})
+    set(GODOT_CPP_BUILDING_SELF ON)
+endif()
+
+# Set some helper variables for readability
+set( compiler_is_clang "$<OR:$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:Clang>>" )
+set( compiler_is_gnu "$<CXX_COMPILER_ID:GNU>" )
+set( compiler_is_msvc "$<CXX_COMPILER_ID:MSVC>" )
+
+# Default build type is Debug in the SConstruct
+if("${CMAKE_BUILD_TYPE}" STREQUAL "")
+	set(CMAKE_BUILD_TYPE Debug)
+endif()
+
+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 GDExtension interface header and the API JSON file
+set(GODOT_GDEXTENSION_DIR "gdextension" CACHE STRING "")
+set(GODOT_CUSTOM_API_FILE "" CACHE STRING "")
+set(FLOAT_PRECISION "single" CACHE STRING "")
+if ("${FLOAT_PRECISION}" STREQUAL "double")
+	add_definitions(-DREAL_T_IS_DOUBLE)
+endif()
+
+set(GODOT_GDEXTENSION_API_FILE "${GODOT_GDEXTENSION_DIR}/extension_api.json")
+if (NOT "${GODOT_CUSTOM_API_FILE}" STREQUAL "")  # User-defined override.
+	set(GODOT_GDEXTENSION_API_FILE "${GODOT_CUSTOM_API_FILE}")
+endif()
+
+set(GODOT_COMPILE_FLAGS )
+
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+	# using Visual Studio C++
+	set(GODOT_COMPILE_FLAGS "/EHsc /utf-8") # /GF /MP
+
+	if(CMAKE_BUILD_TYPE MATCHES Debug)
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /MDd") # /Od /RTC1 /Zi
+	else()
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /MD /O2") # /Oy /GL /Gy
+		STRING(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+		string(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
+	endif(CMAKE_BUILD_TYPE MATCHES Debug)
+
+	add_definitions(-DNOMINMAX)
+else()  # GCC/Clang
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -g")
+
+	if(CMAKE_BUILD_TYPE MATCHES Debug)
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -fno-omit-frame-pointer -O0")
+	else()
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -O3")
+	endif(CMAKE_BUILD_TYPE MATCHES Debug)
+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()
+
+execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "import binding_generator; binding_generator.print_file_list(\"${GODOT_GDEXTENSION_API_FILE}\", \"${CMAKE_CURRENT_BINARY_DIR}\", headers=True, sources=True)"
+	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+	OUTPUT_VARIABLE GENERATED_FILES_LIST
+)
+
+add_custom_command(OUTPUT ${GENERATED_FILES_LIST}
+		COMMAND "${Python3_EXECUTABLE}" "-c" "import binding_generator; binding_generator.generate_bindings(\"${GODOT_GDEXTENSION_API_FILE}\", \"${GENERATE_BINDING_PARAMETERS}\", \"${BITS}\", \"${FLOAT_PRECISION}\", \"${CMAKE_CURRENT_BINARY_DIR}\")"
+		VERBATIM
+		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+		MAIN_DEPENDENCY ${GODOT_GDEXTENSION_API_FILE}
+		DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/binding_generator.py
+		COMMENT "Generating bindings"
+)
+
+# Get Sources
+file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS src/*.c**)
+file(GLOB_RECURSE HEADERS CONFIGURE_DEPENDS include/*.h**)
+
+# Define our godot-cpp library
+add_library(${PROJECT_NAME} STATIC
+		${SOURCES}
+		${HEADERS}
+		${GENERATED_FILES_LIST}
+)
+add_library(godot::cpp ALIAS ${PROJECT_NAME})
+
+include(GodotCompilerWarnings)
+
+# Treat warnings as errors if we are building ourself
+if(GODOT_CPP_BUILDING_SELF)
+    unset( GODOT_CPP_WARNING_AS_ERROR CACHE )
+    set_warning_as_error()
+endif()
+
+target_compile_features(${PROJECT_NAME}
+	PRIVATE
+		cxx_std_17
+)
+
+target_compile_definitions(${PROJECT_NAME} PUBLIC
+	$<$<CONFIG:Debug>:
+		DEBUG_ENABLED
+		DEBUG_METHODS_ENABLED
+	>
+	$<${compiler_is_msvc}:
+		TYPED_METHOD_BIND
+	>
+)
+
+target_link_options(${PROJECT_NAME} PRIVATE
+	$<$<NOT:${compiler_is_msvc}>:
+		-static-libgcc
+		-static-libstdc++
+		-Wl,-R,'$$ORIGIN'
+	>
+)
+
+# Optionally mark headers as SYSTEM
+set(GODOT_CPP_SYSTEM_HEADERS_ATTRIBUTE "")
+if (GODOT_CPP_SYSTEM_HEADERS)
+	set(GODOT_CPP_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
 endif ()
 
-include( ${PROJECT_SOURCE_DIR}/cmake/godotcpp.cmake )
+target_include_directories(${PROJECT_NAME} ${GODOT_CPP_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
+	include
+	${CMAKE_CURRENT_BINARY_DIR}/gen/include
+	${GODOT_GDEXTENSION_DIR}
+)
 
-# I know this doesn't look like a typical CMakeLists.txt, but as we are
-# attempting mostly feature parity with SCons, and easy maintenance, the closer
-# the two build systems look the easier they will be to keep in lockstep.
+# Add the compile flags
+set_property(TARGET ${PROJECT_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS ${GODOT_COMPILE_FLAGS})
 
-# The typical target definitions are in ${PROJECT_SOURCE_DIR}/cmake/godotcpp.cmake
+# Create the correct name (godot.os.build_type.system_bits)
+string(TOLOWER "${CMAKE_SYSTEM_NAME}" SYSTEM_NAME)
+string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE)
 
-godotcpp_options()
+if(ANDROID)
+	# Added the android abi after system name
+	set(SYSTEM_NAME ${SYSTEM_NAME}.${ANDROID_ABI})
 
-godotcpp_generate()
+	# Android does not have the bits at the end if you look at the main godot repo build
+	set(OUTPUT_NAME "godot-cpp.${SYSTEM_NAME}.${BUILD_TYPE}")
+else()
+	set(OUTPUT_NAME "godot-cpp.${SYSTEM_NAME}.${BUILD_TYPE}.${BITS}")
+endif()
+
+set_target_properties(${PROJECT_NAME}
+	PROPERTIES
+		CXX_EXTENSIONS OFF
+		POSITION_INDEPENDENT_CODE ON
+		ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
+		LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
+		RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
+		OUTPUT_NAME "${OUTPUT_NAME}"
+)

README.md

@@ -7,9 +7,8 @@
 > from Godot's `master` branch.
 >
 > For users of stable branches, switch to the branch matching your target Godot version:
-> - [`4.2`](https://github.com/godotengine/godot-cpp/tree/4.2)
-> - [`4.1`](https://github.com/godotengine/godot-cpp/tree/4.1)
 > - [`4.0`](https://github.com/godotengine/godot-cpp/tree/4.0)
+> - [`4.1`](https://github.com/godotengine/godot-cpp/tree/4.1)
 >
 > Or check out the Git tag matching your Godot version (e.g. `godot-4.1.1-stable`).
 >
@@ -58,7 +57,7 @@ first-party `godot-cpp` extension.
 Some compatibility breakage is to be expected as GDExtension and `godot-cpp`
 get more used, documented, and critical issues get resolved. See the
 [Godot issue tracker](https://github.com/godotengine/godot/issues?q=is%3Aissue+is%3Aopen+label%3Atopic%3Agdextension)
-and the [godot-cpp issue tracker](https://github.com/godotengine/godot-cpp/issues)
+and the [godot-cpp issue tracker](https://github.com/godotengine/godot/issues)
 for a list of known issues, and be sure to provide feedback on issues and PRs
 which affect your use of this extension.
 
@@ -69,14 +68,12 @@ wish to help out, ensure you have an account on GitHub and create a "fork" of
 this repository. See [Pull request workflow](https://docs.godotengine.org/en/stable/community/contributing/pr_workflow.html)
 for instructions.
 
-Please install clang-format and the [pre-commit](https://pre-commit.com/) Python framework so formatting is done before your changes are submitted. See the [code style guidelines](https://docs.godotengine.org/en/latest/contributing/development/code_style_guidelines.html#pre-commit-hook) for instructions.
+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
 
-You need the same C++ pre-requisites installed that are required for the `godot` repository. Follow the [official build instructions for your target platform](https://docs.godotengine.org/en/latest/contributing/development/compiling/index.html#building-for-target-platforms).
-
-Getting started with GDExtensions is a bit similar to what it was for 3.x but also a bit different.
-
+It's a bit similar to what it was for 3.x but also a bit different.
 This new approach is much more akin to how core Godot modules are structured.
 
 Compiling this repository generates a static library to be linked with your shared lib,
@@ -131,7 +128,7 @@ void initialize_example_module(ModuleInitializationLevel p_level) {
 	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
 		return;
 	}
-	GDREGISTER_CLASS(Example);
+	ClassDB::register_class<Example>();
 }
 ```
 

SConstruct

@@ -1,13 +1,18 @@
 #!/usr/bin/env python
 
 import os
+import platform
+import sys
+import subprocess
+from binding_generator import scons_generate_bindings, scons_emit_files
+
 
 EnsureSConsVersion(4, 0)
 
 
 try:
     Import("env")
-except Exception:
+except:
     # Default tools with no platform defaults to gnu toolchain.
     # We apply platform specific toolchains via our custom tools.
     env = Environment(tools=["default"], PLATFORM="")
@@ -16,10 +21,6 @@ env.PrependENVPath("PATH", os.getenv("PATH"))
 
 # Custom options and profile flags.
 customs = ["custom.py"]
-try:
-    customs += Import("customs")
-except Exception:
-    pass
 profile = ARGUMENTS.get("profile", "")
 if profile:
     if os.path.isfile(profile):

build_profile.py

@@ -1,183 +0,0 @@
-import json
-import sys
-
-
-def parse_build_profile(profile_filepath, api):
-    if profile_filepath == "":
-        return {}
-
-    with open(profile_filepath, encoding="utf-8") as profile_file:
-        profile = json.load(profile_file)
-
-    api_dict = {}
-    parents = {}
-    children = {}
-    for engine_class in api["classes"]:
-        api_dict[engine_class["name"]] = engine_class
-        parent = engine_class.get("inherits", "")
-        child = engine_class["name"]
-        parents[child] = parent
-        if parent == "":
-            continue
-        children[parent] = children.get(parent, [])
-        children[parent].append(child)
-
-    included = []
-    front = list(profile.get("enabled_classes", []))
-    if front:
-        # These must always be included
-        front.append("WorkerThreadPool")
-        front.append("ClassDB")
-        front.append("ClassDBSingleton")
-        # In src/classes/low_level.cpp
-        front.append("FileAccess")
-        front.append("Image")
-        front.append("XMLParser")
-        # In include/godot_cpp/templates/thread_work_pool.hpp
-        front.append("Semaphore")
-    while front:
-        cls = front.pop()
-        if cls in included:
-            continue
-        included.append(cls)
-        parent = parents.get(cls, "")
-        if parent:
-            front.append(parent)
-
-    excluded = []
-    front = list(profile.get("disabled_classes", []))
-    while front:
-        cls = front.pop()
-        if cls in excluded:
-            continue
-        excluded.append(cls)
-        front += children.get(cls, [])
-
-    if included and excluded:
-        print(
-            "WARNING: Cannot specify both 'enabled_classes' and 'disabled_classes' in build profile. 'disabled_classes' will be ignored."
-        )
-
-    return {
-        "enabled_classes": included,
-        "disabled_classes": excluded,
-    }
-
-
-def generate_trimmed_api(source_api_filepath, profile_filepath):
-    with open(source_api_filepath, encoding="utf-8") as api_file:
-        api = json.load(api_file)
-
-    if profile_filepath == "":
-        return api
-
-    build_profile = parse_build_profile(profile_filepath, api)
-
-    engine_classes = {}
-    for class_api in api["classes"]:
-        engine_classes[class_api["name"]] = class_api["is_refcounted"]
-    for native_struct in api["native_structures"]:
-        if native_struct["name"] == "ObjectID":
-            continue
-        engine_classes[native_struct["name"]] = False
-
-    classes = []
-    for class_api in api["classes"]:
-        if not is_class_included(class_api["name"], build_profile):
-            continue
-        if "methods" in class_api:
-            methods = []
-            for method in class_api["methods"]:
-                if not is_method_included(method, build_profile, engine_classes):
-                    continue
-                methods.append(method)
-            class_api["methods"] = methods
-        classes.append(class_api)
-    api["classes"] = classes
-
-    return api
-
-
-def is_class_included(class_name, build_profile):
-    """
-    Check if an engine class should be included.
-    This removes classes according to a build profile of enabled or disabled classes.
-    """
-    included = build_profile.get("enabled_classes", [])
-    excluded = build_profile.get("disabled_classes", [])
-    if included:
-        return class_name in included
-    if excluded:
-        return class_name not in excluded
-    return True
-
-
-def is_method_included(method, build_profile, engine_classes):
-    """
-    Check if an engine class method should be included.
-    This removes methods according to a build profile of enabled or disabled classes.
-    """
-    included = build_profile.get("enabled_classes", [])
-    excluded = build_profile.get("disabled_classes", [])
-    ref_cls = set()
-    rtype = get_base_type(method.get("return_value", {}).get("type", ""))
-    args = [get_base_type(a["type"]) for a in method.get("arguments", [])]
-    if rtype in engine_classes:
-        ref_cls.add(rtype)
-    elif is_enum(rtype) and get_enum_class(rtype) in engine_classes:
-        ref_cls.add(get_enum_class(rtype))
-    for arg in args:
-        if arg in engine_classes:
-            ref_cls.add(arg)
-        elif is_enum(arg) and get_enum_class(arg) in engine_classes:
-            ref_cls.add(get_enum_class(arg))
-    for acls in ref_cls:
-        if len(included) > 0 and acls not in included:
-            return False
-        elif len(excluded) > 0 and acls in excluded:
-            return False
-    return True
-
-
-def is_enum(type_name):
-    return type_name.startswith("enum::") or type_name.startswith("bitfield::")
-
-
-def get_enum_class(enum_name: str):
-    if "." in enum_name:
-        if is_bitfield(enum_name):
-            return enum_name.replace("bitfield::", "").split(".")[0]
-        else:
-            return enum_name.replace("enum::", "").split(".")[0]
-    else:
-        return "GlobalConstants"
-
-
-def get_base_type(type_name):
-    if type_name.startswith("const "):
-        type_name = type_name[6:]
-    if type_name.endswith("*"):
-        type_name = type_name[:-1]
-    if type_name.startswith("typedarray::"):
-        type_name = type_name.replace("typedarray::", "")
-    return type_name
-
-
-def is_bitfield(type_name):
-    return type_name.startswith("bitfield::")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 3 or len(sys.argv) > 4:
-        print("Usage: %s BUILD_PROFILE INPUT_JSON [OUTPUT_JSON]" % (sys.argv[0]))
-        sys.exit(1)
-    profile = sys.argv[1]
-    infile = sys.argv[2]
-    outfile = sys.argv[3] if len(sys.argv) > 3 else ""
-    api = generate_trimmed_api(infile, profile)
-
-    if outfile:
-        with open(outfile, "w", encoding="utf-8") as f:
-            json.dump(api, f)
-    else:
-        json.dump(api, sys.stdout)

cmake/GodotCompilerWarnings.cmake

@@ -89,6 +89,6 @@ function( set_warning_as_error )
     endif()
 endfunction()
 
-if ( GODOT_WARNING_AS_ERROR )
+if ( GODOT_CPP_WARNING_AS_ERROR )
     set_warning_as_error()
 endif()

cmake/godotcpp.cmake

@@ -1,240 +0,0 @@
-function( godotcpp_options )
-
-    #TODO platform
-    #TODO target
-
-    # Input from user for GDExtension interface header and the API JSON file
-    set(GODOT_GDEXTENSION_DIR "gdextension" CACHE PATH
-            "Path to a custom directory containing GDExtension interface header and API JSON file ( /path/to/gdextension_dir )" )
-    set(GODOT_CUSTOM_API_FILE "" CACHE FILEPATH
-            "Path to a custom GDExtension API JSON file (takes precedence over `gdextension_dir`) ( /path/to/custom_api_file )")
-
-    #TODO generate_bindings
-
-    option(GODOT_GENERATE_TEMPLATE_GET_NODE
-            "Generate a template version of the Node class's get_node. (ON|OFF)" ON)
-
-    #TODO build_library
-
-    set(GODOT_PRECISION "single" CACHE STRING
-            "Set the floating-point precision level (single|double)")
-
-    #TODO arch
-    #TODO threads
-    #TODO compiledb
-    #TODO compiledb_file
-    #TODO build_profile aka cmake preset
-
-    set(GODOT_USE_HOT_RELOAD "" CACHE BOOL
-            "Enable the extra accounting required to support hot reload. (ON|OFF)")
-
-    option(GODOT_DISABLE_EXCEPTIONS "Force disabling exception handling code (ON|OFF)" ON )
-
-    set( GODOT_SYMBOL_VISIBILITY "hidden" CACHE STRING
-            "Symbols visibility on GNU platforms. Use 'auto' to apply the default value. (auto|visible|hidden)")
-    set_property( CACHE GODOT_SYMBOL_VISIBILITY PROPERTY STRINGS "auto;visible;hidden" )
-
-    #TODO optimize
-    #TODO debug_symbols
-    #TODO dev_build
-
-    # FIXME These options are not present in SCons, and perhaps should be added there.
-    option(GODOT_SYSTEM_HEADERS "Expose headers as SYSTEM." ON)
-    option(GODOT_WARNING_AS_ERROR "Treat warnings as errors" OFF)
-
-    # Run options commands on the following to populate cache for all platforms.
-    # This type of thing is typically done conditionally
-    # But as scons shows all options so shall we.
-    #TODO ios_options()
-    #TODO linux_options()
-    #TODO macos_options()
-    #TODO web_options()
-    #TODO windows_options()
-endfunction()
-
-
-function( godotcpp_generate )
-    # Set some helper variables for readability
-    set( compiler_is_clang "$<OR:$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:Clang>>" )
-    set( compiler_is_gnu "$<CXX_COMPILER_ID:GNU>" )
-    set( compiler_is_msvc "$<CXX_COMPILER_ID:MSVC>" )
-
-    # CXX_VISIBILITY_PRESET supported values are: default, hidden, protected, and internal
-    # which is inline with the gcc -fvisibility=
-    # https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html
-    # To match the scons options we need to change the text to match the -fvisibility flag
-    # it is probably worth another PR which changes both to use the flag options
-    if( ${GODOT_SYMBOL_VISIBILITY} STREQUAL "auto" OR ${GODOT_SYMBOL_VISIBILITY} STREQUAL "visible" )
-        set( GODOT_SYMBOL_VISIBILITY "default" )
-    endif ()
-
-    # Default build type is Debug in the SConstruct
-    if("${CMAKE_BUILD_TYPE}" STREQUAL "")
-        set(CMAKE_BUILD_TYPE Debug)
-    endif()
-
-    # Hot reload is enabled by default in Debug-builds
-    if( GODOT_USE_HOT_RELOAD STREQUAL "" AND NOT CMAKE_BUILD_TYPE STREQUAL "Release")
-        set(GODOT_USE_HOT_RELOAD ON)
-    endif()
-
-    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()
-
-
-    set(GODOT_GDEXTENSION_API_FILE "${GODOT_GDEXTENSION_DIR}/extension_api.json")
-    if (NOT "${GODOT_CUSTOM_API_FILE}" STREQUAL "")  # User-defined override.
-        set(GODOT_GDEXTENSION_API_FILE "${GODOT_CUSTOM_API_FILE}")
-    endif()
-
-    if ("${GODOT_PRECISION}" STREQUAL "double")
-        add_definitions(-DREAL_T_IS_DOUBLE)
-    endif()
-
-    set( GODOT_COMPILE_FLAGS )
-
-    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        # using Visual Studio C++
-        set(GODOT_COMPILE_FLAGS "/utf-8") # /GF /MP
-
-        if(CMAKE_BUILD_TYPE MATCHES Debug)
-            set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /MDd") # /Od /RTC1 /Zi
-        else()
-            set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /MD /O2") # /Oy /GL /Gy
-        endif(CMAKE_BUILD_TYPE MATCHES Debug)
-
-        add_definitions(-DNOMINMAX)
-    else()  # GCC/Clang
-        if(CMAKE_BUILD_TYPE MATCHES Debug)
-            set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -fno-omit-frame-pointer -O0 -g")
-        else()
-            set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -O3")
-        endif(CMAKE_BUILD_TYPE MATCHES Debug)
-    endif()
-
-    # Disable exception handling. Godot doesn't use exceptions anywhere, and this
-    # saves around 20% of binary size and very significant build time (GH-80513).
-    if (GODOT_DISABLE_EXCEPTIONS)
-        if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-            set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -D_HAS_EXCEPTIONS=0")
-        else()
-            set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -fno-exceptions")
-        endif()
-    else()
-        if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-            set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /EHsc")
-        endif()
-    endif()
-
-    # Generate source from the bindings file
-    find_package(Python3 3.4 REQUIRED) # pathlib should be present
-    if(GODOT_GENERATE_TEMPLATE_GET_NODE)
-        set(GENERATE_BINDING_PARAMETERS "True")
-    else()
-        set(GENERATE_BINDING_PARAMETERS "False")
-    endif()
-
-    execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "import binding_generator; binding_generator.print_file_list(\"${GODOT_GDEXTENSION_API_FILE}\", \"${CMAKE_CURRENT_BINARY_DIR}\", headers=True, sources=True)"
-            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-            OUTPUT_VARIABLE GENERATED_FILES_LIST
-            OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-
-    add_custom_command(OUTPUT ${GENERATED_FILES_LIST}
-            COMMAND "${Python3_EXECUTABLE}" "-c" "import binding_generator; binding_generator.generate_bindings(\"${GODOT_GDEXTENSION_API_FILE}\", \"${GENERATE_BINDING_PARAMETERS}\", \"${BITS}\", \"${GODOT_PRECISION}\", \"${CMAKE_CURRENT_BINARY_DIR}\")"
-            VERBATIM
-            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-            MAIN_DEPENDENCY ${GODOT_GDEXTENSION_API_FILE}
-            DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/binding_generator.py
-            COMMENT "Generating bindings"
-    )
-
-    # Get Sources
-    # As this cmake file was added using 'include(godotcpp)' from the root CMakeLists.txt,
-    # the ${CMAKE_CURRENT_SOURCE_DIR} is still the root dir.
-    file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS src/*.c**)
-    file(GLOB_RECURSE HEADERS CONFIGURE_DEPENDS include/*.h**)
-
-    # Define our godot-cpp library
-    add_library(${PROJECT_NAME} STATIC
-            ${SOURCES}
-            ${HEADERS}
-            ${GENERATED_FILES_LIST}
-    )
-    add_library(godot::cpp ALIAS ${PROJECT_NAME})
-
-    include(${PROJECT_SOURCE_DIR}/cmake/common_compiler_flags.cmake)
-
-    target_compile_features(${PROJECT_NAME}
-            PRIVATE
-            cxx_std_17
-    )
-
-    if(GODOT_USE_HOT_RELOAD)
-        target_compile_definitions(${PROJECT_NAME} PUBLIC HOT_RELOAD_ENABLED)
-        target_compile_options(${PROJECT_NAME} PUBLIC $<${compiler_is_gnu}:-fno-gnu-unique>)
-    endif()
-
-    target_compile_definitions(${PROJECT_NAME} PUBLIC
-            $<$<CONFIG:Debug>:
-            DEBUG_ENABLED
-            DEBUG_METHODS_ENABLED
-            >
-            $<${compiler_is_msvc}:
-            TYPED_METHOD_BIND
-            >
-    )
-
-    target_link_options(${PROJECT_NAME} PRIVATE
-            $<$<NOT:${compiler_is_msvc}>:
-            -static-libgcc
-            -static-libstdc++
-            -Wl,-R,'$$ORIGIN'
-            >
-    )
-
-    # Optionally mark headers as SYSTEM
-    set(GODOT_SYSTEM_HEADERS_ATTRIBUTE "")
-    if (GODOT_SYSTEM_HEADERS)
-        set(GODOT_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
-    endif ()
-
-    target_include_directories(${PROJECT_NAME} ${GODOT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
-            include
-            ${CMAKE_CURRENT_BINARY_DIR}/gen/include
-            ${GODOT_GDEXTENSION_DIR}
-    )
-
-    # Add the compile flags
-    set_property(TARGET ${PROJECT_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS ${GODOT_COMPILE_FLAGS})
-
-    # Create the correct name (godot.os.build_type.system_bits)
-    string(TOLOWER "${CMAKE_SYSTEM_NAME}" SYSTEM_NAME)
-    string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE)
-
-    if(ANDROID)
-        # Added the android abi after system name
-        set(SYSTEM_NAME ${SYSTEM_NAME}.${ANDROID_ABI})
-
-        # Android does not have the bits at the end if you look at the main godot repo build
-        set(OUTPUT_NAME "godot-cpp.${SYSTEM_NAME}.${BUILD_TYPE}")
-    else()
-        set(OUTPUT_NAME "godot-cpp.${SYSTEM_NAME}.${BUILD_TYPE}.${BITS}")
-    endif()
-
-    set_target_properties(${PROJECT_NAME}
-            PROPERTIES
-            CXX_EXTENSIONS OFF
-            POSITION_INDEPENDENT_CODE ON
-            CXX_VISIBILITY_PRESET ${GODOT_SYMBOL_VISIBILITY}
-            ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
-            LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
-            RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
-            OUTPUT_NAME "${OUTPUT_NAME}"
-    )
-
-endfunction()

doc/cmake.md

@@ -1,57 +0,0 @@
-## CMake
-
-### cmake arguments
-
-`CMAKE_BUILD_TYPE`:         Compilation target (Debug or Release defaults to Debug)
-
-### godot-cpp cmake arguments
-- `GODOT_GDEXTENSION_DIR`:    Path to the directory containing GDExtension interface header and API JSON file
-- `GODOT_SYSTEM_HEADERS`:     Mark the header files as SYSTEM. This may be useful to suppress warnings in projects including this one.
-- `GODOT_WARNING_AS_ERROR`:   Treat any warnings as errors
-- `GODOT_USE_HOT_RELOAD`:     Build with hot reload support. Defaults to YES for Debug-builds and NO for Release-builds.
-- `GODOT_CUSTOM_API_FILE`:    Path to a custom GDExtension API JSON file (takes precedence over `gdextension_dir`)
-- `GODOT_PRECISION`:          Floating-point precision level ("single", "double")
-
-### 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
-```shell
-Builds a debug version:
-cmake .
-cmake --build .
-```
-Builds a release version with clang
-
-```shell
-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:
-
-``` shell
-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:
-
-```shell
-mkdir build && cd build && cmake -G "Unix Makefiles" .. && cmake --build .
-```
-
-Ensure that you avoid exposing godot-cpp symbols - this might lead to hard to debug errors if you ever load multiple
-plugins using difference godot-cpp versions. Use visibility hidden whenever possible:
-```cmake
-set_target_properties(<all-my-plugin-related-targets> PROPERTIES CXX_VISIBILITY_PRESET hidden)
-```
-
-## Todo
-Test build for Windows, Mac and mingw.

gdextension/gdextension_interface.h

@@ -258,19 +258,14 @@ typedef const GDExtensionPropertyInfo *(*GDExtensionClassGetPropertyList)(GDExte
 typedef void (*GDExtensionClassFreePropertyList)(GDExtensionClassInstancePtr p_instance, const GDExtensionPropertyInfo *p_list);
 typedef GDExtensionBool (*GDExtensionClassPropertyCanRevert)(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name);
 typedef GDExtensionBool (*GDExtensionClassPropertyGetRevert)(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionVariantPtr r_ret);
-typedef GDExtensionBool (*GDExtensionClassValidateProperty)(GDExtensionClassInstancePtr p_instance, GDExtensionPropertyInfo *p_property);
-typedef void (*GDExtensionClassNotification)(GDExtensionClassInstancePtr p_instance, int32_t p_what); // Deprecated. Use GDExtensionClassNotification2 instead.
-typedef void (*GDExtensionClassNotification2)(GDExtensionClassInstancePtr p_instance, int32_t p_what, GDExtensionBool p_reversed);
+typedef void (*GDExtensionClassNotification)(GDExtensionClassInstancePtr p_instance, int32_t p_what);
 typedef void (*GDExtensionClassToString)(GDExtensionClassInstancePtr p_instance, GDExtensionBool *r_is_valid, GDExtensionStringPtr p_out);
 typedef void (*GDExtensionClassReference)(GDExtensionClassInstancePtr p_instance);
 typedef void (*GDExtensionClassUnreference)(GDExtensionClassInstancePtr p_instance);
 typedef void (*GDExtensionClassCallVirtual)(GDExtensionClassInstancePtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret);
-typedef GDExtensionObjectPtr (*GDExtensionClassCreateInstance)(void *p_class_userdata);
-typedef void (*GDExtensionClassFreeInstance)(void *p_class_userdata, GDExtensionClassInstancePtr p_instance);
-typedef GDExtensionClassInstancePtr (*GDExtensionClassRecreateInstance)(void *p_class_userdata, GDExtensionObjectPtr p_object);
-typedef GDExtensionClassCallVirtual (*GDExtensionClassGetVirtual)(void *p_class_userdata, GDExtensionConstStringNamePtr p_name);
-typedef void *(*GDExtensionClassGetVirtualCallData)(void *p_class_userdata, GDExtensionConstStringNamePtr p_name);
-typedef void (*GDExtensionClassCallVirtualWithData)(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, void *p_virtual_call_userdata, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret);
+typedef GDExtensionObjectPtr (*GDExtensionClassCreateInstance)(void *p_userdata);
+typedef void (*GDExtensionClassFreeInstance)(void *p_userdata, GDExtensionClassInstancePtr p_instance);
+typedef GDExtensionClassCallVirtual (*GDExtensionClassGetVirtual)(void *p_userdata, GDExtensionConstStringNamePtr p_name);
 
 typedef struct {
 	GDExtensionBool is_virtual;
@@ -290,40 +285,7 @@ typedef struct {
 	GDExtensionClassGetVirtual get_virtual_func; // Queries a virtual function by name and returns a callback to invoke the requested virtual function.
 	GDExtensionClassGetRID get_rid_func;
 	void *class_userdata; // Per-class user data, later accessible in instance bindings.
-} GDExtensionClassCreationInfo; // Deprecated. Use GDExtensionClassCreationInfo2 instead.
-
-typedef struct {
-	GDExtensionBool is_virtual;
-	GDExtensionBool is_abstract;
-	GDExtensionBool is_exposed;
-	GDExtensionClassSet set_func;
-	GDExtensionClassGet get_func;
-	GDExtensionClassGetPropertyList get_property_list_func;
-	GDExtensionClassFreePropertyList free_property_list_func;
-	GDExtensionClassPropertyCanRevert property_can_revert_func;
-	GDExtensionClassPropertyGetRevert property_get_revert_func;
-	GDExtensionClassValidateProperty validate_property_func;
-	GDExtensionClassNotification2 notification_func;
-	GDExtensionClassToString to_string_func;
-	GDExtensionClassReference reference_func;
-	GDExtensionClassUnreference unreference_func;
-	GDExtensionClassCreateInstance create_instance_func; // (Default) constructor; mandatory. If the class is not instantiable, consider making it virtual or abstract.
-	GDExtensionClassFreeInstance free_instance_func; // Destructor; mandatory.
-	GDExtensionClassRecreateInstance recreate_instance_func;
-	// Queries a virtual function by name and returns a callback to invoke the requested virtual function.
-	GDExtensionClassGetVirtual get_virtual_func;
-	// Paired with `call_virtual_with_data_func`, this is an alternative to `get_virtual_func` for extensions that
-	// need or benefit from extra data when calling virtual functions.
-	// Returns user data that will be passed to `call_virtual_with_data_func`.
-	// Returning `NULL` from this function signals to Godot that the virtual function is not overridden.
-	// Data returned from this function should be managed by the extension and must be valid until the extension is deinitialized.
-	// You should supply either `get_virtual_func`, or `get_virtual_call_data_func` with `call_virtual_with_data_func`.
-	GDExtensionClassGetVirtualCallData get_virtual_call_data_func;
-	// Used to call virtual functions when `get_virtual_call_data_func` is not null.
-	GDExtensionClassCallVirtualWithData call_virtual_with_data_func;
-	GDExtensionClassGetRID get_rid_func;
-	void *class_userdata; // Per-class user data, later accessible in instance bindings.
-} GDExtensionClassCreationInfo2;
+} GDExtensionClassCreationInfo;
 
 typedef void *GDExtensionClassLibraryPtr;
 
@@ -381,47 +343,6 @@ typedef struct {
 	GDExtensionVariantPtr *default_arguments;
 } GDExtensionClassMethodInfo;
 
-typedef void (*GDExtensionCallableCustomCall)(void *callable_userdata, const GDExtensionConstVariantPtr *p_args, GDExtensionInt p_argument_count, GDExtensionVariantPtr r_return, GDExtensionCallError *r_error);
-typedef GDExtensionBool (*GDExtensionCallableCustomIsValid)(void *callable_userdata);
-typedef void (*GDExtensionCallableCustomFree)(void *callable_userdata);
-
-typedef uint32_t (*GDExtensionCallableCustomHash)(void *callable_userdata);
-typedef GDExtensionBool (*GDExtensionCallableCustomEqual)(void *callable_userdata_a, void *callable_userdata_b);
-typedef GDExtensionBool (*GDExtensionCallableCustomLessThan)(void *callable_userdata_a, void *callable_userdata_b);
-
-typedef void (*GDExtensionCallableCustomToString)(void *callable_userdata, GDExtensionBool *r_is_valid, GDExtensionStringPtr r_out);
-
-typedef struct {
-	/* Only `call_func` and `token` are strictly required, however, `object_id` should be passed if its not a static method.
-	 *
-	 * `token` should point to an address that uniquely identifies the GDExtension (for example, the
-	 * `GDExtensionClassLibraryPtr` passed to the entry symbol function.
-	 *
-	 * `hash_func`, `equal_func`, and `less_than_func` are optional. If not provided both `call_func` and
-	 * `callable_userdata` together are used as the identity of the callable for hashing and comparison purposes.
-	 *
-	 * The hash returned by `hash_func` is cached, `hash_func` will not be called more than once per callable.
-	 *
-	 * `is_valid_func` is necessary if the validity of the callable can change before destruction.
-	 *
-	 * `free_func` is necessary if `callable_userdata` needs to be cleaned up when the callable is freed.
-	 */
-	void *callable_userdata;
-	void *token;
-
-	GDObjectInstanceID object_id;
-
-	GDExtensionCallableCustomCall call_func;
-	GDExtensionCallableCustomIsValid is_valid_func;
-	GDExtensionCallableCustomFree free_func;
-
-	GDExtensionCallableCustomHash hash_func;
-	GDExtensionCallableCustomEqual equal_func;
-	GDExtensionCallableCustomLessThan less_than_func;
-
-	GDExtensionCallableCustomToString to_string_func;
-} GDExtensionCallableCustomInfo;
-
 /* SCRIPT INSTANCE EXTENSION */
 
 typedef void *GDExtensionScriptInstanceDataPtr; // Pointer to custom ScriptInstance native implementation.
@@ -430,10 +351,7 @@ typedef GDExtensionBool (*GDExtensionScriptInstanceSet)(GDExtensionScriptInstanc
 typedef GDExtensionBool (*GDExtensionScriptInstanceGet)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionVariantPtr r_ret);
 typedef const GDExtensionPropertyInfo *(*GDExtensionScriptInstanceGetPropertyList)(GDExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count);
 typedef void (*GDExtensionScriptInstanceFreePropertyList)(GDExtensionScriptInstanceDataPtr p_instance, const GDExtensionPropertyInfo *p_list);
-typedef GDExtensionBool (*GDExtensionScriptInstanceGetClassCategory)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionPropertyInfo *p_class_category);
-
 typedef GDExtensionVariantType (*GDExtensionScriptInstanceGetPropertyType)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionBool *r_is_valid);
-typedef GDExtensionBool (*GDExtensionScriptInstanceValidateProperty)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionPropertyInfo *p_property);
 
 typedef GDExtensionBool (*GDExtensionScriptInstancePropertyCanRevert)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionConstStringNamePtr p_name);
 typedef GDExtensionBool (*GDExtensionScriptInstancePropertyGetRevert)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionVariantPtr r_ret);
@@ -448,8 +366,7 @@ typedef void (*GDExtensionScriptInstanceFreeMethodList)(GDExtensionScriptInstanc
 typedef GDExtensionBool (*GDExtensionScriptInstanceHasMethod)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionConstStringNamePtr p_name);
 
 typedef void (*GDExtensionScriptInstanceCall)(GDExtensionScriptInstanceDataPtr p_self, GDExtensionConstStringNamePtr p_method, const GDExtensionConstVariantPtr *p_args, GDExtensionInt p_argument_count, GDExtensionVariantPtr r_return, GDExtensionCallError *r_error);
-typedef void (*GDExtensionScriptInstanceNotification)(GDExtensionScriptInstanceDataPtr p_instance, int32_t p_what); // Deprecated. Use GDExtensionScriptInstanceNotification2 instead.
-typedef void (*GDExtensionScriptInstanceNotification2)(GDExtensionScriptInstanceDataPtr p_instance, int32_t p_what, GDExtensionBool p_reversed);
+typedef void (*GDExtensionScriptInstanceNotification)(GDExtensionScriptInstanceDataPtr p_instance, int32_t p_what);
 typedef void (*GDExtensionScriptInstanceToString)(GDExtensionScriptInstanceDataPtr p_instance, GDExtensionBool *r_is_valid, GDExtensionStringPtr r_out);
 
 typedef void (*GDExtensionScriptInstanceRefCountIncremented)(GDExtensionScriptInstanceDataPtr p_instance);
@@ -503,48 +420,7 @@ typedef struct {
 
 	GDExtensionScriptInstanceFree free_func;
 
-} GDExtensionScriptInstanceInfo; // Deprecated. Use GDExtensionScriptInstanceInfo2 instead.
-
-typedef struct {
-	GDExtensionScriptInstanceSet set_func;
-	GDExtensionScriptInstanceGet get_func;
-	GDExtensionScriptInstanceGetPropertyList get_property_list_func;
-	GDExtensionScriptInstanceFreePropertyList free_property_list_func;
-	GDExtensionScriptInstanceGetClassCategory get_class_category_func; // Optional. Set to NULL for the default behavior.
-
-	GDExtensionScriptInstancePropertyCanRevert property_can_revert_func;
-	GDExtensionScriptInstancePropertyGetRevert property_get_revert_func;
-
-	GDExtensionScriptInstanceGetOwner get_owner_func;
-	GDExtensionScriptInstanceGetPropertyState get_property_state_func;
-
-	GDExtensionScriptInstanceGetMethodList get_method_list_func;
-	GDExtensionScriptInstanceFreeMethodList free_method_list_func;
-	GDExtensionScriptInstanceGetPropertyType get_property_type_func;
-	GDExtensionScriptInstanceValidateProperty validate_property_func;
-
-	GDExtensionScriptInstanceHasMethod has_method_func;
-
-	GDExtensionScriptInstanceCall call_func;
-	GDExtensionScriptInstanceNotification2 notification_func;
-
-	GDExtensionScriptInstanceToString to_string_func;
-
-	GDExtensionScriptInstanceRefCountIncremented refcount_incremented_func;
-	GDExtensionScriptInstanceRefCountDecremented refcount_decremented_func;
-
-	GDExtensionScriptInstanceGetScript get_script_func;
-
-	GDExtensionScriptInstanceIsPlaceholder is_placeholder_func;
-
-	GDExtensionScriptInstanceSet set_fallback_func;
-	GDExtensionScriptInstanceGet get_fallback_func;
-
-	GDExtensionScriptInstanceGetLanguage get_language_func;
-
-	GDExtensionScriptInstanceFree free_func;
-
-} GDExtensionScriptInstanceInfo2;
+} GDExtensionScriptInstanceInfo;
 
 /* INITIALIZATION */
 
@@ -590,10 +466,7 @@ typedef GDExtensionInterfaceFunctionPtr (*GDExtensionInterfaceGetProcAddress)(co
  *
  * For example:
  *
- *   GDExtensionInterfaceGetGodotVersion get_godot_version = (GDExtensionInterfaceGetGodotVersion)p_get_proc_address("get_godot_version");
- *
- * (Note that snippet may cause "cast between incompatible function types" on some compilers, you can
- * silence this by adding an intermediary `void*` cast.)
+ *   GDExtensionInterfaceGetGodotVersion *get_godot_version = (GDExtensionInterfaceGetGodotVersion)p_get_proc_address("get_godot_version");
  *
  * You can then call it like a normal function:
  *
@@ -1440,7 +1313,7 @@ typedef void (*GDExtensionInterfaceStringNewWithWideChars)(GDExtensionUninitiali
  *
  * @param r_dest A pointer to a Variant to hold the newly created String.
  * @param p_contents A pointer to a Latin-1 encoded C string.
- * @param p_size The number of characters (= number of bytes).
+ * @param p_size The number of characters.
  */
 typedef void (*GDExtensionInterfaceStringNewWithLatin1CharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const char *p_contents, GDExtensionInt p_size);
 
@@ -1452,7 +1325,7 @@ typedef void (*GDExtensionInterfaceStringNewWithLatin1CharsAndLen)(GDExtensionUn
  *
  * @param r_dest A pointer to a Variant to hold the newly created String.
  * @param p_contents A pointer to a UTF-8 encoded C string.
- * @param p_size The number of bytes (not code units).
+ * @param p_size The number of characters.
  */
 typedef void (*GDExtensionInterfaceStringNewWithUtf8CharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const char *p_contents, GDExtensionInt p_size);
 
@@ -1464,9 +1337,9 @@ typedef void (*GDExtensionInterfaceStringNewWithUtf8CharsAndLen)(GDExtensionUnin
  *
  * @param r_dest A pointer to a Variant to hold the newly created String.
  * @param p_contents A pointer to a UTF-16 encoded C string.
- * @param p_size The number of characters (not bytes).
+ * @param p_size The number of characters.
  */
-typedef void (*GDExtensionInterfaceStringNewWithUtf16CharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const char16_t *p_contents, GDExtensionInt p_char_count);
+typedef void (*GDExtensionInterfaceStringNewWithUtf16CharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const char16_t *p_contents, GDExtensionInt p_size);
 
 /**
  * @name string_new_with_utf32_chars_and_len
@@ -1476,9 +1349,9 @@ typedef void (*GDExtensionInterfaceStringNewWithUtf16CharsAndLen)(GDExtensionUni
  *
  * @param r_dest A pointer to a Variant to hold the newly created String.
  * @param p_contents A pointer to a UTF-32 encoded C string.
- * @param p_size The number of characters (not bytes).
+ * @param p_size The number of characters.
  */
-typedef void (*GDExtensionInterfaceStringNewWithUtf32CharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const char32_t *p_contents, GDExtensionInt p_char_count);
+typedef void (*GDExtensionInterfaceStringNewWithUtf32CharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const char32_t *p_contents, GDExtensionInt p_size);
 
 /**
  * @name string_new_with_wide_chars_and_len
@@ -1488,9 +1361,9 @@ typedef void (*GDExtensionInterfaceStringNewWithUtf32CharsAndLen)(GDExtensionUni
  *
  * @param r_dest A pointer to a Variant to hold the newly created String.
  * @param p_contents A pointer to a wide C string.
- * @param p_size The number of characters (not bytes).
+ * @param p_size The number of characters.
  */
-typedef void (*GDExtensionInterfaceStringNewWithWideCharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const wchar_t *p_contents, GDExtensionInt p_char_count);
+typedef void (*GDExtensionInterfaceStringNewWithWideCharsAndLen)(GDExtensionUninitializedStringPtr r_dest, const wchar_t *p_contents, GDExtensionInt p_size);
 
 /**
  * @name string_to_latin1_chars
@@ -1653,69 +1526,6 @@ typedef void (*GDExtensionInterfaceStringOperatorPlusEqWcstr)(GDExtensionStringP
  */
 typedef void (*GDExtensionInterfaceStringOperatorPlusEqC32str)(GDExtensionStringPtr p_self, const char32_t *p_b);
 
-/**
- * @name string_resize
- * @since 4.2
- *
- * Resizes the underlying string data to the given number of characters.
- *
- * Space needs to be allocated for the null terminating character ('\0') which
- * also must be added manually, in order for all string functions to work correctly.
- *
- * Warning: This is an error-prone operation - only use it if there's no other
- * efficient way to accomplish your goal.
- *
- * @param p_self A pointer to the String.
- * @param p_resize The new length for the String.
- *
- * @return Error code signifying if the operation successful.
- */
-typedef GDExtensionInt (*GDExtensionInterfaceStringResize)(GDExtensionStringPtr p_self, GDExtensionInt p_resize);
-
-/* INTERFACE: StringName Utilities */
-
-/**
- * @name string_name_new_with_latin1_chars
- * @since 4.2
- *
- * Creates a StringName from a Latin-1 encoded C string.
- *
- * If `p_is_static` is true, then:
- * - The StringName will reuse the `p_contents` buffer instead of copying it.
- *   You must guarantee that the buffer remains valid for the duration of the application (e.g. string literal).
- * - You must not call a destructor for this StringName. Incrementing the initial reference once should achieve this.
- *
- * `p_is_static` is purely an optimization and can easily introduce undefined behavior if used wrong. In case of doubt, set it to false.
- *
- * @param r_dest A pointer to uninitialized storage, into which the newly created StringName is constructed.
- * @param p_contents A pointer to a C string (null terminated and Latin-1 or ASCII encoded).
- * @param p_is_static Whether the StringName reuses the buffer directly (see above).
- */
-typedef void (*GDExtensionInterfaceStringNameNewWithLatin1Chars)(GDExtensionUninitializedStringNamePtr r_dest, const char *p_contents, GDExtensionBool p_is_static);
-
-/**
- * @name string_name_new_with_utf8_chars
- * @since 4.2
- *
- * Creates a StringName from a UTF-8 encoded C string.
- *
- * @param r_dest A pointer to uninitialized storage, into which the newly created StringName is constructed.
- * @param p_contents A pointer to a C string (null terminated and UTF-8 encoded).
- */
-typedef void (*GDExtensionInterfaceStringNameNewWithUtf8Chars)(GDExtensionUninitializedStringNamePtr r_dest, const char *p_contents);
-
-/**
- * @name string_name_new_with_utf8_chars_and_len
- * @since 4.2
- *
- * Creates a StringName from a UTF-8 encoded string with a given number of characters.
- *
- * @param r_dest A pointer to uninitialized storage, into which the newly created StringName is constructed.
- * @param p_contents A pointer to a C string (null terminated and UTF-8 encoded).
- * @param p_size The number of bytes (not UTF-8 code points).
- */
-typedef void (*GDExtensionInterfaceStringNameNewWithUtf8CharsAndLen)(GDExtensionUninitializedStringNamePtr r_dest, const char *p_contents, GDExtensionInt p_size);
-
 /* INTERFACE: XMLParser Utilities */
 
 /**
@@ -2194,17 +2004,6 @@ typedef void *(*GDExtensionInterfaceObjectGetInstanceBinding)(GDExtensionObjectP
  */
 typedef void (*GDExtensionInterfaceObjectSetInstanceBinding)(GDExtensionObjectPtr p_o, void *p_token, void *p_binding, const GDExtensionInstanceBindingCallbacks *p_callbacks);
 
-/**
- * @name object_free_instance_binding
- * @since 4.2
- *
- * Free an Object's instance binding.
- *
- * @param p_o A pointer to the Object.
- * @param p_library A token the library received by the GDExtension's entry point function.
- */
-typedef void (*GDExtensionInterfaceObjectFreeInstanceBinding)(GDExtensionObjectPtr p_o, void *p_token);
-
 /**
  * @name object_set_instance
  * @since 4.1
@@ -2298,7 +2097,6 @@ typedef void (*GDExtensionInterfaceRefSetObject)(GDExtensionRefPtr p_ref, GDExte
 /**
  * @name script_instance_create
  * @since 4.1
- * @deprecated in Godot 4.2. Use `script_instance_create2` instead.
  *
  * Creates a script instance that contains the given info and instance data.
  *
@@ -2309,91 +2107,6 @@ typedef void (*GDExtensionInterfaceRefSetObject)(GDExtensionRefPtr p_ref, GDExte
  */
 typedef GDExtensionScriptInstancePtr (*GDExtensionInterfaceScriptInstanceCreate)(const GDExtensionScriptInstanceInfo *p_info, GDExtensionScriptInstanceDataPtr p_instance_data);
 
-/**
- * @name script_instance_create2
- * @since 4.2
- *
- * Creates a script instance that contains the given info and instance data.
- *
- * @param p_info A pointer to a GDExtensionScriptInstanceInfo2 struct.
- * @param p_instance_data A pointer to a data representing the script instance in the GDExtension. This will be passed to all the function pointers on p_info.
- *
- * @return A pointer to a ScriptInstanceExtension object.
- */
-typedef GDExtensionScriptInstancePtr (*GDExtensionInterfaceScriptInstanceCreate2)(const GDExtensionScriptInstanceInfo2 *p_info, GDExtensionScriptInstanceDataPtr p_instance_data);
-
-/**
- * @name placeholder_script_instance_create
- * @since 4.2
- *
- * Creates a placeholder script instance for a given script and instance.
- *
- * This interface is optional as a custom placeholder could also be created with script_instance_create().
- *
- * @param p_language A pointer to a ScriptLanguage.
- * @param p_script A pointer to a Script.
- * @param p_owner A pointer to an Object.
- *
- * @return A pointer to a PlaceHolderScriptInstance object.
- */
-typedef GDExtensionScriptInstancePtr (*GDExtensionInterfacePlaceHolderScriptInstanceCreate)(GDExtensionObjectPtr p_language, GDExtensionObjectPtr p_script, GDExtensionObjectPtr p_owner);
-
-/**
- * @name placeholder_script_instance_update
- * @since 4.2
- *
- * Updates a placeholder script instance with the given properties and values.
- *
- * The passed in placeholder must be an instance of PlaceHolderScriptInstance
- * such as the one returned by placeholder_script_instance_create().
- *
- * @param p_placeholder A pointer to a PlaceHolderScriptInstance.
- * @param p_properties A pointer to an Array of Dictionary representing PropertyInfo.
- * @param p_values A pointer to a Dictionary mapping StringName to Variant values.
- */
-typedef void (*GDExtensionInterfacePlaceHolderScriptInstanceUpdate)(GDExtensionScriptInstancePtr p_placeholder, GDExtensionConstTypePtr p_properties, GDExtensionConstTypePtr p_values);
-
-/**
- * @name object_get_script_instance
- * @since 4.2
- *
- * Get the script instance data attached to this object.
- *
- * @param p_object A pointer to the Object.
- * @param p_language A pointer to the language expected for this script instance.
- *
- * @return A GDExtensionScriptInstanceDataPtr that was attached to this object as part of script_instance_create.
- */
-typedef GDExtensionScriptInstanceDataPtr (*GDExtensionInterfaceObjectGetScriptInstance)(GDExtensionConstObjectPtr p_object, GDExtensionObjectPtr p_language);
-
-/* INTERFACE: Callable */
-
-/**
- * @name callable_custom_create
- * @since 4.2
- *
- * Creates a custom Callable object from a function pointer.
- *
- * Provided struct can be safely freed once the function returns.
- *
- * @param r_callable A pointer that will receive the new Callable.
- * @param p_callable_custom_info The info required to construct a Callable.
- */
-typedef void (*GDExtensionInterfaceCallableCustomCreate)(GDExtensionUninitializedTypePtr r_callable, GDExtensionCallableCustomInfo *p_callable_custom_info);
-
-/**
- * @name callable_custom_get_userdata
- * @since 4.2
- *
- * Retrieves the userdata pointer from a custom Callable.
- *
- * If the Callable is not a custom Callable or the token does not match the one provided to callable_custom_create() via GDExtensionCallableCustomInfo then NULL will be returned.
- *
- * @param p_callable A pointer to a Callable.
- * @param p_token A pointer to an address that uniquely identifies the GDExtension.
- */
-typedef void *(*GDExtensionInterfaceCallableCustomGetUserData)(GDExtensionConstTypePtr p_callable, void *p_token);
-
 /* INTERFACE: ClassDB */
 
 /**
@@ -2441,7 +2154,6 @@ typedef void *(*GDExtensionInterfaceClassdbGetClassTag)(GDExtensionConstStringNa
 /**
  * @name classdb_register_extension_class
  * @since 4.1
- * @deprecated in Godot 4.2. Use `classdb_register_extension_class2` instead.
  *
  * Registers an extension class in the ClassDB.
  *
@@ -2454,21 +2166,6 @@ typedef void *(*GDExtensionInterfaceClassdbGetClassTag)(GDExtensionConstStringNa
  */
 typedef void (*GDExtensionInterfaceClassdbRegisterExtensionClass)(GDExtensionClassLibraryPtr p_library, GDExtensionConstStringNamePtr p_class_name, GDExtensionConstStringNamePtr p_parent_class_name, const GDExtensionClassCreationInfo *p_extension_funcs);
 
-/**
- * @name classdb_register_extension_class2
- * @since 4.2
- *
- * Registers an extension class in the ClassDB.
- *
- * Provided struct can be safely freed once the function returns.
- *
- * @param p_library A pointer the library received by the GDExtension's entry point function.
- * @param p_class_name A pointer to a StringName with the class name.
- * @param p_parent_class_name A pointer to a StringName with the parent class name.
- * @param p_extension_funcs A pointer to a GDExtensionClassCreationInfo2 struct.
- */
-typedef void (*GDExtensionInterfaceClassdbRegisterExtensionClass2)(GDExtensionClassLibraryPtr p_library, GDExtensionConstStringNamePtr p_class_name, GDExtensionConstStringNamePtr p_parent_class_name, const GDExtensionClassCreationInfo2 *p_extension_funcs);
-
 /**
  * @name classdb_register_extension_class_method
  * @since 4.1
@@ -2514,23 +2211,6 @@ typedef void (*GDExtensionInterfaceClassdbRegisterExtensionClassIntegerConstant)
  */
 typedef void (*GDExtensionInterfaceClassdbRegisterExtensionClassProperty)(GDExtensionClassLibraryPtr p_library, GDExtensionConstStringNamePtr p_class_name, const GDExtensionPropertyInfo *p_info, GDExtensionConstStringNamePtr p_setter, GDExtensionConstStringNamePtr p_getter);
 
-/**
- * @name classdb_register_extension_class_property_indexed
- * @since 4.2
- *
- * Registers an indexed property on an extension class in the ClassDB.
- *
- * Provided struct can be safely freed once the function returns.
- *
- * @param p_library A pointer the library received by the GDExtension's entry point function.
- * @param p_class_name A pointer to a StringName with the class name.
- * @param p_info A pointer to a GDExtensionPropertyInfo struct.
- * @param p_setter A pointer to a StringName with the name of the setter method.
- * @param p_getter A pointer to a StringName with the name of the getter method.
- * @param p_index The index to pass as the first argument to the getter and setter methods.
- */
-typedef void (*GDExtensionInterfaceClassdbRegisterExtensionClassPropertyIndexed)(GDExtensionClassLibraryPtr p_library, GDExtensionConstStringNamePtr p_class_name, const GDExtensionPropertyInfo *p_info, GDExtensionConstStringNamePtr p_setter, GDExtensionConstStringNamePtr p_getter, GDExtensionInt p_index);
-
 /**
  * @name classdb_register_extension_class_property_group
  * @since 4.1

include/godot_cpp/classes/editor_plugin_registration.hpp

@@ -1,62 +0,0 @@
-/**************************************************************************/
-/*  editor_plugin_registration.hpp                                        */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* 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_EDITOR_PLUGIN_REGISTRATION_HPP
-#define GODOT_EDITOR_PLUGIN_REGISTRATION_HPP
-
-#include <godot_cpp/templates/vector.hpp>
-
-namespace godot {
-
-class EditorPlugin;
-class StringName;
-
-class EditorPlugins {
-private:
-	static Vector<StringName> plugin_classes;
-
-public:
-	static void add_plugin_class(const StringName &p_class_name);
-	static void remove_plugin_class(const StringName &p_class_name);
-	static void deinitialize(GDExtensionInitializationLevel p_level);
-
-	template <typename T>
-	static void add_by_type() {
-		add_plugin_class(T::get_class_static());
-	}
-	template <typename T>
-	static void remove_by_type() {
-		remove_plugin_class(T::get_class_static());
-	}
-};
-
-} // namespace godot
-
-#endif // GODOT_EDITOR_PLUGIN_REGISTRATION_HPP

include/godot_cpp/classes/ref.hpp

@@ -45,7 +45,7 @@ namespace godot {
 
 class RefCounted;
 
-template <typename T>
+template <class T>
 class Ref {
 	T *reference = nullptr;
 
@@ -63,7 +63,7 @@ class Ref {
 	}
 
 	void ref_pointer(T *p_ref) {
-		ERR_FAIL_NULL(p_ref);
+		ERR_FAIL_COND(!p_ref);
 
 		if (p_ref->init_ref()) {
 			reference = p_ref;
@@ -108,7 +108,7 @@ public:
 		ref(p_from);
 	}
 
-	template <typename T_Other>
+	template <class T_Other>
 	void operator=(const Ref<T_Other> &p_from) {
 		RefCounted *refb = const_cast<RefCounted *>(static_cast<const RefCounted *>(p_from.ptr()));
 		if (!refb) {
@@ -144,7 +144,7 @@ public:
 		}
 	}
 
-	template <typename T_Other>
+	template <class T_Other>
 	void reference_ptr(T_Other *p_ptr) {
 		if (reference == p_ptr) {
 			return;
@@ -161,7 +161,7 @@ public:
 		ref(p_from);
 	}
 
-	template <typename T_Other>
+	template <class T_Other>
 	Ref(const Ref<T_Other> &p_from) {
 		RefCounted *refb = const_cast<RefCounted *>(static_cast<const RefCounted *>(p_from.ptr()));
 		if (!refb) {
@@ -226,13 +226,11 @@ public:
 	}
 };
 
-template <typename T>
+template <class T>
 struct PtrToArg<Ref<T>> {
 	_FORCE_INLINE_ static Ref<T> convert(const void *p_ptr) {
 		GDExtensionRefPtr ref = (GDExtensionRefPtr)p_ptr;
-		if (unlikely(!p_ptr)) {
-			return Ref<T>();
-		}
+		ERR_FAIL_NULL_V(p_ptr, Ref<T>());
 		return Ref<T>(reinterpret_cast<T *>(godot::internal::get_object_instance_binding(godot::internal::gdextension_interface_ref_get_object(ref))));
 	}
 
@@ -250,20 +248,18 @@ struct PtrToArg<Ref<T>> {
 	}
 };
 
-template <typename T>
+template <class T>
 struct PtrToArg<const Ref<T> &> {
 	typedef Ref<T> EncodeT;
 
 	_FORCE_INLINE_ static Ref<T> convert(const void *p_ptr) {
 		GDExtensionRefPtr ref = const_cast<GDExtensionRefPtr>(p_ptr);
-		if (unlikely(!p_ptr)) {
-			return Ref<T>();
-		}
+		ERR_FAIL_NULL_V(p_ptr, Ref<T>());
 		return Ref<T>(reinterpret_cast<T *>(godot::internal::get_object_instance_binding(godot::internal::gdextension_interface_ref_get_object(ref))));
 	}
 };
 
-template <typename T>
+template <class T>
 struct GetTypeInfo<Ref<T>, typename EnableIf<TypeInherits<RefCounted, T>::value>::type> {
 	static const GDExtensionVariantType VARIANT_TYPE = GDEXTENSION_VARIANT_TYPE_OBJECT;
 	static const GDExtensionClassMethodArgumentMetadata METADATA = GDEXTENSION_METHOD_ARGUMENT_METADATA_NONE;
@@ -273,7 +269,7 @@ struct GetTypeInfo<Ref<T>, typename EnableIf<TypeInherits<RefCounted, T>::value>
 	}
 };
 
-template <typename T>
+template <class T>
 struct GetTypeInfo<const Ref<T> &, typename EnableIf<TypeInherits<RefCounted, T>::value>::type> {
 	static const GDExtensionVariantType VARIANT_TYPE = GDEXTENSION_VARIANT_TYPE_OBJECT;
 	static const GDExtensionClassMethodArgumentMetadata METADATA = GDEXTENSION_METHOD_ARGUMENT_METADATA_NONE;

include/godot_cpp/classes/wrapped.hpp

@@ -48,19 +48,9 @@ typedef void GodotObject;
 // Base for all engine classes, to contain the pointer to the engine instance.
 class Wrapped {
 	friend class GDExtensionBinding;
-	friend class ClassDB;
 	friend void postinitialize_handler(Wrapped *);
 
 protected:
-#ifdef HOT_RELOAD_ENABLED
-	struct RecreateInstance {
-		GDExtensionClassInstancePtr wrapper;
-		GDExtensionObjectPtr owner;
-		RecreateInstance *next;
-	};
-	inline static RecreateInstance *recreate_instance = nullptr;
-#endif
-
 	virtual const StringName *_get_extension_class_name() const; // This is needed to retrieve the class name before the godot object has its _extension and _extension_instance members assigned.
 	virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const = 0;
 
@@ -70,33 +60,30 @@ protected:
 	void _get_property_list(List<PropertyInfo> *p_list) const {}
 	bool _property_can_revert(const StringName &p_name) const { return false; }
 	bool _property_get_revert(const StringName &p_name, Variant &r_property) const { return false; }
-	void _validate_property(PropertyInfo &p_property) const {}
 	String _to_string() const { return "[" + String(get_class_static()) + ":" + itos(get_instance_id()) + "]"; }
 
-	static void notification_bind(GDExtensionClassInstancePtr p_instance, int32_t p_what, GDExtensionBool p_reversed) {}
+	static void notification_bind(GDExtensionClassInstancePtr p_instance, int32_t p_what) {}
 	static GDExtensionBool set_bind(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionConstVariantPtr p_value) { return false; }
 	static GDExtensionBool get_bind(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionVariantPtr r_ret) { return false; }
 	static const GDExtensionPropertyInfo *get_property_list_bind(GDExtensionClassInstancePtr p_instance, uint32_t *r_count) { return nullptr; }
 	static void free_property_list_bind(GDExtensionClassInstancePtr p_instance, const GDExtensionPropertyInfo *p_list) {}
 	static GDExtensionBool property_can_revert_bind(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name) { return false; }
 	static GDExtensionBool property_get_revert_bind(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionVariantPtr r_ret) { return false; }
-	static GDExtensionBool validate_property_bind(GDExtensionClassInstancePtr p_instance, GDExtensionPropertyInfo *p_property) { return false; }
 	static void to_string_bind(GDExtensionClassInstancePtr p_instance, GDExtensionBool *r_is_valid, GDExtensionStringPtr r_out) {}
 
-	// The only reason this has to be held here, is when we return results of `_get_property_list` to Godot, we pass
-	// pointers to strings in this list. They have to remain valid to pass the bridge, until the list is freed by Godot...
 	::godot::List<::godot::PropertyInfo> plist_owned;
+	GDExtensionPropertyInfo *plist = nullptr;
+	uint32_t plist_size = 0;
 
 	void _postinitialize();
-	virtual void _notificationv(int32_t p_what, bool p_reversed = false) {}
 
 	Wrapped(const StringName p_godot_class);
 	Wrapped(GodotObject *p_godot_object);
 	virtual ~Wrapped() {}
 
 public:
-	static const StringName &get_class_static() {
-		static const StringName string_name = StringName("Wrapped");
+	static StringName &get_class_static() {
+		static StringName string_name = StringName("Wrapped");
 		return string_name;
 	}
 
@@ -108,37 +95,11 @@ public:
 	GodotObject *_owner = nullptr;
 };
 
-namespace internal {
-
-GDExtensionPropertyInfo *create_c_property_list(const ::godot::List<::godot::PropertyInfo> &plist_cpp, uint32_t *r_size);
-void free_c_property_list(GDExtensionPropertyInfo *plist);
-
-typedef void (*EngineClassRegistrationCallback)();
-void add_engine_class_registration_callback(EngineClassRegistrationCallback p_callback);
-void register_engine_class(const StringName &p_name, const GDExtensionInstanceBindingCallbacks *p_callbacks);
-void register_engine_classes();
-
-template <typename T>
-struct EngineClassRegistration {
-	EngineClassRegistration() {
-		add_engine_class_registration_callback(&EngineClassRegistration<T>::callback);
-	}
-
-	static void callback() {
-		register_engine_class(T::get_class_static(), &T::_gde_binding_callbacks);
-	}
-};
-
-} // namespace internal
-
 } // namespace godot
 
-// Use this on top of your own classes.
-// Note: the trail of `***` is to keep sane diffs in PRs, because clang-format otherwise moves every `\` which makes
-// every line of the macro different
-#define GDCLASS(m_class, m_inherits) /***********************************************************************************************************************************************/ \
+#define GDCLASS(m_class, m_inherits)                                                                                                                                                   \
 private:                                                                                                                                                                               \
-	void operator=(const m_class & /*p_rval*/) {}                                                                                                                                      \
+	void operator=(const m_class &p_rval) {}                                                                                                                                           \
 	friend class ::godot::ClassDB;                                                                                                                                                     \
                                                                                                                                                                                        \
 protected:                                                                                                                                                                             \
@@ -179,23 +140,16 @@ protected:
 		return (bool(::godot::Wrapped::*)(const ::godot::StringName &p_name, ::godot::Variant &) const) & m_class::_property_get_revert;                                               \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static void (::godot::Wrapped::*_get_validate_property())(::godot::PropertyInfo & p_property) const {                                                                              \
-		return (void(::godot::Wrapped::*)(::godot::PropertyInfo & p_property) const) & m_class::_validate_property;                                                                    \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
 	static ::godot::String (::godot::Wrapped::*_get_to_string())() const {                                                                                                             \
 		return (::godot::String(::godot::Wrapped::*)() const) & m_class::_to_string;                                                                                                   \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	template <typename T, typename B>                                                                                                                                                  \
+	template <class T, class B>                                                                                                                                                        \
 	static void register_virtuals() {                                                                                                                                                  \
 		m_inherits::register_virtuals<T, B>();                                                                                                                                         \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 public:                                                                                                                                                                                \
-	typedef m_class self_type;                                                                                                                                                         \
-	typedef m_inherits parent_type;                                                                                                                                                    \
-                                                                                                                                                                                       \
 	static void initialize_class() {                                                                                                                                                   \
 		static bool initialized = false;                                                                                                                                               \
 		if (initialized) {                                                                                                                                                             \
@@ -209,78 +163,86 @@ public:
 		initialized = true;                                                                                                                                                            \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static const ::godot::StringName &get_class_static() {                                                                                                                             \
-		static const ::godot::StringName string_name = ::godot::StringName(#m_class);                                                                                                  \
+	static ::godot::StringName &get_class_static() {                                                                                                                                   \
+		static ::godot::StringName string_name = ::godot::StringName(#m_class);                                                                                                        \
 		return string_name;                                                                                                                                                            \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static const ::godot::StringName &get_parent_class_static() {                                                                                                                      \
+	static ::godot::StringName &get_parent_class_static() {                                                                                                                            \
 		return m_inherits::get_class_static();                                                                                                                                         \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static void notification_bind(GDExtensionClassInstancePtr p_instance, int32_t p_what, GDExtensionBool p_reversed) {                                                                \
+	static GDExtensionObjectPtr create(void *data) {                                                                                                                                   \
+		m_class *new_object = memnew(m_class);                                                                                                                                         \
+		return new_object->_owner;                                                                                                                                                     \
+	}                                                                                                                                                                                  \
+                                                                                                                                                                                       \
+	static void notification_bind(GDExtensionClassInstancePtr p_instance, int32_t p_what) {                                                                                            \
 		if (p_instance && m_class::_get_notification()) {                                                                                                                              \
-			if (!p_reversed) {                                                                                                                                                         \
-				m_inherits::notification_bind(p_instance, p_what, p_reversed);                                                                                                         \
-			}                                                                                                                                                                          \
 			if (m_class::_get_notification() != m_inherits::_get_notification()) {                                                                                                     \
 				m_class *cls = reinterpret_cast<m_class *>(p_instance);                                                                                                                \
-				cls->_notification(p_what);                                                                                                                                            \
-			}                                                                                                                                                                          \
-			if (p_reversed) {                                                                                                                                                          \
-				m_inherits::notification_bind(p_instance, p_what, p_reversed);                                                                                                         \
+				return cls->_notification(p_what);                                                                                                                                     \
 			}                                                                                                                                                                          \
+			m_inherits::notification_bind(p_instance, p_what);                                                                                                                         \
 		}                                                                                                                                                                              \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 	static GDExtensionBool set_bind(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionConstVariantPtr p_value) {                                \
-		if (p_instance) {                                                                                                                                                              \
-			if (m_inherits::set_bind(p_instance, p_name, p_value)) {                                                                                                                   \
-				return true;                                                                                                                                                           \
-			}                                                                                                                                                                          \
+		if (p_instance && m_class::_get_set()) {                                                                                                                                       \
 			if (m_class::_get_set() != m_inherits::_get_set()) {                                                                                                                       \
 				m_class *cls = reinterpret_cast<m_class *>(p_instance);                                                                                                                \
 				return cls->_set(*reinterpret_cast<const ::godot::StringName *>(p_name), *reinterpret_cast<const ::godot::Variant *>(p_value));                                        \
 			}                                                                                                                                                                          \
+			return m_inherits::set_bind(p_instance, p_name, p_value);                                                                                                                  \
 		}                                                                                                                                                                              \
 		return false;                                                                                                                                                                  \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 	static GDExtensionBool get_bind(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, GDExtensionVariantPtr r_ret) {                                       \
-		if (p_instance) {                                                                                                                                                              \
-			if (m_inherits::get_bind(p_instance, p_name, r_ret)) {                                                                                                                     \
-				return true;                                                                                                                                                           \
-			}                                                                                                                                                                          \
+		if (p_instance && m_class::_get_get()) {                                                                                                                                       \
 			if (m_class::_get_get() != m_inherits::_get_get()) {                                                                                                                       \
 				m_class *cls = reinterpret_cast<m_class *>(p_instance);                                                                                                                \
 				return cls->_get(*reinterpret_cast<const ::godot::StringName *>(p_name), *reinterpret_cast<::godot::Variant *>(r_ret));                                                \
 			}                                                                                                                                                                          \
+			return m_inherits::get_bind(p_instance, p_name, r_ret);                                                                                                                    \
 		}                                                                                                                                                                              \
 		return false;                                                                                                                                                                  \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static inline bool has_get_property_list() {                                                                                                                                       \
-		return m_class::_get_get_property_list() && m_class::_get_get_property_list() != m_inherits::_get_get_property_list();                                                         \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
 	static const GDExtensionPropertyInfo *get_property_list_bind(GDExtensionClassInstancePtr p_instance, uint32_t *r_count) {                                                          \
-		if (!p_instance) {                                                                                                                                                             \
-			if (r_count)                                                                                                                                                               \
-				*r_count = 0;                                                                                                                                                          \
-			return nullptr;                                                                                                                                                            \
+		if (p_instance && m_class::_get_get_property_list()) {                                                                                                                         \
+			if (m_class::_get_get_property_list() != m_inherits::_get_get_property_list()) {                                                                                           \
+				m_class *cls = reinterpret_cast<m_class *>(p_instance);                                                                                                                \
+				ERR_FAIL_COND_V_MSG(!cls->plist_owned.is_empty() || cls->plist != nullptr || cls->plist_size != 0, nullptr, "Internal error, property list was not freed by engine!"); \
+				cls->_get_property_list(&cls->plist_owned);                                                                                                                            \
+				cls->plist = reinterpret_cast<GDExtensionPropertyInfo *>(memalloc(sizeof(GDExtensionPropertyInfo) * cls->plist_owned.size()));                                         \
+				cls->plist_size = 0;                                                                                                                                                   \
+				for (const ::godot::PropertyInfo &E : cls->plist_owned) {                                                                                                              \
+					cls->plist[cls->plist_size].type = static_cast<GDExtensionVariantType>(E.type);                                                                                    \
+					cls->plist[cls->plist_size].name = E.name._native_ptr();                                                                                                           \
+					cls->plist[cls->plist_size].hint = E.hint;                                                                                                                         \
+					cls->plist[cls->plist_size].hint_string = E.hint_string._native_ptr();                                                                                             \
+					cls->plist[cls->plist_size].class_name = E.class_name._native_ptr();                                                                                               \
+					cls->plist[cls->plist_size].usage = E.usage;                                                                                                                       \
+					cls->plist_size++;                                                                                                                                                 \
+				}                                                                                                                                                                      \
+				if (r_count)                                                                                                                                                           \
+					*r_count = cls->plist_size;                                                                                                                                        \
+				return cls->plist;                                                                                                                                                     \
+			}                                                                                                                                                                          \
+			return m_inherits::get_property_list_bind(p_instance, r_count);                                                                                                            \
 		}                                                                                                                                                                              \
-		m_class *cls = reinterpret_cast<m_class *>(p_instance);                                                                                                                        \
-		::godot::List<::godot::PropertyInfo> &plist_cpp = cls->plist_owned;                                                                                                            \
-		ERR_FAIL_COND_V_MSG(!plist_cpp.is_empty(), nullptr, "Internal error, property list was not freed by engine!");                                                                 \
-		cls->_get_property_list(&plist_cpp);                                                                                                                                           \
-		return ::godot::internal::create_c_property_list(plist_cpp, r_count);                                                                                                          \
+		return nullptr;                                                                                                                                                                \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 	static void free_property_list_bind(GDExtensionClassInstancePtr p_instance, const GDExtensionPropertyInfo *p_list) {                                                               \
 		if (p_instance) {                                                                                                                                                              \
 			m_class *cls = reinterpret_cast<m_class *>(p_instance);                                                                                                                    \
+			ERR_FAIL_COND_MSG(cls->plist == nullptr, "Internal error, property list double free!");                                                                                    \
+			memfree(cls->plist);                                                                                                                                                       \
+			cls->plist = nullptr;                                                                                                                                                      \
+			cls->plist_size = 0;                                                                                                                                                       \
 			cls->plist_owned.clear();                                                                                                                                                  \
-			::godot::internal::free_c_property_list(const_cast<GDExtensionPropertyInfo *>(p_list));                                                                                    \
 		}                                                                                                                                                                              \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
@@ -306,21 +268,6 @@ public:
 		return false;                                                                                                                                                                  \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static GDExtensionBool validate_property_bind(GDExtensionClassInstancePtr p_instance, GDExtensionPropertyInfo *p_property) {                                                       \
-		bool ret = false;                                                                                                                                                              \
-		if (p_instance && m_class::_get_validate_property()) {                                                                                                                         \
-			ret = m_inherits::validate_property_bind(p_instance, p_property);                                                                                                          \
-			if (m_class::_get_validate_property() != m_inherits::_get_validate_property()) {                                                                                           \
-				m_class *cls = reinterpret_cast<m_class *>(p_instance);                                                                                                                \
-				::godot::PropertyInfo info(p_property);                                                                                                                                \
-				cls->_validate_property(info);                                                                                                                                         \
-				info._update(p_property);                                                                                                                                              \
-				return true;                                                                                                                                                           \
-			}                                                                                                                                                                          \
-		}                                                                                                                                                                              \
-		return ret;                                                                                                                                                                    \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
 	static void to_string_bind(GDExtensionClassInstancePtr p_instance, GDExtensionBool *r_is_valid, GDExtensionStringPtr r_out) {                                                      \
 		if (p_instance && m_class::_get_to_string()) {                                                                                                                                 \
 			if (m_class::_get_to_string() != m_inherits::_get_to_string()) {                                                                                                           \
@@ -333,133 +280,106 @@ public:
 		}                                                                                                                                                                              \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
-	static void free(void * /*data*/, GDExtensionClassInstancePtr ptr) {                                                                                                               \
+	static void free(void *data, GDExtensionClassInstancePtr ptr) {                                                                                                                    \
 		if (ptr) {                                                                                                                                                                     \
 			m_class *cls = reinterpret_cast<m_class *>(ptr);                                                                                                                           \
 			cls->~m_class();                                                                                                                                                           \
 			::godot::Memory::free_static(cls);                                                                                                                                         \
 		}                                                                                                                                                                              \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static void *_gde_binding_create_callback(void * /*p_token*/, void * /*p_instance*/) {                                                                                             \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static void _gde_binding_free_callback(void * /*p_token*/, void * /*p_instance*/, void * /*p_binding*/) {                                                                          \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static GDExtensionBool _gde_binding_reference_callback(void * /*p_token*/, void * /*p_instance*/, GDExtensionBool /*p_reference*/) {                                               \
-		return true;                                                                                                                                                                   \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = {                                                                                                    \
-		_gde_binding_create_callback,                                                                                                                                                  \
-		_gde_binding_free_callback,                                                                                                                                                    \
-		_gde_binding_reference_callback,                                                                                                                                               \
-	};                                                                                                                                                                                 \
-                                                                                                                                                                                       \
-protected:                                                                                                                                                                             \
-	virtual void _notificationv(int32_t p_what, bool p_reversed = false) override {                                                                                                    \
-		m_class::notification_bind(this, p_what, p_reversed);                                                                                                                          \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-private:
-
-// Don't use this for your classes, use GDCLASS() instead.
-#define GDEXTENSION_CLASS_ALIAS(m_class, m_alias_for, m_inherits) /******************************************************************************************************************/ \
-private:                                                                                                                                                                               \
-	inline static ::godot::internal::EngineClassRegistration<m_class> _gde_engine_class_registration_helper;                                                                           \
-	void operator=(const m_class &p_rval) {}                                                                                                                                           \
-	friend class ::godot::ClassDB;                                                                                                                                                     \
-                                                                                                                                                                                       \
-protected:                                                                                                                                                                             \
-	virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override {                                                                                      \
-		return &_gde_binding_callbacks;                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	m_class(const char *p_godot_class) : m_inherits(p_godot_class) {}                                                                                                                  \
-	m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {}                                                                                                               \
-                                                                                                                                                                                       \
-	static void _bind_methods() {}                                                                                                                                                     \
-                                                                                                                                                                                       \
-	static void (*_get_bind_methods())() {                                                                                                                                             \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static void (Wrapped::*_get_notification())(int) {                                                                                                                                 \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) {                                                                                 \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const {                                                                                      \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static inline bool has_get_property_list() {                                                                                                                                       \
-		return false;                                                                                                                                                                  \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static void (Wrapped::*_get_get_property_list())(List<PropertyInfo> * p_list) const {                                                                                              \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) const {                                                                                      \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) const {                                                                           \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static void (Wrapped::*_get_validate_property())(::godot::PropertyInfo & p_property) const {                                                                                       \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static String (Wrapped::*_get_to_string())() const {                                                                                                                               \
-		return nullptr;                                                                                                                                                                \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-public:                                                                                                                                                                                \
-	typedef m_class self_type;                                                                                                                                                         \
-	typedef m_inherits parent_type;                                                                                                                                                    \
-                                                                                                                                                                                       \
-	static void initialize_class() {}                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static const ::godot::StringName &get_class_static() {                                                                                                                             \
-		static const ::godot::StringName string_name = ::godot::StringName(#m_alias_for);                                                                                              \
-		return string_name;                                                                                                                                                            \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static const ::godot::StringName &get_parent_class_static() {                                                                                                                      \
-		return m_inherits::get_class_static();                                                                                                                                         \
-	}                                                                                                                                                                                  \
-                                                                                                                                                                                       \
-	static void free(void *data, GDExtensionClassInstancePtr ptr) {                                                                                                                    \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 	static void *_gde_binding_create_callback(void *p_token, void *p_instance) {                                                                                                       \
-		/* Do not call memnew here, we don't want the post-initializer to be called */                                                                                                 \
-		return new ("", "") m_class((GodotObject *)p_instance);                                                                                                                        \
+		return nullptr;                                                                                                                                                                \
 	}                                                                                                                                                                                  \
+                                                                                                                                                                                       \
 	static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) {                                                                                         \
-		/* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */                                                                                     \
-		reinterpret_cast<m_class *>(p_binding)->~m_class();                                                                                                                            \
-		Memory::free_static(reinterpret_cast<m_class *>(p_binding));                                                                                                                   \
 	}                                                                                                                                                                                  \
+                                                                                                                                                                                       \
 	static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) {                                                             \
 		return true;                                                                                                                                                                   \
 	}                                                                                                                                                                                  \
+                                                                                                                                                                                       \
 	static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = {                                                                                                    \
 		_gde_binding_create_callback,                                                                                                                                                  \
 		_gde_binding_free_callback,                                                                                                                                                    \
 		_gde_binding_reference_callback,                                                                                                                                               \
-	};                                                                                                                                                                                 \
-	m_class() : m_class(#m_alias_for) {}                                                                                                                                               \
-                                                                                                                                                                                       \
-private:
+	};
+
+// Don't use this for your classes, use GDCLASS() instead.
+#define GDEXTENSION_CLASS_ALIAS(m_class, m_alias_for, m_inherits)                                                          \
+private:                                                                                                                   \
+	void operator=(const m_class &p_rval) {}                                                                               \
+                                                                                                                           \
+protected:                                                                                                                 \
+	virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override {                          \
+		return &_gde_binding_callbacks;                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	m_class(const char *p_godot_class) : m_inherits(p_godot_class) {}                                                      \
+	m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {}                                                   \
+                                                                                                                           \
+	static void (*_get_bind_methods())() {                                                                                 \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static void (Wrapped::*_get_notification())(int) {                                                                     \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) {                     \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const {                          \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static void (Wrapped::*_get_get_property_list())(List<PropertyInfo> * p_list) const {                                  \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) const {                          \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) const {               \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+	static String (Wrapped::*_get_to_string())() const {                                                                   \
+		return nullptr;                                                                                                    \
+	}                                                                                                                      \
+                                                                                                                           \
+public:                                                                                                                    \
+	static void initialize_class() {}                                                                                      \
+                                                                                                                           \
+	static ::godot::StringName &get_class_static() {                                                                       \
+		static ::godot::StringName string_name = ::godot::StringName(#m_alias_for);                                        \
+		return string_name;                                                                                                \
+	}                                                                                                                      \
+                                                                                                                           \
+	static ::godot::StringName &get_parent_class_static() {                                                                \
+		return m_inherits::get_class_static();                                                                             \
+	}                                                                                                                      \
+                                                                                                                           \
+	static void *_gde_binding_create_callback(void *p_token, void *p_instance) {                                           \
+		/* Do not call memnew here, we don't want the post-initializer to be called */                                     \
+		return new ("") m_class((GodotObject *)p_instance);                                                                \
+	}                                                                                                                      \
+	static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) {                             \
+		/* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */                         \
+		reinterpret_cast<m_class *>(p_binding)->~m_class();                                                                \
+		Memory::free_static(reinterpret_cast<m_class *>(p_binding));                                                       \
+	}                                                                                                                      \
+	static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \
+		return true;                                                                                                       \
+	}                                                                                                                      \
+	static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = {                                        \
+		_gde_binding_create_callback,                                                                                      \
+		_gde_binding_free_callback,                                                                                        \
+		_gde_binding_reference_callback,                                                                                   \
+	};                                                                                                                     \
+	m_class() : m_class(#m_alias_for) {}
 
 // Don't use this for your classes, use GDCLASS() instead.
 #define GDEXTENSION_CLASS(m_class, m_inherits) GDEXTENSION_CLASS_ALIAS(m_class, m_class, m_inherits)

include/godot_cpp/core/binder_common.hpp

@@ -83,7 +83,7 @@ namespace godot {
 	};                                                                           \
 	}
 
-template <typename T>
+template <class T>
 struct VariantCaster {
 	static _FORCE_INLINE_ T cast(const Variant &p_variant) {
 		using TStripped = std::remove_pointer_t<T>;
@@ -95,7 +95,7 @@ struct VariantCaster {
 	}
 };
 
-template <typename T>
+template <class T>
 struct VariantCaster<T &> {
 	static _FORCE_INLINE_ T cast(const Variant &p_variant) {
 		using TStripped = std::remove_pointer_t<T>;
@@ -107,7 +107,7 @@ struct VariantCaster<T &> {
 	}
 };
 
-template <typename T>
+template <class T>
 struct VariantCaster<const T &> {
 	static _FORCE_INLINE_ T cast(const Variant &p_variant) {
 		using TStripped = std::remove_pointer_t<T>;
@@ -144,7 +144,7 @@ struct VariantObjectClassChecker<const Ref<T> &> {
 	}
 };
 
-template <typename T>
+template <class T>
 struct VariantCasterAndValidate {
 	static _FORCE_INLINE_ T cast(const Variant **p_args, uint32_t p_arg_idx, GDExtensionCallError &r_error) {
 		GDExtensionVariantType argtype = GDExtensionVariantType(GetTypeInfo<T>::VARIANT_TYPE);
@@ -159,7 +159,7 @@ struct VariantCasterAndValidate {
 	}
 };
 
-template <typename T>
+template <class T>
 struct VariantCasterAndValidate<T &> {
 	static _FORCE_INLINE_ T cast(const Variant **p_args, uint32_t p_arg_idx, GDExtensionCallError &r_error) {
 		GDExtensionVariantType argtype = GDExtensionVariantType(GetTypeInfo<T>::VARIANT_TYPE);
@@ -174,7 +174,7 @@ struct VariantCasterAndValidate<T &> {
 	}
 };
 
-template <typename T>
+template <class T>
 struct VariantCasterAndValidate<const T &> {
 	static _FORCE_INLINE_ T cast(const Variant **p_args, uint32_t p_arg_idx, GDExtensionCallError &r_error) {
 		GDExtensionVariantType argtype = GDExtensionVariantType(GetTypeInfo<T>::VARIANT_TYPE);
@@ -189,47 +189,47 @@ struct VariantCasterAndValidate<const T &> {
 	}
 };
 
-template <typename T, typename... P, size_t... Is>
+template <class T, class... P, size_t... Is>
 void call_with_ptr_args_helper(T *p_instance, void (T::*p_method)(P...), const GDExtensionConstTypePtr *p_args, IndexSequence<Is...>) {
 	(p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...);
 }
 
-template <typename T, typename... P, size_t... Is>
+template <class T, class... P, size_t... Is>
 void call_with_ptr_argsc_helper(T *p_instance, void (T::*p_method)(P...) const, const GDExtensionConstTypePtr *p_args, IndexSequence<Is...>) {
 	(p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...);
 }
 
-template <typename T, typename R, typename... P, size_t... Is>
+template <class T, class R, class... P, size_t... Is>
 void call_with_ptr_args_ret_helper(T *p_instance, R (T::*p_method)(P...), const GDExtensionConstTypePtr *p_args, void *r_ret, IndexSequence<Is...>) {
 	PtrToArg<R>::encode((p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...), r_ret);
 }
 
-template <typename T, typename R, typename... P, size_t... Is>
+template <class T, class R, class... P, size_t... Is>
 void call_with_ptr_args_retc_helper(T *p_instance, R (T::*p_method)(P...) const, const GDExtensionConstTypePtr *p_args, void *r_ret, IndexSequence<Is...>) {
 	PtrToArg<R>::encode((p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...), r_ret);
 }
 
-template <typename T, typename... P>
+template <class T, class... P>
 void call_with_ptr_args(T *p_instance, void (T::*p_method)(P...), const GDExtensionConstTypePtr *p_args, void * /*ret*/) {
 	call_with_ptr_args_helper<T, P...>(p_instance, p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename T, typename... P>
+template <class T, class... P>
 void call_with_ptr_args(T *p_instance, void (T::*p_method)(P...) const, const GDExtensionConstTypePtr *p_args, void * /*ret*/) {
 	call_with_ptr_argsc_helper<T, P...>(p_instance, p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 void call_with_ptr_args(T *p_instance, R (T::*p_method)(P...), const GDExtensionConstTypePtr *p_args, void *r_ret) {
 	call_with_ptr_args_ret_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 void call_with_ptr_args(T *p_instance, R (T::*p_method)(P...) const, const GDExtensionConstTypePtr *p_args, void *r_ret) {
 	call_with_ptr_args_retc_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename T, typename... P, size_t... Is>
+template <class T, class... P, size_t... Is>
 void call_with_variant_args_helper(T *p_instance, void (T::*p_method)(P...), const Variant **p_args, GDExtensionCallError &r_error, IndexSequence<Is...>) {
 	r_error.error = GDEXTENSION_CALL_OK;
 
@@ -241,7 +241,7 @@ void call_with_variant_args_helper(T *p_instance, void (T::*p_method)(P...), con
 	(void)(p_args); // Avoid warning.
 }
 
-template <typename T, typename... P, size_t... Is>
+template <class T, class... P, size_t... Is>
 void call_with_variant_argsc_helper(T *p_instance, void (T::*p_method)(P...) const, const Variant **p_args, GDExtensionCallError &r_error, IndexSequence<Is...>) {
 	r_error.error = GDEXTENSION_CALL_OK;
 
@@ -253,7 +253,7 @@ void call_with_variant_argsc_helper(T *p_instance, void (T::*p_method)(P...) con
 	(void)(p_args); // Avoid warning.
 }
 
-template <typename T, typename R, typename... P, size_t... Is>
+template <class T, class R, class... P, size_t... Is>
 void call_with_variant_args_ret_helper(T *p_instance, R (T::*p_method)(P...), const Variant **p_args, Variant &r_ret, GDExtensionCallError &r_error, IndexSequence<Is...>) {
 	r_error.error = GDEXTENSION_CALL_OK;
 
@@ -264,7 +264,7 @@ void call_with_variant_args_ret_helper(T *p_instance, R (T::*p_method)(P...), co
 #endif
 }
 
-template <typename T, typename R, typename... P, size_t... Is>
+template <class T, class R, class... P, size_t... Is>
 void call_with_variant_args_retc_helper(T *p_instance, R (T::*p_method)(P...) const, const Variant **p_args, Variant &r_ret, GDExtensionCallError &r_error, IndexSequence<Is...>) {
 	r_error.error = GDEXTENSION_CALL_OK;
 
@@ -276,66 +276,12 @@ void call_with_variant_args_retc_helper(T *p_instance, R (T::*p_method)(P...) co
 	(void)p_args;
 }
 
-template <typename T, typename... P>
-void call_with_variant_args(T *p_instance, void (T::*p_method)(P...), const Variant **p_args, int p_argcount, GDExtensionCallError &r_error) {
-#ifdef DEBUG_ENABLED
-	if ((size_t)p_argcount > sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-
-	if ((size_t)p_argcount < sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-#endif
-	call_with_variant_args_helper<T, P...>(p_instance, p_method, p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
-}
-
-template <typename T, typename R, typename... P>
-void call_with_variant_args_ret(T *p_instance, R (T::*p_method)(P...), const Variant **p_args, int p_argcount, Variant &r_ret, GDExtensionCallError &r_error) {
-#ifdef DEBUG_ENABLED
-	if ((size_t)p_argcount > sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-
-	if ((size_t)p_argcount < sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-#endif
-	call_with_variant_args_ret_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
-}
-
-template <typename T, typename R, typename... P>
-void call_with_variant_args_retc(T *p_instance, R (T::*p_method)(P...) const, const Variant **p_args, int p_argcount, Variant &r_ret, GDExtensionCallError &r_error) {
-#ifdef DEBUG_ENABLED
-	if ((size_t)p_argcount > sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-
-	if ((size_t)p_argcount < sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-#endif
-	call_with_variant_args_retc_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
-}
-
-template <typename T, typename... P>
+template <class T, class... P>
 void call_with_variant_args_dv(T *p_instance, void (T::*p_method)(P...), const GDExtensionConstVariantPtr *p_args, int p_argcount, GDExtensionCallError &r_error, const std::vector<Variant> &default_values) {
 #ifdef DEBUG_ENABLED
 	if ((size_t)p_argcount > sizeof...(P)) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -346,7 +292,7 @@ void call_with_variant_args_dv(T *p_instance, void (T::*p_method)(P...), const G
 #ifdef DEBUG_ENABLED
 	if (missing > dvs) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -365,12 +311,12 @@ void call_with_variant_args_dv(T *p_instance, void (T::*p_method)(P...), const G
 	call_with_variant_args_helper(p_instance, p_method, argsp.data(), r_error, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename T, typename... P>
+template <class T, class... P>
 void call_with_variant_argsc_dv(T *p_instance, void (T::*p_method)(P...) const, const GDExtensionConstVariantPtr *p_args, int p_argcount, GDExtensionCallError &r_error, const std::vector<Variant> &default_values) {
 #ifdef DEBUG_ENABLED
 	if ((size_t)p_argcount > sizeof...(P)) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -381,7 +327,7 @@ void call_with_variant_argsc_dv(T *p_instance, void (T::*p_method)(P...) const,
 #ifdef DEBUG_ENABLED
 	if (missing > dvs) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -400,12 +346,12 @@ void call_with_variant_argsc_dv(T *p_instance, void (T::*p_method)(P...) const,
 	call_with_variant_argsc_helper(p_instance, p_method, argsp.data(), r_error, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 void call_with_variant_args_ret_dv(T *p_instance, R (T::*p_method)(P...), const GDExtensionConstVariantPtr *p_args, int p_argcount, Variant &r_ret, GDExtensionCallError &r_error, const std::vector<Variant> &default_values) {
 #ifdef DEBUG_ENABLED
 	if ((size_t)p_argcount > sizeof...(P)) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -416,7 +362,7 @@ void call_with_variant_args_ret_dv(T *p_instance, R (T::*p_method)(P...), const
 #ifdef DEBUG_ENABLED
 	if (missing > dvs) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -435,12 +381,12 @@ void call_with_variant_args_ret_dv(T *p_instance, R (T::*p_method)(P...), const
 	call_with_variant_args_ret_helper(p_instance, p_method, argsp.data(), r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 void call_with_variant_args_retc_dv(T *p_instance, R (T::*p_method)(P...) const, const GDExtensionConstVariantPtr *p_args, int p_argcount, Variant &r_ret, GDExtensionCallError &r_error, const std::vector<Variant> &default_values) {
 #ifdef DEBUG_ENABLED
 	if ((size_t)p_argcount > sizeof...(P)) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -451,7 +397,7 @@ void call_with_variant_args_retc_dv(T *p_instance, R (T::*p_method)(P...) const,
 #ifdef DEBUG_ENABLED
 	if (missing > dvs) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
+		r_error.argument = (int32_t)sizeof...(P);
 		return;
 	}
 #endif
@@ -477,7 +423,7 @@ void call_with_variant_args_retc_dv(T *p_instance, R (T::*p_method)(P...) const,
 #pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
 #endif
 
-template <typename Q>
+template <class Q>
 void call_get_argument_type_helper(int p_arg, int &index, GDExtensionVariantType &type) {
 	if (p_arg == index) {
 		type = GDExtensionVariantType(GetTypeInfo<Q>::VARIANT_TYPE);
@@ -485,7 +431,7 @@ void call_get_argument_type_helper(int p_arg, int &index, GDExtensionVariantType
 	index++;
 }
 
-template <typename... P>
+template <class... P>
 GDExtensionVariantType call_get_argument_type(int p_arg) {
 	GDExtensionVariantType type = GDEXTENSION_VARIANT_TYPE_NIL;
 	int index = 0;
@@ -497,7 +443,7 @@ GDExtensionVariantType call_get_argument_type(int p_arg) {
 	return type;
 }
 
-template <typename Q>
+template <class Q>
 void call_get_argument_type_info_helper(int p_arg, int &index, PropertyInfo &info) {
 	if (p_arg == index) {
 		info = GetTypeInfo<Q>::get_class_info();
@@ -505,7 +451,7 @@ void call_get_argument_type_info_helper(int p_arg, int &index, PropertyInfo &inf
 	index++;
 }
 
-template <typename... P>
+template <class... P>
 void call_get_argument_type_info(int p_arg, PropertyInfo &info) {
 	int index = 0;
 	// I think rocket science is simpler than modern C++.
@@ -515,7 +461,7 @@ void call_get_argument_type_info(int p_arg, PropertyInfo &info) {
 	(void)index; // Suppress GCC warning.
 }
 
-template <typename Q>
+template <class Q>
 void call_get_argument_metadata_helper(int p_arg, int &index, GDExtensionClassMethodArgumentMetadata &md) {
 	if (p_arg == index) {
 		md = GetTypeInfo<Q>::METADATA;
@@ -523,7 +469,7 @@ void call_get_argument_metadata_helper(int p_arg, int &index, GDExtensionClassMe
 	index++;
 }
 
-template <typename... P>
+template <class... P>
 GDExtensionClassMethodArgumentMetadata call_get_argument_metadata(int p_arg) {
 	GDExtensionClassMethodArgumentMetadata md = GDEXTENSION_METHOD_ARGUMENT_METADATA_NONE;
 
@@ -536,7 +482,7 @@ GDExtensionClassMethodArgumentMetadata call_get_argument_metadata(int p_arg) {
 	return md;
 }
 
-template <typename... P, size_t... Is>
+template <class... P, size_t... Is>
 void call_with_variant_args_static(void (*p_method)(P...), const Variant **p_args, GDExtensionCallError &r_error, IndexSequence<Is...>) {
 	r_error.error = GDEXTENSION_CALL_OK;
 
@@ -547,12 +493,12 @@ void call_with_variant_args_static(void (*p_method)(P...), const Variant **p_arg
 #endif
 }
 
-template <typename... P>
+template <class... P>
 void call_with_variant_args_static_dv(void (*p_method)(P...), const GDExtensionConstVariantPtr *p_args, int p_argcount, GDExtensionCallError &r_error, const std::vector<Variant> &default_values) {
 #ifdef DEBUG_ENABLED
 	if ((size_t)p_argcount > sizeof...(P)) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = sizeof...(P);
+		r_error.argument = sizeof...(P);
 		return;
 	}
 #endif
@@ -563,7 +509,7 @@ void call_with_variant_args_static_dv(void (*p_method)(P...), const GDExtensionC
 #ifdef DEBUG_ENABLED
 	if (missing > dvs) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = sizeof...(P);
+		r_error.argument = sizeof...(P);
 		return;
 	}
 #endif
@@ -582,53 +528,17 @@ void call_with_variant_args_static_dv(void (*p_method)(P...), const GDExtensionC
 	call_with_variant_args_static(p_method, argsp.data(), r_error, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename... P, size_t... Is>
+template <class... P, size_t... Is>
 void call_with_ptr_args_static_method_helper(void (*p_method)(P...), const GDExtensionConstTypePtr *p_args, IndexSequence<Is...>) {
 	p_method(PtrToArg<P>::convert(p_args[Is])...);
 }
 
-template <typename... P>
+template <class... P>
 void call_with_ptr_args_static_method(void (*p_method)(P...), const GDExtensionConstTypePtr *p_args) {
 	call_with_ptr_args_static_method_helper<P...>(p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename R, typename... P>
-void call_with_variant_args_static_ret(R (*p_method)(P...), const Variant **p_args, int p_argcount, Variant &r_ret, GDExtensionCallError &r_error) {
-#ifdef DEBUG_ENABLED
-	if ((size_t)p_argcount > sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-
-	if ((size_t)p_argcount < sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-#endif
-	call_with_variant_args_static_ret<R, P...>(p_method, p_args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
-}
-
-template <typename... P>
-void call_with_variant_args_static_ret(void (*p_method)(P...), const Variant **p_args, int p_argcount, Variant &r_ret, GDExtensionCallError &r_error) {
-#ifdef DEBUG_ENABLED
-	if ((size_t)p_argcount > sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-
-	if ((size_t)p_argcount < sizeof...(P)) {
-		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = (int32_t)sizeof...(P);
-		return;
-	}
-#endif
-	call_with_variant_args_static<P...>(p_method, p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
-}
-
-template <typename R, typename... P, size_t... Is>
+template <class R, class... P, size_t... Is>
 void call_with_variant_args_static_ret(R (*p_method)(P...), const Variant **p_args, Variant &r_ret, GDExtensionCallError &r_error, IndexSequence<Is...>) {
 	r_error.error = GDEXTENSION_CALL_OK;
 
@@ -639,12 +549,12 @@ void call_with_variant_args_static_ret(R (*p_method)(P...), const Variant **p_ar
 #endif
 }
 
-template <typename R, typename... P>
+template <class R, class... P>
 void call_with_variant_args_static_ret_dv(R (*p_method)(P...), const GDExtensionConstVariantPtr *p_args, int p_argcount, Variant &r_ret, GDExtensionCallError &r_error, const std::vector<Variant> &default_values) {
 #ifdef DEBUG_ENABLED
 	if ((size_t)p_argcount > sizeof...(P)) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.expected = sizeof...(P);
+		r_error.argument = sizeof...(P);
 		return;
 	}
 #endif
@@ -655,7 +565,7 @@ void call_with_variant_args_static_ret_dv(R (*p_method)(P...), const GDExtension
 #ifdef DEBUG_ENABLED
 	if (missing > dvs) {
 		r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.expected = sizeof...(P);
+		r_error.argument = sizeof...(P);
 		return;
 	}
 #endif
@@ -674,12 +584,12 @@ void call_with_variant_args_static_ret_dv(R (*p_method)(P...), const GDExtension
 	call_with_variant_args_static_ret(p_method, argsp.data(), r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
 }
 
-template <typename R, typename... P, size_t... Is>
+template <class R, class... P, size_t... Is>
 void call_with_ptr_args_static_method_ret_helper(R (*p_method)(P...), const GDExtensionConstTypePtr *p_args, void *r_ret, IndexSequence<Is...>) {
 	PtrToArg<R>::encode(p_method(PtrToArg<P>::convert(p_args[Is])...), r_ret);
 }
 
-template <typename R, typename... P>
+template <class R, class... P>
 void call_with_ptr_args_static_method_ret(R (*p_method)(P...), const GDExtensionConstTypePtr *p_args, void *r_ret) {
 	call_with_ptr_args_static_method_ret_helper<R, P...>(p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
 }

include/godot_cpp/core/builtin_ptrcall.hpp

@@ -32,7 +32,6 @@
 #define GODOT_BUILTIN_PTRCALL_HPP
 
 #include <gdextension_interface.h>
-#include <godot_cpp/core/object.hpp>
 
 #include <array>
 
@@ -40,24 +39,13 @@ namespace godot {
 
 namespace internal {
 
-template <typename O, typename... Args>
-O *_call_builtin_method_ptr_ret_obj(const GDExtensionPtrBuiltInMethod method, GDExtensionTypePtr base, const Args &...args) {
-	GodotObject *ret = nullptr;
-	std::array<GDExtensionConstTypePtr, sizeof...(Args)> call_args = { { (GDExtensionConstTypePtr)args... } };
-	method(base, call_args.data(), &ret, sizeof...(Args));
-	if (ret == nullptr) {
-		return nullptr;
-	}
-	return reinterpret_cast<O *>(internal::get_object_instance_binding(ret));
-}
-
-template <typename... Args>
+template <class... Args>
 void _call_builtin_constructor(const GDExtensionPtrConstructor constructor, GDExtensionTypePtr base, Args... args) {
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> call_args = { { (GDExtensionConstTypePtr)args... } };
 	constructor(base, call_args.data());
 }
 
-template <typename T, typename... Args>
+template <class T, class... Args>
 T _call_builtin_method_ptr_ret(const GDExtensionPtrBuiltInMethod method, GDExtensionTypePtr base, Args... args) {
 	T ret;
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> call_args = { { (GDExtensionConstTypePtr)args... } };
@@ -65,20 +53,20 @@ T _call_builtin_method_ptr_ret(const GDExtensionPtrBuiltInMethod method, GDExten
 	return ret;
 }
 
-template <typename... Args>
+template <class... Args>
 void _call_builtin_method_ptr_no_ret(const GDExtensionPtrBuiltInMethod method, GDExtensionTypePtr base, Args... args) {
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> call_args = { { (GDExtensionConstTypePtr)args... } };
 	method(base, call_args.data(), nullptr, sizeof...(Args));
 }
 
-template <typename T>
+template <class T>
 T _call_builtin_operator_ptr(const GDExtensionPtrOperatorEvaluator op, GDExtensionConstTypePtr left, GDExtensionConstTypePtr right) {
 	T ret;
 	op(left, right, &ret);
 	return ret;
 }
 
-template <typename T>
+template <class T>
 T _call_builtin_ptr_getter(const GDExtensionPtrGetter getter, GDExtensionConstTypePtr base) {
 	T ret;
 	getter(base, &ret);

include/godot_cpp/core/class_db.hpp

@@ -40,12 +40,7 @@
 
 #include <godot_cpp/classes/class_db_singleton.hpp>
 
-// Makes callable_mp readily available in all classes connecting signals.
-// Needs to come after method_bind and object have been included.
-#include <godot_cpp/variant/callable_method_pointer.hpp>
-
 #include <list>
-#include <mutex>
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -86,6 +81,15 @@ class ClassDB {
 	friend class godot::GDExtensionBinding;
 
 public:
+	struct PropertySetGet {
+		int index;
+		StringName setter;
+		StringName getter;
+		MethodBind *_setptr;
+		MethodBind *_getptr;
+		Variant::Type type;
+	};
+
 	struct ClassInfo {
 		StringName name;
 		StringName parent_name;
@@ -105,77 +109,29 @@ private:
 	static std::unordered_map<StringName, const GDExtensionInstanceBindingCallbacks *> instance_binding_callbacks;
 	// Used to remember the custom class registration order.
 	static std::vector<StringName> class_register_order;
-	static std::unordered_map<StringName, Object *> engine_singletons;
-	static std::mutex engine_singletons_mutex;
 
 	static MethodBind *bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const MethodDefinition &method_name, const void **p_defs, int p_defcount);
 	static void initialize_class(const ClassInfo &cl);
 	static void bind_method_godot(const StringName &p_class_name, MethodBind *p_method);
 
-	template <typename T, bool is_abstract>
-	static void _register_class(bool p_virtual = false, bool p_exposed = true);
-
-	template <typename T>
-	static GDExtensionObjectPtr _create_instance_func(void *data) {
-		if constexpr (!std::is_abstract_v<T>) {
-			T *new_object = memnew(T);
-			return new_object->_owner;
-		} else {
-			return nullptr;
-		}
-	}
-
-	template <typename T>
-	static GDExtensionClassInstancePtr _recreate_instance_func(void *data, GDExtensionObjectPtr obj) {
-		if constexpr (!std::is_abstract_v<T>) {
-#ifdef HOT_RELOAD_ENABLED
-			T *new_instance = (T *)memalloc(sizeof(T));
-			Wrapped::RecreateInstance recreate_data = { new_instance, obj, Wrapped::recreate_instance };
-			Wrapped::recreate_instance = &recreate_data;
-			memnew_placement(new_instance, T);
-			return new_instance;
-#else
-			return nullptr;
-#endif
-		} else {
-			return nullptr;
-		}
-	}
+	template <class T, bool is_abstract>
+	static void _register_class(bool p_virtual = false);
 
 public:
-	template <typename T>
+	template <class T>
 	static void register_class(bool p_virtual = false);
-	template <typename T>
+	template <class T>
 	static void register_abstract_class();
-	template <typename T>
-	static void register_internal_class();
+	template <class T>
+	static void register_engine_class();
 
-	_FORCE_INLINE_ static void _register_engine_class(const StringName &p_name, const GDExtensionInstanceBindingCallbacks *p_callbacks) {
-		instance_binding_callbacks[p_name] = p_callbacks;
-	}
-
-	static void _register_engine_singleton(const StringName &p_class_name, Object *p_singleton) {
-		std::lock_guard<std::mutex> lock(engine_singletons_mutex);
-		std::unordered_map<StringName, Object *>::const_iterator i = engine_singletons.find(p_class_name);
-		if (i != engine_singletons.end()) {
-			ERR_FAIL_COND((*i).second != p_singleton);
-			return;
-		}
-		engine_singletons[p_class_name] = p_singleton;
-	}
-
-	static void _unregister_engine_singleton(const StringName &p_class_name) {
-		std::lock_guard<std::mutex> lock(engine_singletons_mutex);
-		engine_singletons.erase(p_class_name);
-	}
-
-	template <typename N, typename M, typename... VarArgs>
+	template <class N, class M, typename... VarArgs>
 	static MethodBind *bind_method(N p_method_name, M p_method, VarArgs... p_args);
 
-	template <typename N, typename M, typename... VarArgs>
+	template <class N, class M, typename... VarArgs>
 	static MethodBind *bind_static_method(StringName p_class, N p_method_name, M p_method, VarArgs... p_args);
 
-	template <typename M>
+	template <class M>
 	static MethodBind *bind_vararg_method(uint32_t p_flags, StringName p_name, M p_method, const MethodInfo &p_info = MethodInfo(), const std::vector<Variant> &p_default_args = std::vector<Variant>{}, bool p_return_nil_is_variant = true);
 
 	static void add_property_group(const StringName &p_class, const String &p_name, const String &p_prefix);
@@ -197,27 +153,24 @@ public:
 };
 
 #define BIND_CONSTANT(m_constant) \
-	::godot::ClassDB::bind_integer_constant(get_class_static(), "", #m_constant, m_constant);
+	godot::ClassDB::bind_integer_constant(get_class_static(), "", #m_constant, m_constant);
 
 #define BIND_ENUM_CONSTANT(m_constant) \
-	::godot::ClassDB::bind_integer_constant(get_class_static(), ::godot::_gde_constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
+	godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
 
 #define BIND_BITFIELD_FLAG(m_constant) \
-	::godot::ClassDB::bind_integer_constant(get_class_static(), ::godot::_gde_constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true);
+	godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true);
 
 #define BIND_VIRTUAL_METHOD(m_class, m_method)                                                                                                \
 	{                                                                                                                                         \
 		auto _call##m_method = [](GDExtensionObjectPtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr p_ret) -> void { \
 			call_with_ptr_args(reinterpret_cast<m_class *>(p_instance), &m_class::m_method, p_args, p_ret);                                   \
 		};                                                                                                                                    \
-		::godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, _call##m_method);                                       \
+		godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, _call##m_method);                                         \
 	}
 
-template <typename T, bool is_abstract>
-void ClassDB::_register_class(bool p_virtual, bool p_exposed) {
-	static_assert(TypesAreSame<typename T::self_type, T>::value, "Class not declared properly, please use GDCLASS.");
-	static_assert(!FunctionsAreSame<T::self_type::_bind_methods, T::parent_type::_bind_methods>::value, "Class must declare 'static void _bind_methods'.");
-	static_assert(!std::is_abstract_v<T> || is_abstract, "Class is abstract, please use GDREGISTER_ABSTRACT_CLASS.");
+template <class T, bool is_abstract>
+void ClassDB::_register_class(bool p_virtual) {
 	instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks;
 
 	// Register this class within our plugin
@@ -234,32 +187,27 @@ void ClassDB::_register_class(bool p_virtual, bool p_exposed) {
 	class_register_order.push_back(cl.name);
 
 	// Register this class with Godot
-	GDExtensionClassCreationInfo2 class_info = {
+	GDExtensionClassCreationInfo class_info = {
 		p_virtual, // GDExtensionBool is_virtual;
 		is_abstract, // GDExtensionBool is_abstract;
-		p_exposed, // GDExtensionBool is_exposed;
 		T::set_bind, // GDExtensionClassSet set_func;
 		T::get_bind, // GDExtensionClassGet get_func;
-		T::has_get_property_list() ? T::get_property_list_bind : nullptr, // GDExtensionClassGetPropertyList get_property_list_func;
+		T::get_property_list_bind, // GDExtensionClassGetPropertyList get_property_list_func;
 		T::free_property_list_bind, // GDExtensionClassFreePropertyList free_property_list_func;
 		T::property_can_revert_bind, // GDExtensionClassPropertyCanRevert property_can_revert_func;
 		T::property_get_revert_bind, // GDExtensionClassPropertyGetRevert property_get_revert_func;
-		T::validate_property_bind, // GDExtensionClassValidateProperty validate_property_func;
-		T::notification_bind, // GDExtensionClassNotification2 notification_func;
+		T::notification_bind, // GDExtensionClassNotification notification_func;
 		T::to_string_bind, // GDExtensionClassToString to_string_func;
 		nullptr, // GDExtensionClassReference reference_func;
 		nullptr, // GDExtensionClassUnreference unreference_func;
-		&_create_instance_func<T>, // GDExtensionClassCreateInstance create_instance_func; /* this one is mandatory */
+		T::create, // GDExtensionClassCreateInstance create_instance_func; /* this one is mandatory */
 		T::free, // GDExtensionClassFreeInstance free_instance_func; /* this one is mandatory */
-		&_recreate_instance_func<T>, // GDExtensionClassRecreateInstance recreate_instance_func;
 		&ClassDB::get_virtual_func, // GDExtensionClassGetVirtual get_virtual_func;
-		nullptr, // GDExtensionClassGetVirtualCallData get_virtual_call_data_func;
-		nullptr, // GDExtensionClassCallVirtualWithData call_virtual_func;
 		nullptr, // GDExtensionClassGetRID get_rid;
 		(void *)&T::get_class_static(), // void *class_userdata;
 	};
 
-	internal::gdextension_interface_classdb_register_extension_class2(internal::library, cl.name._native_ptr(), cl.parent_name._native_ptr(), &class_info);
+	internal::gdextension_interface_classdb_register_extension_class(internal::library, cl.name._native_ptr(), cl.parent_name._native_ptr(), &class_info);
 
 	// call bind_methods etc. to register all members of the class
 	T::initialize_class();
@@ -268,22 +216,22 @@ void ClassDB::_register_class(bool p_virtual, bool p_exposed) {
 	initialize_class(classes[cl.name]);
 }
 
-template <typename T>
+template <class T>
 void ClassDB::register_class(bool p_virtual) {
 	ClassDB::_register_class<T, false>(p_virtual);
 }
 
-template <typename T>
+template <class T>
 void ClassDB::register_abstract_class() {
 	ClassDB::_register_class<T, true>();
 }
 
-template <typename T>
-void ClassDB::register_internal_class() {
-	ClassDB::_register_class<T, false>(false, false);
+template <class T>
+void ClassDB::register_engine_class() {
+	instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks;
 }
 
-template <typename N, typename M, typename... VarArgs>
+template <class N, class M, typename... VarArgs>
 MethodBind *ClassDB::bind_method(N p_method_name, M p_method, VarArgs... p_args) {
 	Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
 	const Variant *argptrs[sizeof...(p_args) + 1];
@@ -294,7 +242,7 @@ MethodBind *ClassDB::bind_method(N p_method_name, M p_method, VarArgs... p_args)
 	return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const void **)argptrs, sizeof...(p_args));
 }
 
-template <typename N, typename M, typename... VarArgs>
+template <class N, class M, typename... VarArgs>
 MethodBind *ClassDB::bind_static_method(StringName p_class, N p_method_name, M p_method, VarArgs... p_args) {
 	Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
 	const Variant *argptrs[sizeof...(p_args) + 1];
@@ -306,10 +254,10 @@ MethodBind *ClassDB::bind_static_method(StringName p_class, N p_method_name, M p
 	return bind_methodfi(0, bind, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const void **)argptrs, sizeof...(p_args));
 }
 
-template <typename M>
+template <class M>
 MethodBind *ClassDB::bind_vararg_method(uint32_t p_flags, StringName p_name, M p_method, const MethodInfo &p_info, const std::vector<Variant> &p_default_args, bool p_return_nil_is_variant) {
 	MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant);
-	ERR_FAIL_NULL_V(bind, nullptr);
+	ERR_FAIL_COND_V(!bind, nullptr);
 
 	bind->set_name(p_name);
 	bind->set_default_arguments(p_default_args);
@@ -338,13 +286,10 @@ MethodBind *ClassDB::bind_vararg_method(uint32_t p_flags, StringName p_name, M p
 	return bind;
 }
 
-#define GDREGISTER_CLASS(m_class) ::godot::ClassDB::register_class<m_class>();
-#define GDREGISTER_VIRTUAL_CLASS(m_class) ::godot::ClassDB::register_class<m_class>(true);
-#define GDREGISTER_ABSTRACT_CLASS(m_class) ::godot::ClassDB::register_abstract_class<m_class>();
-#define GDREGISTER_INTERNAL_CLASS(m_class) ::godot::ClassDB::register_internal_class<m_class>();
+#define GDREGISTER_CLASS(m_class) ClassDB::register_class<m_class>();
+#define GDREGISTER_VIRTUAL_CLASS(m_class) ClassDB::register_class<m_class>(true);
+#define GDREGISTER_ABSTRACT_CLASS(m_class) ClassDB::register_abstract_class<m_class>();
 
 } // namespace godot
 
-CLASSDB_SINGLETON_VARIANT_CAST;
-
 #endif // GODOT_CLASS_DB_HPP

include/godot_cpp/core/defs.hpp

@@ -35,8 +35,6 @@
 #include <cstdint>
 #include <cstring>
 
-namespace godot {
-
 #if !defined(GDE_EXPORT)
 #if defined(_WIN32)
 #define GDE_EXPORT __declspec(dllexport)
@@ -110,7 +108,7 @@ typedef float real_t;
 // Generic swap template.
 #ifndef SWAP
 #define SWAP(m_x, m_y) __swap_tmpl((m_x), (m_y))
-template <typename T>
+template <class T>
 inline void __swap_tmpl(T &x, T &y) {
 	T aux = x;
 	x = y;
@@ -129,10 +127,4 @@ struct BuildIndexSequence : BuildIndexSequence<N - 1, N - 1, Is...> {};
 template <size_t... Is>
 struct BuildIndexSequence<0, Is...> : IndexSequence<Is...> {};
 
-} //namespace godot
-
-// To maintain compatibility an alias is defined outside the namespace.
-// Consider it deprecated.
-using real_t = godot::real_t;
-
 #endif // GODOT_DEFS_HPP

include/godot_cpp/core/engine_ptrcall.hpp

@@ -43,7 +43,7 @@ namespace godot {
 
 namespace internal {
 
-template <typename O, typename... Args>
+template <class O, class... Args>
 O *_call_native_mb_ret_obj(const GDExtensionMethodBindPtr mb, void *instance, const Args &...args) {
 	GodotObject *ret = nullptr;
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> mb_args = { { (GDExtensionConstTypePtr)args... } };
@@ -54,7 +54,7 @@ O *_call_native_mb_ret_obj(const GDExtensionMethodBindPtr mb, void *instance, co
 	return reinterpret_cast<O *>(internal::get_object_instance_binding(ret));
 }
 
-template <typename R, typename... Args>
+template <class R, class... Args>
 R _call_native_mb_ret(const GDExtensionMethodBindPtr mb, void *instance, const Args &...args) {
 	R ret;
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> mb_args = { { (GDExtensionConstTypePtr)args... } };
@@ -62,13 +62,13 @@ R _call_native_mb_ret(const GDExtensionMethodBindPtr mb, void *instance, const A
 	return ret;
 }
 
-template <typename... Args>
+template <class... Args>
 void _call_native_mb_no_ret(const GDExtensionMethodBindPtr mb, void *instance, const Args &...args) {
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> mb_args = { { (GDExtensionConstTypePtr)args... } };
 	internal::gdextension_interface_object_method_bind_ptrcall(mb, instance, mb_args.data(), nullptr);
 }
 
-template <typename R, typename... Args>
+template <class R, class... Args>
 R _call_utility_ret(GDExtensionPtrUtilityFunction func, const Args &...args) {
 	R ret;
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> mb_args = { { (GDExtensionConstTypePtr)args... } };
@@ -76,15 +76,15 @@ R _call_utility_ret(GDExtensionPtrUtilityFunction func, const Args &...args) {
 	return ret;
 }
 
-template <typename... Args>
-Object *_call_utility_ret_obj(const GDExtensionPtrUtilityFunction func, const Args &...args) {
+template <class... Args>
+Object *_call_utility_ret_obj(const GDExtensionPtrUtilityFunction func, void *instance, const Args &...args) {
 	GodotObject *ret = nullptr;
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> mb_args = { { (GDExtensionConstTypePtr)args... } };
 	func(&ret, mb_args.data(), mb_args.size());
 	return (Object *)internal::get_object_instance_binding(ret);
 }
 
-template <typename... Args>
+template <class... Args>
 void _call_utility_no_ret(const GDExtensionPtrUtilityFunction func, const Args &...args) {
 	std::array<GDExtensionConstTypePtr, sizeof...(Args)> mb_args = { { (GDExtensionConstTypePtr)args... } };
 	func(nullptr, mb_args.data(), mb_args.size());

include/godot_cpp/core/math.hpp

@@ -84,7 +84,7 @@ constexpr auto CLAMP(const T m_a, const T2 m_min, const T3 m_max) {
 // Generic swap template.
 #ifndef SWAP
 #define SWAP(m_x, m_y) __swap_tmpl((m_x), (m_y))
-template <typename T>
+template <class T>
 inline void __swap_tmpl(T &x, T &y) {
 	T aux = x;
 	x = y;
@@ -138,7 +138,7 @@ static inline int get_shift_from_power_of_2(unsigned int p_bits) {
 	return -1;
 }
 
-template <typename T>
+template <class T>
 static _FORCE_INLINE_ T nearest_power_of_2_templated(T x) {
 	--x;
 
@@ -613,14 +613,6 @@ inline bool is_inf(double p_val) {
 	return std::isinf(p_val);
 }
 
-inline bool is_finite(float p_val) {
-	return std::isfinite(p_val);
-}
-
-inline bool is_finite(double p_val) {
-	return std::isfinite(p_val);
-}
-
 inline bool is_equal_approx(float a, float b) {
 	// Check for exact equality first, required to handle "infinity" values.
 	if (a == b) {

include/godot_cpp/core/memory.hpp

@@ -40,21 +40,24 @@
 
 #include <type_traits>
 
-// p_dummy argument is added to avoid conflicts with the engine functions when both engine and GDExtension are built as a static library on iOS.
-void *operator new(size_t p_size, const char *p_dummy, const char *p_description); ///< operator new that takes a description and uses MemoryStaticPool
-void *operator new(size_t p_size, const char *p_dummy, void *(*p_allocfunc)(size_t p_size)); ///< operator new that takes a description and uses MemoryStaticPool
-void *operator new(size_t p_size, const char *p_dummy, void *p_pointer, size_t check, const char *p_description); ///< operator new that takes a description and uses a pointer to the preallocated memory
+#ifndef PAD_ALIGN
+#define PAD_ALIGN 16 //must always be greater than this at much
+#endif
 
-_ALWAYS_INLINE_ void *operator new(size_t p_size, const char *p_dummy, void *p_pointer, size_t check, const char *p_description) {
+void *operator new(size_t p_size, const char *p_description); ///< operator new that takes a description and uses MemoryStaticPool
+void *operator new(size_t p_size, void *(*p_allocfunc)(size_t p_size)); ///< operator new that takes a description and uses MemoryStaticPool
+void *operator new(size_t p_size, void *p_pointer, size_t check, const char *p_description); ///< operator new that takes a description and uses a pointer to the preallocated memory
+
+_ALWAYS_INLINE_ void *operator new(size_t p_size, void *p_pointer, size_t check, const char *p_description) {
 	return p_pointer;
 }
 
 #ifdef _MSC_VER
 // When compiling with VC++ 2017, the above declarations of placement new generate many irrelevant warnings (C4291).
 // The purpose of the following definitions is to muffle these warnings, not to provide a usable implementation of placement delete.
-void operator delete(void *p_mem, const char *p_dummy, const char *p_description);
-void operator delete(void *p_mem, const char *p_dummy, void *(*p_allocfunc)(size_t p_size));
-void operator delete(void *p_mem, const char *p_dummy, void *p_pointer, size_t check, const char *p_description);
+void operator delete(void *p_mem, const char *p_description);
+void operator delete(void *p_mem, void *(*p_allocfunc)(size_t p_size));
+void operator delete(void *p_mem, void *p_pointer, size_t check, const char *p_description);
 #endif
 
 namespace godot {
@@ -65,18 +68,6 @@ class Memory {
 	Memory();
 
 public:
-	// Alignment:  ↓ max_align_t        ↓ uint64_t          ↓ max_align_t
-	//             ┌─────────────────┬──┬────────────────┬──┬───────────...
-	//             │ uint64_t        │░░│ uint64_t       │░░│ T[]
-	//             │ alloc size      │░░│ element count  │░░│ data
-	//             └─────────────────┴──┴────────────────┴──┴───────────...
-	// Offset:     ↑ SIZE_OFFSET        ↑ ELEMENT_OFFSET    ↑ DATA_OFFSET
-	// Note: "alloc size" is used and set by the engine and is never accessed or changed for the extension.
-
-	static constexpr size_t SIZE_OFFSET = 0;
-	static constexpr size_t ELEMENT_OFFSET = ((SIZE_OFFSET + sizeof(uint64_t)) % alignof(uint64_t) == 0) ? (SIZE_OFFSET + sizeof(uint64_t)) : ((SIZE_OFFSET + sizeof(uint64_t)) + alignof(uint64_t) - ((SIZE_OFFSET + sizeof(uint64_t)) % alignof(uint64_t)));
-	static constexpr size_t DATA_OFFSET = ((ELEMENT_OFFSET + sizeof(uint64_t)) % alignof(max_align_t) == 0) ? (ELEMENT_OFFSET + sizeof(uint64_t)) : ((ELEMENT_OFFSET + sizeof(uint64_t)) + alignof(max_align_t) - ((ELEMENT_OFFSET + sizeof(uint64_t)) % alignof(max_align_t)));
-
 	static void *alloc_static(size_t p_bytes, bool p_pad_align = false);
 	static void *realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align = false);
 	static void free_static(void *p_ptr, bool p_pad_align = false);
@@ -84,7 +75,7 @@ public:
 
 _ALWAYS_INLINE_ void postinitialize_handler(void *) {}
 
-template <typename T>
+template <class T>
 _ALWAYS_INLINE_ T *_post_initialize(T *p_obj) {
 	postinitialize_handler(p_obj);
 	return p_obj;
@@ -94,34 +85,34 @@ _ALWAYS_INLINE_ T *_post_initialize(T *p_obj) {
 #define memrealloc(m_mem, m_size) ::godot::Memory::realloc_static(m_mem, m_size)
 #define memfree(m_mem) ::godot::Memory::free_static(m_mem)
 
-#define memnew(m_class) ::godot::_post_initialize(new ("", "") m_class)
+#define memnew(m_class) ::godot::_post_initialize(new ("") m_class)
 
-#define memnew_allocator(m_class, m_allocator) ::godot::_post_initialize(new ("", m_allocator::alloc) m_class)
-#define memnew_placement(m_placement, m_class) ::godot::_post_initialize(new ("", m_placement, sizeof(m_class), "") m_class)
+#define memnew_allocator(m_class, m_allocator) ::godot::_post_initialize(new (m_allocator::alloc) m_class)
+#define memnew_placement(m_placement, m_class) ::godot::_post_initialize(new (m_placement, sizeof(m_class), "") m_class)
 
 // Generic comparator used in Map, List, etc.
-template <typename T>
+template <class T>
 struct Comparator {
 	_ALWAYS_INLINE_ bool operator()(const T &p_a, const T &p_b) const { return (p_a < p_b); }
 };
 
-template <typename T>
+template <class T>
 void memdelete(T *p_class, typename std::enable_if<!std::is_base_of_v<godot::Wrapped, T>>::type * = nullptr) {
-	if constexpr (!std::is_trivially_destructible_v<T>) {
+	if (!std::is_trivially_destructible<T>::value) {
 		p_class->~T();
 	}
 
 	Memory::free_static(p_class);
 }
 
-template <typename T, std::enable_if_t<std::is_base_of_v<godot::Wrapped, T>, bool> = true>
+template <class T, std::enable_if_t<std::is_base_of_v<godot::Wrapped, T>, bool> = true>
 void memdelete(T *p_class) {
 	godot::internal::gdextension_interface_object_destroy(p_class->_owner);
 }
 
-template <typename T, typename A>
+template <class T, class A>
 void memdelete_allocator(T *p_class) {
-	if constexpr (!std::is_trivially_destructible_v<T>) {
+	if (!std::is_trivially_destructible<T>::value) {
 		p_class->~T();
 	}
 
@@ -134,20 +125,16 @@ public:
 	_ALWAYS_INLINE_ static void free(void *p_ptr) { Memory::free_static(p_ptr); }
 };
 
-template <typename T>
+template <class T>
 class DefaultTypedAllocator {
 public:
-	template <typename... Args>
+	template <class... Args>
 	_ALWAYS_INLINE_ T *new_allocation(const Args &&...p_args) { return memnew(T(p_args...)); }
 	_ALWAYS_INLINE_ void delete_allocation(T *p_allocation) { memdelete(p_allocation); }
 };
 
 #define memnew_arr(m_class, m_count) memnew_arr_template<m_class>(m_count)
 
-_FORCE_INLINE_ uint64_t *_get_element_count_ptr(uint8_t *p_ptr) {
-	return (uint64_t *)(p_ptr - Memory::DATA_OFFSET + Memory::ELEMENT_OFFSET);
-}
-
 template <typename T>
 T *memnew_arr_template(size_t p_elements, const char *p_descr = "") {
 	if (p_elements == 0) {
@@ -157,39 +144,29 @@ T *memnew_arr_template(size_t p_elements, const char *p_descr = "") {
 	same strategy used by std::vector, and the Vector class, so it should be safe.*/
 
 	size_t len = sizeof(T) * p_elements;
-	uint8_t *mem = (uint8_t *)Memory::alloc_static(len, true);
+	uint64_t *mem = (uint64_t *)Memory::alloc_static(len, true);
 	T *failptr = nullptr; // Get rid of a warning.
-	ERR_FAIL_NULL_V(mem, failptr);
+	ERR_FAIL_COND_V(!mem, failptr);
+	*(mem - 1) = p_elements;
 
-	uint64_t *_elem_count_ptr = _get_element_count_ptr(mem);
-	*(_elem_count_ptr) = p_elements;
-
-	if constexpr (!std::is_trivially_destructible_v<T>) {
+	if (!std::is_trivially_destructible<T>::value) {
 		T *elems = (T *)mem;
 
 		/* call operator new */
 		for (size_t i = 0; i < p_elements; i++) {
-			new ("", &elems[i], sizeof(T), p_descr) T;
+			new (&elems[i], sizeof(T), p_descr) T;
 		}
 	}
 
 	return (T *)mem;
 }
 
-template <typename T>
-size_t memarr_len(const T *p_class) {
-	uint8_t *ptr = (uint8_t *)p_class;
-	uint64_t *_elem_count_ptr = _get_element_count_ptr(ptr);
-	return *(_elem_count_ptr);
-}
-
 template <typename T>
 void memdelete_arr(T *p_class) {
-	uint8_t *ptr = (uint8_t *)p_class;
+	uint64_t *ptr = (uint64_t *)p_class;
 
-	if constexpr (!std::is_trivially_destructible_v<T>) {
-		uint64_t *_elem_count_ptr = _get_element_count_ptr(ptr);
-		uint64_t elem_count = *(_elem_count_ptr);
+	if (!std::is_trivially_destructible<T>::value) {
+		uint64_t elem_count = *(ptr - 1);
 
 		for (uint64_t i = 0; i < elem_count; i++) {
 			p_class[i].~T();

include/godot_cpp/core/method_bind.hpp

@@ -132,7 +132,7 @@ public:
 		std::vector<GDExtensionClassMethodArgumentMetadata> vec;
 		// First element is return value
 		vec.reserve(argument_count + 1);
-		for (int i = 0; i < argument_count + 1; i++) {
+		for (int i = 0; i < argument_count; i++) {
 			vec.push_back(get_argument_metadata(i - 1));
 		}
 		return vec;
@@ -147,7 +147,7 @@ public:
 	virtual ~MethodBind();
 };
 
-template <typename Derived, typename T, typename R, bool should_returns>
+template <class Derived, class T, class R, bool should_returns>
 class MethodBindVarArgBase : public MethodBind {
 protected:
 	R(T::*method)
@@ -208,7 +208,7 @@ private:
 	}
 };
 
-template <typename T>
+template <class T>
 class MethodBindVarArgT : public MethodBindVarArgBase<MethodBindVarArgT<T>, T, void, false> {
 	friend class MethodBindVarArgBase<MethodBindVarArgT<T>, T, void, false>;
 
@@ -231,14 +231,14 @@ private:
 	}
 };
 
-template <typename T>
+template <class T>
 MethodBind *create_vararg_method_bind(void (T::*p_method)(const Variant **, GDExtensionInt, GDExtensionCallError &), const MethodInfo &p_info, bool p_return_nil_is_variant) {
 	MethodBind *a = memnew((MethodBindVarArgT<T>)(p_method, p_info, p_return_nil_is_variant));
 	a->set_instance_class(T::get_class_static());
 	return a;
 }
 
-template <typename T, typename R>
+template <class T, class R>
 class MethodBindVarArgTR : public MethodBindVarArgBase<MethodBindVarArgTR<T, R>, T, R, true> {
 	friend class MethodBindVarArgBase<MethodBindVarArgTR<T, R>, T, R, true>;
 
@@ -260,7 +260,7 @@ private:
 	}
 };
 
-template <typename T, typename R>
+template <class T, class R>
 MethodBind *create_vararg_method_bind(R (T::*p_method)(const Variant **, GDExtensionInt, GDExtensionCallError &), const MethodInfo &p_info, bool p_return_nil_is_variant) {
 	MethodBind *a = memnew((MethodBindVarArgTR<T, R>)(p_method, p_info, p_return_nil_is_variant));
 	a->set_instance_class(T::get_class_static());
@@ -277,9 +277,9 @@ class _gde_UnexistingClass;
 // No return, not const.
 
 #ifdef TYPED_METHOD_BIND
-template <typename T, typename... P>
+template <class T, class... P>
 #else
-template <typename... P>
+template <class... P>
 #endif // TYPED_METHOD_BIND
 class MethodBindT : public MethodBind {
 	void (MB_T::*method)(P...);
@@ -339,7 +339,7 @@ public:
 	}
 };
 
-template <typename T, typename... P>
+template <class T, class... P>
 MethodBind *create_method_bind(void (T::*p_method)(P...)) {
 #ifdef TYPED_METHOD_BIND
 	MethodBind *a = memnew((MethodBindT<T, P...>)(p_method));
@@ -353,9 +353,9 @@ MethodBind *create_method_bind(void (T::*p_method)(P...)) {
 // No return, const.
 
 #ifdef TYPED_METHOD_BIND
-template <typename T, typename... P>
+template <class T, class... P>
 #else
-template <typename... P>
+template <class... P>
 #endif // TYPED_METHOD_BIND
 class MethodBindTC : public MethodBind {
 	void (MB_T::*method)(P...) const;
@@ -412,11 +412,10 @@ public:
 		method = p_method;
 		generate_argument_types(sizeof...(P));
 		set_argument_count(sizeof...(P));
-		set_const(true);
 	}
 };
 
-template <typename T, typename... P>
+template <class T, class... P>
 MethodBind *create_method_bind(void (T::*p_method)(P...) const) {
 #ifdef TYPED_METHOD_BIND
 	MethodBind *a = memnew((MethodBindTC<T, P...>)(p_method));
@@ -430,9 +429,9 @@ MethodBind *create_method_bind(void (T::*p_method)(P...) const) {
 // Return, not const.
 
 #ifdef TYPED_METHOD_BIND
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 #else
-template <typename R, typename... P>
+template <class R, class... P>
 #endif // TYPED_METHOD_BIND
 class MethodBindTR : public MethodBind {
 	R(MB_T::*method)
@@ -499,7 +498,7 @@ public:
 	}
 };
 
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 MethodBind *create_method_bind(R (T::*p_method)(P...)) {
 #ifdef TYPED_METHOD_BIND
 	MethodBind *a = memnew((MethodBindTR<T, R, P...>)(p_method));
@@ -513,9 +512,9 @@ MethodBind *create_method_bind(R (T::*p_method)(P...)) {
 // Return, const.
 
 #ifdef TYPED_METHOD_BIND
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 #else
-template <typename R, typename... P>
+template <class R, class... P>
 #endif // TYPED_METHOD_BIND
 class MethodBindTRC : public MethodBind {
 	R(MB_T::*method)
@@ -579,11 +578,10 @@ public:
 		generate_argument_types(sizeof...(P));
 		set_argument_count(sizeof...(P));
 		set_return(true);
-		set_const(true);
 	}
 };
 
-template <typename T, typename R, typename... P>
+template <class T, class R, class... P>
 MethodBind *create_method_bind(R (T::*p_method)(P...) const) {
 #ifdef TYPED_METHOD_BIND
 	MethodBind *a = memnew((MethodBindTRC<T, R, P...>)(p_method));
@@ -598,7 +596,7 @@ MethodBind *create_method_bind(R (T::*p_method)(P...) const) {
 
 // no return
 
-template <typename... P>
+template <class... P>
 class MethodBindTS : public MethodBind {
 	void (*function)(P...);
 
@@ -654,7 +652,7 @@ public:
 	}
 };
 
-template <typename... P>
+template <class... P>
 MethodBind *create_static_method_bind(void (*p_method)(P...)) {
 	MethodBind *a = memnew((MethodBindTS<P...>)(p_method));
 	return a;
@@ -662,7 +660,7 @@ MethodBind *create_static_method_bind(void (*p_method)(P...)) {
 
 // return
 
-template <typename R, typename... P>
+template <class R, class... P>
 class MethodBindTRS : public MethodBind {
 	R(*function)
 	(P...);
@@ -724,7 +722,7 @@ public:
 	}
 };
 
-template <typename R, typename... P>
+template <class R, class... P>
 MethodBind *create_static_method_bind(R (*p_method)(P...)) {
 	MethodBind *a = memnew((MethodBindTRS<R, P...>)(p_method));
 	return a;

include/godot_cpp/core/method_ptrcall.hpp

@@ -39,7 +39,7 @@
 
 namespace godot {
 
-template <typename T>
+template <class T>
 struct PtrToArg {};
 
 #define MAKE_PTRARG(m_type)                                            \
@@ -166,27 +166,27 @@ MAKE_PTRARG_BY_REFERENCE(Variant);
 
 // This is for Object.
 
-template <typename T>
+template <class T>
 struct PtrToArg<T *> {
 	static_assert(std::is_base_of<Object, T>::value, "Cannot encode non-Object value as an Object");
 	_FORCE_INLINE_ static T *convert(const void *p_ptr) {
-		return likely(p_ptr) ? reinterpret_cast<T *>(godot::internal::get_object_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr)))) : nullptr;
+		return reinterpret_cast<T *>(godot::internal::get_object_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr))));
 	}
 	typedef Object *EncodeT;
 	_FORCE_INLINE_ static void encode(T *p_var, void *p_ptr) {
-		*reinterpret_cast<const void **>(p_ptr) = likely(p_var) ? p_var->_owner : nullptr;
+		*reinterpret_cast<const void **>(p_ptr) = p_var ? p_var->_owner : nullptr;
 	}
 };
 
-template <typename T>
+template <class T>
 struct PtrToArg<const T *> {
 	static_assert(std::is_base_of<Object, T>::value, "Cannot encode non-Object value as an Object");
 	_FORCE_INLINE_ static const T *convert(const void *p_ptr) {
-		return likely(p_ptr) ? reinterpret_cast<const T *>(godot::internal::get_object_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr)))) : nullptr;
+		return reinterpret_cast<const T *>(godot::internal::get_object_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr))));
 	}
 	typedef const Object *EncodeT;
 	_FORCE_INLINE_ static void encode(T *p_var, void *p_ptr) {
-		*reinterpret_cast<const void **>(p_ptr) = likely(p_var) ? p_var->_owner : nullptr;
+		*reinterpret_cast<const void **>(p_ptr) = p_var ? p_var->_owner : nullptr;
 	}
 };
 

include/godot_cpp/core/object.hpp

@@ -33,8 +33,6 @@
 
 #include <godot_cpp/core/defs.hpp>
 
-#include <godot_cpp/core/object_id.hpp>
-
 #include <godot_cpp/core/property_info.hpp>
 
 #include <godot_cpp/variant/variant.hpp>
@@ -47,11 +45,10 @@
 
 #include <vector>
 
-#define ADD_SIGNAL(m_signal) ::godot::ClassDB::add_signal(get_class_static(), m_signal)
-#define ADD_GROUP(m_name, m_prefix) ::godot::ClassDB::add_property_group(get_class_static(), m_name, m_prefix)
-#define ADD_SUBGROUP(m_name, m_prefix) ::godot::ClassDB::add_property_subgroup(get_class_static(), m_name, m_prefix)
-#define ADD_PROPERTY(m_property, m_setter, m_getter) ::godot::ClassDB::add_property(get_class_static(), m_property, m_setter, m_getter)
-#define ADD_PROPERTYI(m_property, m_setter, m_getter, m_index) ::godot::ClassDB::add_property(get_class_static(), m_property, m_setter, m_getter, m_index)
+#define ADD_SIGNAL(m_signal) godot::ClassDB::add_signal(get_class_static(), m_signal)
+#define ADD_GROUP(m_name, m_prefix) godot::ClassDB::add_property_group(get_class_static(), m_name, m_prefix)
+#define ADD_SUBGROUP(m_name, m_prefix) godot::ClassDB::add_property_subgroup(get_class_static(), m_name, m_prefix)
+#define ADD_PROPERTY(m_property, m_setter, m_getter) godot::ClassDB::add_property(get_class_static(), m_property, m_setter, m_getter)
 
 namespace godot {
 
@@ -78,36 +75,58 @@ struct MethodInfo {
 
 	MethodInfo();
 	MethodInfo(StringName p_name);
-	template <typename... Args>
+	template <class... Args>
 	MethodInfo(StringName p_name, const Args &...args);
 	MethodInfo(Variant::Type ret);
 	MethodInfo(Variant::Type ret, StringName p_name);
-	template <typename... Args>
+	template <class... Args>
 	MethodInfo(Variant::Type ret, StringName p_name, const Args &...args);
 	MethodInfo(const PropertyInfo &p_ret, StringName p_name);
-	template <typename... Args>
+	template <class... Args>
 	MethodInfo(const PropertyInfo &p_ret, StringName p_name, const Args &...);
 };
 
-template <typename... Args>
+template <class... Args>
 MethodInfo::MethodInfo(StringName p_name, const Args &...args) :
 		name(p_name), flags(GDEXTENSION_METHOD_FLAG_NORMAL) {
 	arguments = { args... };
 }
 
-template <typename... Args>
+template <class... Args>
 MethodInfo::MethodInfo(Variant::Type ret, StringName p_name, const Args &...args) :
 		name(p_name), flags(GDEXTENSION_METHOD_FLAG_NORMAL) {
 	return_val.type = ret;
 	arguments = { args... };
 }
 
-template <typename... Args>
+template <class... Args>
 MethodInfo::MethodInfo(const PropertyInfo &p_ret, StringName p_name, const Args &...args) :
 		name(p_name), return_val(p_ret), flags(GDEXTENSION_METHOD_FLAG_NORMAL) {
 	arguments = { args... };
 }
 
+class ObjectID {
+	uint64_t id = 0;
+
+public:
+	_FORCE_INLINE_ bool is_ref_counted() const { return (id & (uint64_t(1) << 63)) != 0; }
+	_FORCE_INLINE_ bool is_valid() const { return id != 0; }
+	_FORCE_INLINE_ bool is_null() const { return id == 0; }
+	_FORCE_INLINE_ operator uint64_t() const { return id; }
+	_FORCE_INLINE_ operator int64_t() const { return id; }
+
+	_FORCE_INLINE_ bool operator==(const ObjectID &p_id) const { return id == p_id.id; }
+	_FORCE_INLINE_ bool operator!=(const ObjectID &p_id) const { return id != p_id.id; }
+	_FORCE_INLINE_ bool operator<(const ObjectID &p_id) const { return id < p_id.id; }
+
+	_FORCE_INLINE_ void operator=(int64_t p_int64) { id = p_int64; }
+	_FORCE_INLINE_ void operator=(uint64_t p_uint64) { id = p_uint64; }
+
+	_FORCE_INLINE_ ObjectID() {}
+	_FORCE_INLINE_ explicit ObjectID(const uint64_t p_id) { id = p_id; }
+	_FORCE_INLINE_ explicit ObjectID(const int64_t p_id) { id = p_id; }
+};
+
 class ObjectDB {
 public:
 	static Object *get_instance(uint64_t p_object_id) {
@@ -119,7 +138,7 @@ public:
 	}
 };
 
-template <typename T>
+template <class T>
 T *Object::cast_to(Object *p_object) {
 	if (p_object == nullptr) {
 		return nullptr;
@@ -132,7 +151,7 @@ T *Object::cast_to(Object *p_object) {
 	return dynamic_cast<T *>(internal::get_object_instance_binding(casted));
 }
 
-template <typename T>
+template <class T>
 const T *Object::cast_to(const Object *p_object) {
 	if (p_object == nullptr) {
 		return nullptr;

include/godot_cpp/core/object_id.hpp

@@ -1,62 +0,0 @@
-/**************************************************************************/
-/*  object_id.hpp                                                         */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* 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_OBJECT_ID_HPP
-#define GODOT_OBJECT_ID_HPP
-
-#include <godot_cpp/core/defs.hpp>
-
-namespace godot {
-
-class ObjectID {
-	uint64_t id = 0;
-
-public:
-	_FORCE_INLINE_ bool is_ref_counted() const { return (id & (uint64_t(1) << 63)) != 0; }
-	_FORCE_INLINE_ bool is_valid() const { return id != 0; }
-	_FORCE_INLINE_ bool is_null() const { return id == 0; }
-	_FORCE_INLINE_ operator uint64_t() const { return id; }
-	_FORCE_INLINE_ operator int64_t() const { return id; }
-
-	_FORCE_INLINE_ bool operator==(const ObjectID &p_id) const { return id == p_id.id; }
-	_FORCE_INLINE_ bool operator!=(const ObjectID &p_id) const { return id != p_id.id; }
-	_FORCE_INLINE_ bool operator<(const ObjectID &p_id) const { return id < p_id.id; }
-
-	_FORCE_INLINE_ void operator=(int64_t p_int64) { id = p_int64; }
-	_FORCE_INLINE_ void operator=(uint64_t p_uint64) { id = p_uint64; }
-
-	_FORCE_INLINE_ ObjectID() {}
-	_FORCE_INLINE_ explicit ObjectID(const uint64_t p_id) { id = p_id; }
-	_FORCE_INLINE_ explicit ObjectID(const int64_t p_id) { id = p_id; }
-};
-
-} // namespace godot
-
-#endif // GODOT_OBJECT_ID_HPP

include/godot_cpp/core/property_info.hpp

@@ -47,9 +47,9 @@ struct PropertyInfo {
 	Variant::Type type = Variant::NIL;
 	StringName name;
 	StringName class_name;
-	uint32_t hint = PROPERTY_HINT_NONE;
+	uint32_t hint = 0;
 	String hint_string;
-	uint32_t usage = PROPERTY_USAGE_DEFAULT;
+	uint32_t usage = 7;
 
 	PropertyInfo() = default;
 
@@ -68,52 +68,6 @@ struct PropertyInfo {
 
 	PropertyInfo(GDExtensionVariantType p_type, const StringName &p_name, PropertyHint p_hint = PROPERTY_HINT_NONE, const String &p_hint_string = "", uint32_t p_usage = PROPERTY_USAGE_DEFAULT, const StringName &p_class_name = "") :
 			PropertyInfo((Variant::Type)p_type, p_name, p_hint, p_hint_string, p_usage, p_class_name) {}
-
-	PropertyInfo(const GDExtensionPropertyInfo *p_info) :
-			PropertyInfo(p_info->type, *reinterpret_cast<StringName *>(p_info->name), (PropertyHint)p_info->hint, *reinterpret_cast<String *>(p_info->hint_string), p_info->usage, *reinterpret_cast<StringName *>(p_info->class_name)) {}
-
-	operator Dictionary() const {
-		Dictionary dict;
-		dict["name"] = name;
-		dict["class_name"] = class_name;
-		dict["type"] = type;
-		dict["hint"] = hint;
-		dict["hint_string"] = hint_string;
-		dict["usage"] = usage;
-		return dict;
-	}
-
-	static PropertyInfo from_dict(const Dictionary &p_dict) {
-		PropertyInfo pi;
-		if (p_dict.has("type")) {
-			pi.type = Variant::Type(int(p_dict["type"]));
-		}
-		if (p_dict.has("name")) {
-			pi.name = p_dict["name"];
-		}
-		if (p_dict.has("class_name")) {
-			pi.class_name = p_dict["class_name"];
-		}
-		if (p_dict.has("hint")) {
-			pi.hint = PropertyHint(int(p_dict["hint"]));
-		}
-		if (p_dict.has("hint_string")) {
-			pi.hint_string = p_dict["hint_string"];
-		}
-		if (p_dict.has("usage")) {
-			pi.usage = p_dict["usage"];
-		}
-		return pi;
-	}
-
-	void _update(GDExtensionPropertyInfo *p_info) {
-		p_info->type = (GDExtensionVariantType)type;
-		*(reinterpret_cast<StringName *>(p_info->name)) = name;
-		p_info->hint = hint;
-		*(reinterpret_cast<String *>(p_info->hint_string)) = hint_string;
-		p_info->usage = usage;
-		*(reinterpret_cast<StringName *>(p_info->class_name)) = class_name;
-	}
 };
 
 } // namespace godot

include/godot_cpp/core/type_info.hpp

@@ -58,16 +58,6 @@ struct TypesAreSame<A, A> {
 	static bool const value = true;
 };
 
-template <auto A, auto B>
-struct FunctionsAreSame {
-	static bool const value = false;
-};
-
-template <auto A>
-struct FunctionsAreSame<A, A> {
-	static bool const value = true;
-};
-
 template <typename B, typename D>
 struct TypeInherits {
 	static D *get_d();
@@ -100,7 +90,7 @@ static PropertyInfo make_property_info(Variant::Type p_type, const StringName &p
 // instead of a forward declaration. You can always forward declare 'T' in a header file, and then
 // include the actual declaration of 'T' in the source file where 'GetTypeInfo<T>' is instantiated.
 
-template <typename T, typename = void>
+template <class T, typename = void>
 struct GetTypeInfo;
 
 #define MAKE_TYPE_INFO(m_type, m_var_type)                                                                            \
@@ -258,14 +248,14 @@ inline StringName _gde_constant_get_enum_name(T param, StringName p_constant) {
 	return GetTypeInfo<T>::get_class_info().class_name;
 }
 
-template <typename T>
+template <class T>
 class BitField {
 	int64_t value = 0;
 
 public:
 	_FORCE_INLINE_ void set_flag(T p_flag) { value |= p_flag; }
 	_FORCE_INLINE_ bool has_flag(T p_flag) const { return value & p_flag; }
-	_FORCE_INLINE_ void clear_flag(T p_flag) { value &= ~p_flag; }
+	_FORCE_INLINE_ void clear_flag(T p_flag) { return value &= ~p_flag; }
 	_FORCE_INLINE_ BitField(int64_t p_value) { value = p_value; }
 	_FORCE_INLINE_ operator int64_t() const { return value; }
 	_FORCE_INLINE_ operator Variant() const { return value; }
@@ -305,7 +295,7 @@ inline StringName _gde_constant_get_bitfield_name(T param, StringName p_constant
 	return GetTypeInfo<BitField<T>>::get_class_info().class_name;
 }
 
-template <typename T>
+template <class T>
 struct PtrToArg<TypedArray<T>> {
 	_FORCE_INLINE_ static TypedArray<T> convert(const void *p_ptr) {
 		return TypedArray<T>(*reinterpret_cast<const Array *>(p_ptr));
@@ -316,7 +306,7 @@ struct PtrToArg<TypedArray<T>> {
 	}
 };
 
-template <typename T>
+template <class T>
 struct PtrToArg<const TypedArray<T> &> {
 	typedef Array EncodeT;
 	_FORCE_INLINE_ static TypedArray<T>
@@ -393,15 +383,17 @@ MAKE_TYPED_ARRAY_INFO(Callable, Variant::CALLABLE)
 MAKE_TYPED_ARRAY_INFO(Signal, Variant::SIGNAL)
 MAKE_TYPED_ARRAY_INFO(Dictionary, Variant::DICTIONARY)
 MAKE_TYPED_ARRAY_INFO(Array, Variant::ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedByteArray, Variant::PACKED_BYTE_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedInt32Array, Variant::PACKED_INT32_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedInt64Array, Variant::PACKED_INT64_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedFloat32Array, Variant::PACKED_FLOAT32_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedFloat64Array, Variant::PACKED_FLOAT64_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedStringArray, Variant::PACKED_STRING_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedVector2Array, Variant::PACKED_VECTOR2_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedVector3Array, Variant::PACKED_VECTOR3_ARRAY)
-MAKE_TYPED_ARRAY_INFO(PackedColorArray, Variant::PACKED_COLOR_ARRAY)
+/*
+MAKE_TYPED_ARRAY_INFO(Vector<uint8_t>, Variant::PACKED_BYTE_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<int32_t>, Variant::PACKED_INT32_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<int64_t>, Variant::PACKED_INT64_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<float>, Variant::PACKED_FLOAT32_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<double>, Variant::PACKED_FLOAT64_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<String>, Variant::PACKED_STRING_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<Vector2>, Variant::PACKED_VECTOR2_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<Vector3>, Variant::PACKED_VECTOR3_ARRAY)
+MAKE_TYPED_ARRAY_INFO(Vector<Color>, Variant::PACKED_COLOR_ARRAY)
+*/
 
 #define CLASS_INFO(m_type) (GetTypeInfo<m_type *>::get_class_info())
 

include/godot_cpp/godot.hpp

@@ -123,8 +123,6 @@ extern "C" GDExtensionInterfaceStringOperatorPlusEqChar gdextension_interface_st
 extern "C" GDExtensionInterfaceStringOperatorPlusEqCstr gdextension_interface_string_operator_plus_eq_cstr;
 extern "C" GDExtensionInterfaceStringOperatorPlusEqWcstr gdextension_interface_string_operator_plus_eq_wcstr;
 extern "C" GDExtensionInterfaceStringOperatorPlusEqC32str gdextension_interface_string_operator_plus_eq_c32str;
-extern "C" GDExtensionInterfaceStringResize gdextension_interface_string_resize;
-extern "C" GDExtensionInterfaceStringNameNewWithLatin1Chars gdextension_interface_string_name_new_with_latin1_chars;
 extern "C" GDExtensionInterfaceXmlParserOpenBuffer gdextension_interface_xml_parser_open_buffer;
 extern "C" GDExtensionInterfaceFileAccessStoreBuffer gdextension_interface_file_access_store_buffer;
 extern "C" GDExtensionInterfaceFileAccessGetBuffer gdextension_interface_file_access_get_buffer;
@@ -160,27 +158,21 @@ extern "C" GDExtensionInterfaceObjectDestroy gdextension_interface_object_destro
 extern "C" GDExtensionInterfaceGlobalGetSingleton gdextension_interface_global_get_singleton;
 extern "C" GDExtensionInterfaceObjectGetInstanceBinding gdextension_interface_object_get_instance_binding;
 extern "C" GDExtensionInterfaceObjectSetInstanceBinding gdextension_interface_object_set_instance_binding;
-extern "C" GDExtensionInterfaceObjectFreeInstanceBinding gdextension_interface_object_free_instance_binding;
 extern "C" GDExtensionInterfaceObjectSetInstance gdextension_interface_object_set_instance;
 extern "C" GDExtensionInterfaceObjectGetClassName gdextension_interface_object_get_class_name;
 extern "C" GDExtensionInterfaceObjectCastTo gdextension_interface_object_cast_to;
 extern "C" GDExtensionInterfaceObjectGetInstanceFromId gdextension_interface_object_get_instance_from_id;
 extern "C" GDExtensionInterfaceObjectGetInstanceId gdextension_interface_object_get_instance_id;
-extern "C" GDExtensionInterfaceCallableCustomCreate gdextension_interface_callable_custom_create;
-extern "C" GDExtensionInterfaceCallableCustomGetUserData gdextension_interface_callable_custom_get_userdata;
 extern "C" GDExtensionInterfaceRefGetObject gdextension_interface_ref_get_object;
 extern "C" GDExtensionInterfaceRefSetObject gdextension_interface_ref_set_object;
-extern "C" GDExtensionInterfaceScriptInstanceCreate2 gdextension_interface_script_instance_create2;
-extern "C" GDExtensionInterfacePlaceHolderScriptInstanceCreate gdextension_interface_placeholder_script_instance_create;
-extern "C" GDExtensionInterfacePlaceHolderScriptInstanceUpdate gdextension_interface_placeholder_script_instance_update;
+extern "C" GDExtensionInterfaceScriptInstanceCreate gdextension_interface_script_instance_create;
 extern "C" GDExtensionInterfaceClassdbConstructObject gdextension_interface_classdb_construct_object;
 extern "C" GDExtensionInterfaceClassdbGetMethodBind gdextension_interface_classdb_get_method_bind;
 extern "C" GDExtensionInterfaceClassdbGetClassTag gdextension_interface_classdb_get_class_tag;
-extern "C" GDExtensionInterfaceClassdbRegisterExtensionClass2 gdextension_interface_classdb_register_extension_class2;
+extern "C" GDExtensionInterfaceClassdbRegisterExtensionClass gdextension_interface_classdb_register_extension_class;
 extern "C" GDExtensionInterfaceClassdbRegisterExtensionClassMethod gdextension_interface_classdb_register_extension_class_method;
 extern "C" GDExtensionInterfaceClassdbRegisterExtensionClassIntegerConstant gdextension_interface_classdb_register_extension_class_integer_constant;
 extern "C" GDExtensionInterfaceClassdbRegisterExtensionClassProperty gdextension_interface_classdb_register_extension_class_property;
-extern "C" GDExtensionInterfaceClassdbRegisterExtensionClassPropertyIndexed gdextension_interface_classdb_register_extension_class_property_indexed;
 extern "C" GDExtensionInterfaceClassdbRegisterExtensionClassPropertyGroup gdextension_interface_classdb_register_extension_class_property_group;
 extern "C" GDExtensionInterfaceClassdbRegisterExtensionClassPropertySubgroup gdextension_interface_classdb_register_extension_class_property_subgroup;
 extern "C" GDExtensionInterfaceClassdbRegisterExtensionClassSignal gdextension_interface_classdb_register_extension_class_signal;
@@ -195,44 +187,29 @@ enum ModuleInitializationLevel {
 	MODULE_INITIALIZATION_LEVEL_CORE = GDEXTENSION_INITIALIZATION_CORE,
 	MODULE_INITIALIZATION_LEVEL_SERVERS = GDEXTENSION_INITIALIZATION_SERVERS,
 	MODULE_INITIALIZATION_LEVEL_SCENE = GDEXTENSION_INITIALIZATION_SCENE,
-	MODULE_INITIALIZATION_LEVEL_EDITOR = GDEXTENSION_INITIALIZATION_EDITOR,
-	MODULE_INITIALIZATION_LEVEL_MAX
+	MODULE_INITIALIZATION_LEVEL_EDITOR = GDEXTENSION_INITIALIZATION_EDITOR
 };
 
 class GDExtensionBinding {
+private:
+	static void register_engine_classes();
+
 public:
 	using Callback = void (*)(ModuleInitializationLevel p_level);
 
-	struct InitData {
-		GDExtensionInitializationLevel minimum_initialization_level = GDEXTENSION_INITIALIZATION_CORE;
-		Callback init_callback = nullptr;
-		Callback terminate_callback = nullptr;
-	};
-
-	class InitDataList {
-		int data_count = 0;
-		int data_capacity = 0;
-		InitData **data = nullptr;
-
-	public:
-		void add(InitData *p_cb);
-		~InitDataList();
-	};
-
-	static bool api_initialized;
-	static int level_initialized[MODULE_INITIALIZATION_LEVEL_MAX];
-	static InitDataList initdata;
-	static GDExtensionBool init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, InitData *p_init_data, GDExtensionInitialization *r_initialization);
+	static Callback init_callback;
+	static Callback terminate_callback;
+	static GDExtensionInitializationLevel minimum_initialization_level;
+	static GDExtensionBool init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization);
 
 public:
-	static void initialize_level(void *p_userdata, GDExtensionInitializationLevel p_level);
-	static void deinitialize_level(void *p_userdata, GDExtensionInitializationLevel p_level);
+	static void initialize_level(void *userdata, GDExtensionInitializationLevel p_level);
+	static void deinitialize_level(void *userdata, GDExtensionInitializationLevel p_level);
 
 	class InitObject {
 		GDExtensionInterfaceGetProcAddress get_proc_address;
 		GDExtensionClassLibraryPtr library;
 		GDExtensionInitialization *initialization;
-		mutable InitData *init_data = nullptr;
 
 	public:
 		InitObject(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization);

include/godot_cpp/templates/cowdata.hpp

@@ -43,149 +43,104 @@
 
 namespace godot {
 
-template <typename T>
+template <class T>
 class Vector;
 
-template <typename T, typename V>
+template <class T, class V>
 class VMap;
 
-template <typename T>
+template <class T>
 class CharStringT;
 
-static_assert(std::is_trivially_destructible_v<std::atomic<uint64_t>>);
-
 // Silence a false positive warning (see GH-52119).
 #if defined(__GNUC__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wplacement-new"
 #endif
 
-template <typename T>
+template <class T>
 class CowData {
-	template <typename TV>
+	template <class TV>
 	friend class Vector;
 
-	template <typename TV, typename VV>
+	template <class TV, class VV>
 	friend class VMap;
 
-	template <typename TS>
+	template <class TS>
 	friend class CharStringT;
 
-public:
-	typedef int64_t Size;
-	typedef uint64_t USize;
-	static constexpr USize MAX_INT = INT64_MAX;
-
 private:
-	// Function to find the next power of 2 to an integer.
-	static _FORCE_INLINE_ USize next_po2(USize x) {
-		if (x == 0) {
-			return 0;
-		}
-
-		--x;
-		x |= x >> 1;
-		x |= x >> 2;
-		x |= x >> 4;
-		x |= x >> 8;
-		x |= x >> 16;
-		if (sizeof(USize) == 8) {
-			x |= x >> 32;
-		}
-
-		return ++x;
-	}
-
-	// Alignment:  ↓ max_align_t           ↓ USize          ↓ max_align_t
-	//             ┌────────────────────┬──┬─────────────┬──┬───────────...
-	//             │ SafeNumeric<USize> │░░│ USize       │░░│ T[]
-	//             │ ref. count         │░░│ data size   │░░│ data
-	//             └────────────────────┴──┴─────────────┴──┴───────────...
-	// Offset:     ↑ REF_COUNT_OFFSET      ↑ SIZE_OFFSET    ↑ DATA_OFFSET
-
-	static constexpr size_t REF_COUNT_OFFSET = 0;
-	static constexpr size_t SIZE_OFFSET = ((REF_COUNT_OFFSET + sizeof(SafeNumeric<USize>)) % alignof(USize) == 0) ? (REF_COUNT_OFFSET + sizeof(SafeNumeric<USize>)) : ((REF_COUNT_OFFSET + sizeof(SafeNumeric<USize>)) + alignof(USize) - ((REF_COUNT_OFFSET + sizeof(SafeNumeric<USize>)) % alignof(USize)));
-	static constexpr size_t DATA_OFFSET = ((SIZE_OFFSET + sizeof(USize)) % alignof(max_align_t) == 0) ? (SIZE_OFFSET + sizeof(USize)) : ((SIZE_OFFSET + sizeof(USize)) + alignof(max_align_t) - ((SIZE_OFFSET + sizeof(USize)) % alignof(max_align_t)));
-
 	mutable T *_ptr = nullptr;
 
 	// internal helpers
 
-	static _FORCE_INLINE_ SafeNumeric<USize> *_get_refcount_ptr(uint8_t *p_ptr) {
-		return (SafeNumeric<USize> *)(p_ptr + REF_COUNT_OFFSET);
-	}
-
-	static _FORCE_INLINE_ USize *_get_size_ptr(uint8_t *p_ptr) {
-		return (USize *)(p_ptr + SIZE_OFFSET);
-	}
-
-	static _FORCE_INLINE_ T *_get_data_ptr(uint8_t *p_ptr) {
-		return (T *)(p_ptr + DATA_OFFSET);
-	}
-
-	_FORCE_INLINE_ SafeNumeric<USize> *_get_refcount() const {
+	_FORCE_INLINE_ SafeNumeric<uint32_t> *_get_refcount() const {
 		if (!_ptr) {
 			return nullptr;
 		}
 
-		return (SafeNumeric<USize> *)((uint8_t *)_ptr - DATA_OFFSET + REF_COUNT_OFFSET);
+		return reinterpret_cast<SafeNumeric<uint32_t> *>(_ptr) - 2;
 	}
 
-	_FORCE_INLINE_ USize *_get_size() const {
+	_FORCE_INLINE_ uint32_t *_get_size() const {
 		if (!_ptr) {
 			return nullptr;
 		}
 
-		return (USize *)((uint8_t *)_ptr - DATA_OFFSET + SIZE_OFFSET);
+		return reinterpret_cast<uint32_t *>(_ptr) - 1;
 	}
 
-	_FORCE_INLINE_ USize _get_alloc_size(USize p_elements) const {
-		return next_po2(p_elements * sizeof(T));
-	}
-
-	_FORCE_INLINE_ bool _get_alloc_size_checked(USize p_elements, USize *out) const {
-		if (unlikely(p_elements == 0)) {
-			*out = 0;
-			return true;
+	_FORCE_INLINE_ T *_get_data() const {
+		if (!_ptr) {
+			return nullptr;
 		}
-#if defined(__GNUC__) && defined(IS_32_BIT)
-		USize o;
-		USize p;
+		return reinterpret_cast<T *>(_ptr);
+	}
+
+	_FORCE_INLINE_ size_t _get_alloc_size(size_t p_elements) const {
+		return next_power_of_2(p_elements * sizeof(T));
+	}
+
+	_FORCE_INLINE_ bool _get_alloc_size_checked(size_t p_elements, size_t *out) const {
+#if defined(__GNUC__)
+		size_t o;
+		size_t p;
 		if (__builtin_mul_overflow(p_elements, sizeof(T), &o)) {
 			*out = 0;
 			return false;
 		}
-		*out = next_po2(o);
-		if (__builtin_add_overflow(o, static_cast<USize>(32), &p)) {
+		*out = next_power_of_2(o);
+		if (__builtin_add_overflow(o, static_cast<size_t>(32), &p)) {
 			return false; // No longer allocated here.
 		}
+		return true;
 #else
 		// Speed is more important than correctness here, do the operations unchecked
 		// and hope for the best.
 		*out = _get_alloc_size(p_elements);
+		return true;
 #endif
-		return *out;
 	}
 
 	void _unref(void *p_data);
 	void _ref(const CowData *p_from);
 	void _ref(const CowData &p_from);
-	USize _copy_on_write();
+	uint32_t _copy_on_write();
 
 public:
 	void operator=(const CowData<T> &p_from) { _ref(p_from); }
 
 	_FORCE_INLINE_ T *ptrw() {
 		_copy_on_write();
-		return _ptr;
+		return (T *)_get_data();
 	}
 
 	_FORCE_INLINE_ const T *ptr() const {
-		return _ptr;
+		return _get_data();
 	}
 
-	_FORCE_INLINE_ Size size() const {
-		USize *size = (USize *)_get_size();
+	_FORCE_INLINE_ int size() const {
+		uint32_t *size = (uint32_t *)_get_size();
 		if (size) {
 			return *size;
 		} else {
@@ -196,42 +151,41 @@ public:
 	_FORCE_INLINE_ void clear() { resize(0); }
 	_FORCE_INLINE_ bool is_empty() const { return _ptr == nullptr; }
 
-	_FORCE_INLINE_ void set(Size p_index, const T &p_elem) {
+	_FORCE_INLINE_ void set(int p_index, const T &p_elem) {
 		ERR_FAIL_INDEX(p_index, size());
 		_copy_on_write();
-		_ptr[p_index] = p_elem;
+		_get_data()[p_index] = p_elem;
 	}
 
-	_FORCE_INLINE_ T &get_m(Size p_index) {
+	_FORCE_INLINE_ T &get_m(int p_index) {
 		CRASH_BAD_INDEX(p_index, size());
 		_copy_on_write();
-		return _ptr[p_index];
+		return _get_data()[p_index];
 	}
 
-	_FORCE_INLINE_ const T &get(Size p_index) const {
+	_FORCE_INLINE_ const T &get(int p_index) const {
 		CRASH_BAD_INDEX(p_index, size());
 
-		return _ptr[p_index];
+		return _get_data()[p_index];
 	}
 
-	template <bool p_ensure_zero = false>
-	Error resize(Size p_size);
+	Error resize(int p_size);
 
-	_FORCE_INLINE_ void remove_at(Size p_index) {
+	_FORCE_INLINE_ void remove_at(int p_index) {
 		ERR_FAIL_INDEX(p_index, size());
 		T *p = ptrw();
-		Size len = size();
-		for (Size i = p_index; i < len - 1; i++) {
+		int len = size();
+		for (int i = p_index; i < len - 1; i++) {
 			p[i] = p[i + 1];
 		}
 
 		resize(len - 1);
 	}
 
-	Error insert(Size p_pos, const T &p_val) {
+	Error insert(int p_pos, const T &p_val) {
 		ERR_FAIL_INDEX_V(p_pos, size() + 1, ERR_INVALID_PARAMETER);
 		resize(size() + 1);
-		for (Size i = (size() - 1); i > p_pos; i--) {
+		for (int i = (size() - 1); i > p_pos; i--) {
 			set(i, get(i - 1));
 		}
 		set(p_pos, p_val);
@@ -239,88 +193,83 @@ public:
 		return OK;
 	}
 
-	Size find(const T &p_val, Size p_from = 0) const;
-	Size rfind(const T &p_val, Size p_from = -1) const;
-	Size count(const T &p_val) const;
+	int find(const T &p_val, int p_from = 0) const;
 
 	_FORCE_INLINE_ CowData() {}
 	_FORCE_INLINE_ ~CowData();
-	_FORCE_INLINE_ CowData(CowData<T> &p_from) { _ref(p_from); };
+	_FORCE_INLINE_ CowData(CowData<T> &p_from) { _ref(p_from); }
 };
 
-template <typename T>
+template <class T>
 void CowData<T>::_unref(void *p_data) {
 	if (!p_data) {
 		return;
 	}
 
-	SafeNumeric<USize> *refc = _get_refcount();
+	SafeNumeric<uint32_t> *refc = _get_refcount();
 
 	if (refc->decrement() > 0) {
 		return; // still in use
 	}
-	// clean up
 
-	if constexpr (!std::is_trivially_destructible_v<T>) {
-		USize *count = _get_size();
+	// clean up
+	if (!std::is_trivially_destructible<T>::value) {
+		uint32_t *count = _get_size();
 		T *data = (T *)(count + 1);
 
-		for (USize i = 0; i < *count; ++i) {
+		for (uint32_t i = 0; i < *count; ++i) {
 			// call destructors
 			data[i].~T();
 		}
 	}
 
 	// free mem
-	Memory::free_static(((uint8_t *)p_data) - DATA_OFFSET, false);
+	Memory::free_static((uint8_t *)p_data, true);
 }
 
-template <typename T>
-typename CowData<T>::USize CowData<T>::_copy_on_write() {
+template <class T>
+uint32_t CowData<T>::_copy_on_write() {
 	if (!_ptr) {
 		return 0;
 	}
 
-	SafeNumeric<USize> *refc = _get_refcount();
+	SafeNumeric<uint32_t> *refc = _get_refcount();
 
-	USize rc = refc->get();
+	uint32_t rc = refc->get();
 	if (unlikely(rc > 1)) {
 		/* in use by more than me */
-		USize current_size = *_get_size();
+		uint32_t current_size = *_get_size();
 
-		uint8_t *mem_new = (uint8_t *)Memory::alloc_static(_get_alloc_size(current_size) + DATA_OFFSET, false);
-		ERR_FAIL_NULL_V(mem_new, 0);
+		uint32_t *mem_new = (uint32_t *)Memory::alloc_static(_get_alloc_size(current_size), true);
 
-		SafeNumeric<USize> *_refc_ptr = _get_refcount_ptr(mem_new);
-		USize *_size_ptr = _get_size_ptr(mem_new);
-		T *_data_ptr = _get_data_ptr(mem_new);
+		new (mem_new - 2) SafeNumeric<uint32_t>(1); // refcount
+		*(mem_new - 1) = current_size; // size
 
-		new (_refc_ptr) SafeNumeric<USize>(1); //refcount
-		*(_size_ptr) = current_size; //size
+		T *_data = (T *)(mem_new);
 
 		// initialize new elements
-		if constexpr (std::is_trivially_copyable_v<T>) {
-			memcpy((uint8_t *)_data_ptr, _ptr, current_size * sizeof(T));
+		if (std::is_trivially_copyable<T>::value) {
+			memcpy(mem_new, _ptr, current_size * sizeof(T));
+
 		} else {
-			for (USize i = 0; i < current_size; i++) {
-				memnew_placement(&_data_ptr[i], T(_ptr[i]));
+			for (uint32_t i = 0; i < current_size; i++) {
+				memnew_placement(&_data[i], T(_get_data()[i]));
 			}
 		}
 
 		_unref(_ptr);
-		_ptr = _data_ptr;
+		_ptr = _data;
 
 		rc = 1;
 	}
 	return rc;
 }
 
-template <typename T>
-template <bool p_ensure_zero>
-Error CowData<T>::resize(Size p_size) {
+template <class T>
+Error CowData<T>::resize(int p_size) {
 	ERR_FAIL_COND_V(p_size < 0, ERR_INVALID_PARAMETER);
 
-	Size current_size = size();
+	int current_size = size();
 
 	if (p_size == current_size) {
 		return OK;
@@ -334,71 +283,59 @@ Error CowData<T>::resize(Size p_size) {
 	}
 
 	// possibly changing size, copy on write
-	USize rc = _copy_on_write();
+	uint32_t rc = _copy_on_write();
 
-	USize current_alloc_size = _get_alloc_size(current_size);
-	USize alloc_size;
+	size_t current_alloc_size = _get_alloc_size(current_size);
+	size_t alloc_size;
 	ERR_FAIL_COND_V(!_get_alloc_size_checked(p_size, &alloc_size), ERR_OUT_OF_MEMORY);
 
 	if (p_size > current_size) {
 		if (alloc_size != current_alloc_size) {
 			if (current_size == 0) {
 				// alloc from scratch
-				uint8_t *mem_new = (uint8_t *)Memory::alloc_static(alloc_size + DATA_OFFSET, false);
-				ERR_FAIL_NULL_V(mem_new, ERR_OUT_OF_MEMORY);
+				uint32_t *ptr = (uint32_t *)Memory::alloc_static(alloc_size, true);
+				ERR_FAIL_COND_V(!ptr, ERR_OUT_OF_MEMORY);
+				*(ptr - 1) = 0; // size, currently none
+				new (ptr - 2) SafeNumeric<uint32_t>(1); // refcount
 
-				SafeNumeric<USize> *_refc_ptr = _get_refcount_ptr(mem_new);
-				USize *_size_ptr = _get_size_ptr(mem_new);
-				T *_data_ptr = _get_data_ptr(mem_new);
+				_ptr = (T *)ptr;
 
-				new (_refc_ptr) SafeNumeric<USize>(1); //refcount
-				*(_size_ptr) = 0; //size, currently none
-
-				_ptr = _data_ptr;
 			} else {
-				uint8_t *mem_new = (uint8_t *)Memory::realloc_static(((uint8_t *)_ptr) - DATA_OFFSET, alloc_size + DATA_OFFSET, false);
-				ERR_FAIL_NULL_V(mem_new, ERR_OUT_OF_MEMORY);
+				uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true);
+				ERR_FAIL_COND_V(!_ptrnew, ERR_OUT_OF_MEMORY);
+				new (_ptrnew - 2) SafeNumeric<uint32_t>(rc); // refcount
 
-				SafeNumeric<USize> *_refc_ptr = _get_refcount_ptr(mem_new);
-				T *_data_ptr = _get_data_ptr(mem_new);
-
-				new (_refc_ptr) SafeNumeric<USize>(rc); //refcount
-
-				_ptr = _data_ptr;
+				_ptr = (T *)(_ptrnew);
 			}
 		}
 
 		// construct the newly created elements
 
-		if constexpr (!std::is_trivially_constructible_v<T>) {
-			for (Size i = *_get_size(); i < p_size; i++) {
-				memnew_placement(&_ptr[i], T);
+		if (!std::is_trivially_constructible<T>::value) {
+			T *elems = _get_data();
+
+			for (int i = *_get_size(); i < p_size; i++) {
+				memnew_placement(&elems[i], T);
 			}
-		} else if (p_ensure_zero) {
-			memset((void *)(_ptr + current_size), 0, (p_size - current_size) * sizeof(T));
 		}
 
 		*_get_size() = p_size;
 
 	} else if (p_size < current_size) {
-		if constexpr (!std::is_trivially_destructible_v<T>) {
+		if (!std::is_trivially_destructible<T>::value) {
 			// deinitialize no longer needed elements
-			for (USize i = p_size; i < *_get_size(); i++) {
-				T *t = &_ptr[i];
+			for (uint32_t i = p_size; i < *_get_size(); i++) {
+				T *t = &_get_data()[i];
 				t->~T();
 			}
 		}
 
 		if (alloc_size != current_alloc_size) {
-			uint8_t *mem_new = (uint8_t *)Memory::realloc_static(((uint8_t *)_ptr) - DATA_OFFSET, alloc_size + DATA_OFFSET, false);
-			ERR_FAIL_NULL_V(mem_new, ERR_OUT_OF_MEMORY);
+			uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true);
+			ERR_FAIL_COND_V(!_ptrnew, ERR_OUT_OF_MEMORY);
+			new (_ptrnew - 2) SafeNumeric<uint32_t>(rc); // refcount
 
-			SafeNumeric<USize> *_refc_ptr = _get_refcount_ptr(mem_new);
-			T *_data_ptr = _get_data_ptr(mem_new);
-
-			new (_refc_ptr) SafeNumeric<USize>(rc); //refcount
-
-			_ptr = _data_ptr;
+			_ptr = (T *)(_ptrnew);
 		}
 
 		*_get_size() = p_size;
@@ -407,15 +344,15 @@ Error CowData<T>::resize(Size p_size) {
 	return OK;
 }
 
-template <typename T>
-typename CowData<T>::Size CowData<T>::find(const T &p_val, Size p_from) const {
-	Size ret = -1;
+template <class T>
+int CowData<T>::find(const T &p_val, int p_from) const {
+	int ret = -1;
 
 	if (p_from < 0 || size() == 0) {
 		return ret;
 	}
 
-	for (Size i = p_from; i < size(); i++) {
+	for (int i = p_from; i < size(); i++) {
 		if (get(i) == p_val) {
 			ret = i;
 			break;
@@ -425,42 +362,12 @@ typename CowData<T>::Size CowData<T>::find(const T &p_val, Size p_from) const {
 	return ret;
 }
 
-template <typename T>
-typename CowData<T>::Size CowData<T>::rfind(const T &p_val, Size p_from) const {
-	const Size s = size();
-
-	if (p_from < 0) {
-		p_from = s + p_from;
-	}
-	if (p_from < 0 || p_from >= s) {
-		p_from = s - 1;
-	}
-
-	for (Size i = p_from; i >= 0; i--) {
-		if (get(i) == p_val) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-template <typename T>
-typename CowData<T>::Size CowData<T>::count(const T &p_val) const {
-	Size amount = 0;
-	for (Size i = 0; i < size(); i++) {
-		if (get(i) == p_val) {
-			amount++;
-		}
-	}
-	return amount;
-}
-
-template <typename T>
+template <class T>
 void CowData<T>::_ref(const CowData *p_from) {
 	_ref(*p_from);
 }
 
-template <typename T>
+template <class T>
 void CowData<T>::_ref(const CowData &p_from) {
 	if (_ptr == p_from._ptr) {
 		return; // self assign, do nothing.
@@ -478,7 +385,7 @@ void CowData<T>::_ref(const CowData &p_from) {
 	}
 }
 
-template <typename T>
+template <class T>
 CowData<T>::~CowData() {
 	_unref(_ptr);
 }

include/godot_cpp/templates/hash_map.hpp

@@ -52,7 +52,7 @@ namespace godot {
  * The assignment operator copy the pairs from one map to the other.
  */
 
-template <typename TKey, typename TValue>
+template <class TKey, class TValue>
 struct HashMapElement {
 	HashMapElement *next = nullptr;
 	HashMapElement *prev = nullptr;
@@ -62,10 +62,10 @@ struct HashMapElement {
 			data(p_key, p_value) {}
 };
 
-template <typename TKey, typename TValue,
-		typename Hasher = HashMapHasherDefault,
-		typename Comparator = HashMapComparatorDefault<TKey>,
-		typename Allocator = DefaultTypedAllocator<HashMapElement<TKey, TValue>>>
+template <class TKey, class TValue,
+		class Hasher = HashMapHasherDefault,
+		class Comparator = HashMapComparatorDefault<TKey>,
+		class Allocator = DefaultTypedAllocator<HashMapElement<TKey, TValue>>>
 class HashMap {
 public:
 	const uint32_t MIN_CAPACITY_INDEX = 2; // Use a prime.

include/godot_cpp/templates/hash_set.hpp

@@ -48,9 +48,9 @@ namespace godot {
  *
  */
 
-template <typename TKey,
-		typename Hasher = HashMapHasherDefault,
-		typename Comparator = HashMapComparatorDefault<TKey>>
+template <class TKey,
+		class Hasher = HashMapHasherDefault,
+		class Comparator = HashMapComparatorDefault<TKey>>
 class HashSet {
 public:
 	static constexpr uint32_t MIN_CAPACITY_INDEX = 2; // Use a prime.

include/godot_cpp/templates/hashfuncs.hpp

@@ -253,7 +253,7 @@ static _FORCE_INLINE_ uint32_t hash_djb2_one_float(double p_in, uint32_t p_prev
 	return ((p_prev << 5) + p_prev) + hash_one_uint64(u.i);
 }
 
-template <typename T>
+template <class T>
 static _FORCE_INLINE_ uint32_t hash_make_uint32_t(T p_in) {
 	union {
 		T t;
@@ -286,7 +286,7 @@ static _FORCE_INLINE_ uint64_t hash_djb2_one_64(uint64_t p_in, uint64_t p_prev =
 	return ((p_prev << 5) + p_prev) ^ p_in;
 }
 
-template <typename T>
+template <class T>
 static _FORCE_INLINE_ uint64_t hash_make_uint64_t(T p_in) {
 	union {
 		T t;
@@ -298,15 +298,15 @@ static _FORCE_INLINE_ uint64_t hash_make_uint64_t(T p_in) {
 	return _u._u64;
 }
 
-template <typename T>
+template <class T>
 class Ref;
 
 struct HashMapHasherDefault {
 	// Generic hash function for any type.
-	template <typename T>
+	template <class T>
 	static _FORCE_INLINE_ uint32_t hash(const T *p_pointer) { return hash_one_uint64((uint64_t)p_pointer); }
 
-	template <typename T>
+	template <class T>
 	static _FORCE_INLINE_ uint32_t hash(const Ref<T> &p_ref) { return hash_one_uint64((uint64_t)p_ref.operator->()); }
 
 	static _FORCE_INLINE_ uint32_t hash(const String &p_string) { return p_string.hash(); }

include/godot_cpp/templates/list.hpp

@@ -45,7 +45,7 @@
 
 namespace godot {
 
-template <typename T, typename A = DefaultAllocator>
+template <class T, class A = DefaultAllocator>
 class List {
 	struct _Data;
 
@@ -221,7 +221,7 @@ private:
 		int size_cache = 0;
 
 		bool erase(const Element *p_I) {
-			ERR_FAIL_NULL_V(p_I, false);
+			ERR_FAIL_COND_V(!p_I, false);
 			ERR_FAIL_COND_V(p_I->data != this, false);
 
 			if (first == p_I) {
@@ -410,7 +410,7 @@ public:
 	/**
 	 * find an element in the list,
 	 */
-	template <typename T_v>
+	template <class T_v>
 	Element *find(const T_v &p_val) {
 		Element *it = front();
 		while (it) {
@@ -646,7 +646,7 @@ public:
 		sort_custom<Comparator<T>>();
 	}
 
-	template <typename C>
+	template <class C>
 	void sort_custom_inplace() {
 		if (size() < 2) {
 			return;
@@ -693,7 +693,7 @@ public:
 		_data->last = to;
 	}
 
-	template <typename C>
+	template <class C>
 	struct AuxiliaryComparator {
 		C compare;
 		_FORCE_INLINE_ bool operator()(const Element *a, const Element *b) const {
@@ -701,7 +701,7 @@ public:
 		}
 	};
 
-	template <typename C>
+	template <class C>
 	void sort_custom() {
 		// this version uses auxiliary memory for speed.
 		// if you don't want to use auxiliary memory, use the in_place version

include/godot_cpp/templates/local_vector.hpp

@@ -31,10 +31,10 @@
 #ifndef GODOT_LOCAL_VECTOR_HPP
 #define GODOT_LOCAL_VECTOR_HPP
 
-#include <godot_cpp/core/error_macros.hpp>
-#include <godot_cpp/core/memory.hpp>
-#include <godot_cpp/templates/sort_array.hpp>
-#include <godot_cpp/templates/vector.hpp>
+#include "godot_cpp/core/error_macros.hpp"
+#include "godot_cpp/core/memory.hpp"
+#include "godot_cpp/templates/sort_array.hpp"
+#include "godot_cpp/templates/vector.hpp"
 
 #include <initializer_list>
 #include <type_traits>
@@ -43,7 +43,7 @@ namespace godot {
 
 // If tight, it grows strictly as much as needed.
 // Otherwise, it grows exponentially (the default and what you want in most cases).
-template <typename T, typename U = uint32_t, bool force_trivial = false, bool tight = false>
+template <class T, class U = uint32_t, bool force_trivial = false, bool tight = false>
 class LocalVector {
 private:
 	U count = 0;
@@ -257,7 +257,7 @@ public:
 		return -1;
 	}
 
-	template <typename C>
+	template <class C>
 	void sort_custom() {
 		U len = count;
 		if (len == 0) {
@@ -331,7 +331,7 @@ public:
 	}
 };
 
-template <typename T, typename U = uint32_t, bool force_trivial = false>
+template <class T, class U = uint32_t, bool force_trivial = false>
 using TightLocalVector = LocalVector<T, U, force_trivial, true>;
 
 } // namespace godot

include/godot_cpp/templates/pair.hpp

@@ -33,7 +33,7 @@
 
 namespace godot {
 
-template <typename F, typename S>
+template <class F, class S>
 struct Pair {
 	F first;
 	S second;
@@ -49,17 +49,17 @@ struct Pair {
 	}
 };
 
-template <typename F, typename S>
+template <class F, class S>
 bool operator==(const Pair<F, S> &pair, const Pair<F, S> &other) {
 	return (pair.first == other.first) && (pair.second == other.second);
 }
 
-template <typename F, typename S>
+template <class F, class S>
 bool operator!=(const Pair<F, S> &pair, const Pair<F, S> &other) {
 	return (pair.first != other.first) || (pair.second != other.second);
 }
 
-template <typename F, typename S>
+template <class F, class S>
 struct PairSort {
 	bool operator()(const Pair<F, S> &A, const Pair<F, S> &B) const {
 		if (A.first != B.first) {
@@ -69,7 +69,7 @@ struct PairSort {
 	}
 };
 
-template <typename K, typename V>
+template <class K, class V>
 struct KeyValue {
 	const K key;
 	V value;
@@ -85,17 +85,17 @@ struct KeyValue {
 	}
 };
 
-template <typename K, typename V>
+template <class K, class V>
 bool operator==(const KeyValue<K, V> &pair, const KeyValue<K, V> &other) {
 	return (pair.key == other.key) && (pair.value == other.value);
 }
 
-template <typename K, typename V>
+template <class K, class V>
 bool operator!=(const KeyValue<K, V> &pair, const KeyValue<K, V> &other) {
 	return (pair.key != other.key) || (pair.value != other.value);
 }
 
-template <typename K, typename V>
+template <class K, class V>
 struct KeyValueSort {
 	bool operator()(const KeyValue<K, V> &A, const KeyValue<K, V> &B) const {
 		return A.key < B.key;

include/godot_cpp/templates/rb_map.hpp

@@ -40,7 +40,7 @@ namespace godot {
 // based on the very nice implementation of rb-trees by:
 // https://web.archive.org/web/20120507164830/https://web.mit.edu/~emin/www/source_code/red_black_tree/index.html
 
-template <typename K, typename V, typename C = Comparator<K>, typename A = DefaultAllocator>
+template <class K, class V, class C = Comparator<K>, class A = DefaultAllocator>
 class RBMap {
 	enum Color {
 		RED,

include/godot_cpp/templates/rb_set.hpp

@@ -38,7 +38,7 @@
 
 namespace godot {
 
-template <typename T, typename C = Comparator<T>, typename A = DefaultAllocator>
+template <class T, class C = Comparator<T>, class A = DefaultAllocator>
 class RBSet {
 	enum Color {
 		RED,

include/godot_cpp/templates/rid_owner.hpp

@@ -42,7 +42,7 @@
 
 namespace godot {
 
-template <typename T, bool THREAD_SAFE = false>
+template <class T, bool THREAD_SAFE = false>
 class RID_Alloc {
 	T **chunks = nullptr;
 	uint32_t **free_list_chunks = nullptr;
@@ -186,12 +186,12 @@ public:
 	}
 	void initialize_rid(RID p_rid) {
 		T *mem = get_or_null(p_rid, true);
-		ERR_FAIL_NULL(mem);
+		ERR_FAIL_COND(!mem);
 		memnew_placement(mem, T);
 	}
 	void initialize_rid(RID p_rid, const T &p_value) {
 		T *mem = get_or_null(p_rid, true);
-		ERR_FAIL_NULL(mem);
+		ERR_FAIL_COND(!mem);
 		memnew_placement(mem, T(p_value));
 	}
 
@@ -347,7 +347,7 @@ public:
 	}
 };
 
-template <typename T, bool THREAD_SAFE = false>
+template <class T, bool THREAD_SAFE = false>
 class RID_PtrOwner {
 	RID_Alloc<T *, THREAD_SAFE> alloc;
 
@@ -374,7 +374,7 @@ public:
 
 	_FORCE_INLINE_ void replace(const RID &p_rid, T *p_new_ptr) {
 		T **ptr = alloc.get_or_null(p_rid);
-		ERR_FAIL_NULL(ptr);
+		ERR_FAIL_COND(!ptr);
 		*ptr = p_new_ptr;
 	}
 
@@ -406,7 +406,7 @@ public:
 			alloc(p_target_chunk_byte_size) {}
 };
 
-template <typename T, bool THREAD_SAFE = false>
+template <class T, bool THREAD_SAFE = false>
 class RID_Owner {
 	RID_Alloc<T, THREAD_SAFE> alloc;
 

include/godot_cpp/templates/safe_refcount.hpp

@@ -48,16 +48,7 @@ namespace godot {
 //   value and, as an important benefit, you can be sure the value is properly synchronized
 //   even with threads that are already running.
 
-// These are used in very specific areas of the engine where it's critical that these guarantees are held
-#define SAFE_NUMERIC_TYPE_PUN_GUARANTEES(m_type)                    \
-	static_assert(sizeof(SafeNumeric<m_type>) == sizeof(m_type));   \
-	static_assert(alignof(SafeNumeric<m_type>) == alignof(m_type)); \
-	static_assert(std::is_trivially_destructible<std::atomic<m_type>>::value);
-#define SAFE_FLAG_TYPE_PUN_GUARANTEES                \
-	static_assert(sizeof(SafeFlag) == sizeof(bool)); \
-	static_assert(alignof(SafeFlag) == alignof(bool));
-
-template <typename T>
+template <class T>
 class SafeNumeric {
 	std::atomic<T> value;
 
@@ -132,7 +123,7 @@ public:
 		}
 	}
 
-	_ALWAYS_INLINE_ explicit SafeNumeric(T p_value = static_cast<T>(0)) {
+	_ALWAYS_INLINE_ explicit SafeNumeric<T>(T p_value = static_cast<T>(0)) {
 		set(p_value);
 	}
 };
@@ -195,7 +186,7 @@ public:
 
 #else
 
-template <typename T>
+template <class T>
 class SafeNumeric {
 protected:
 	T value;

include/godot_cpp/templates/search_array.hpp

@@ -35,7 +35,7 @@
 
 namespace godot {
 
-template <typename T, typename Comparator = _DefaultComparator<T>>
+template <class T, class Comparator = _DefaultComparator<T>>
 class SearchArray {
 public:
 	Comparator compare;

include/godot_cpp/templates/self_list.hpp

@@ -36,7 +36,7 @@
 
 namespace godot {
 
-template <typename T>
+template <class T>
 class SelfList {
 public:
 	class List {

include/godot_cpp/templates/sort_array.hpp

@@ -41,7 +41,7 @@ namespace godot {
 		break;                                                        \
 	}
 
-template <typename T>
+template <class T>
 struct _DefaultComparator {
 	_FORCE_INLINE_ bool operator()(const T &a, const T &b) const { return (a < b); }
 };
@@ -52,7 +52,7 @@ struct _DefaultComparator {
 #define SORT_ARRAY_VALIDATE_ENABLED false
 #endif
 
-template <typename T, typename Comparator = _DefaultComparator<T>, bool Validate = SORT_ARRAY_VALIDATE_ENABLED>
+template <class T, class Comparator = _DefaultComparator<T>, bool Validate = SORT_ARRAY_VALIDATE_ENABLED>
 class SortArray {
 	enum {
 		INTROSORT_THRESHOLD = 16

include/godot_cpp/templates/thread_work_pool.hpp

@@ -52,7 +52,7 @@ class ThreadWorkPool {
 		virtual ~BaseWork() = default;
 	};
 
-	template <typename C, typename M, typename U>
+	template <class C, class M, class U>
 	struct Work : public BaseWork {
 		C *instance;
 		M method;
@@ -94,9 +94,9 @@ class ThreadWorkPool {
 	}
 
 public:
-	template <typename C, typename M, typename U>
+	template <class C, class M, class U>
 	void begin_work(uint32_t p_elements, C *p_instance, M p_method, U p_userdata) {
-		ERR_FAIL_NULL(threads); // Never initialized.
+		ERR_FAIL_COND(!threads); // never initialized
 		ERR_FAIL_COND(current_work != nullptr);
 
 		index.store(0, std::memory_order_release);
@@ -123,18 +123,18 @@ public:
 	}
 
 	bool is_done_dispatching() const {
-		ERR_FAIL_NULL_V(current_work, true);
+		ERR_FAIL_COND_V(current_work == nullptr, true);
 		return index.load(std::memory_order_acquire) >= current_work->max_elements;
 	}
 
 	uint32_t get_work_index() const {
-		ERR_FAIL_NULL_V(current_work, 0);
+		ERR_FAIL_COND_V(current_work == nullptr, 0);
 		uint32_t idx = index.load(std::memory_order_acquire);
 		return Math::min(idx, current_work->max_elements);
 	}
 
 	void end_work() {
-		ERR_FAIL_NULL(current_work);
+		ERR_FAIL_COND(current_work == nullptr);
 		for (uint32_t i = 0; i < threads_working; i++) {
 			threads[i].completed.wait();
 			threads[i].work = nullptr;
@@ -145,7 +145,7 @@ public:
 		current_work = nullptr;
 	}
 
-	template <typename C, typename M, typename U>
+	template <class C, class M, class U>
 	void do_work(uint32_t p_elements, C *p_instance, M p_method, U p_userdata) {
 		switch (p_elements) {
 			case 0:

include/godot_cpp/templates/vector.hpp

@@ -47,42 +47,38 @@
 
 namespace godot {
 
-template <typename T>
+template <class T>
 class VectorWriteProxy {
 public:
-	_FORCE_INLINE_ T &operator[](typename CowData<T>::Size p_index) {
+	_FORCE_INLINE_ T &operator[](int p_index) {
 		CRASH_BAD_INDEX(p_index, ((Vector<T> *)(this))->_cowdata.size());
 
 		return ((Vector<T> *)(this))->_cowdata.ptrw()[p_index];
 	}
 };
 
-template <typename T>
+template <class T>
 class Vector {
 	friend class VectorWriteProxy<T>;
 
 public:
 	VectorWriteProxy<T> write;
-	typedef typename CowData<T>::Size Size;
 
 private:
 	CowData<T> _cowdata;
 
 public:
 	bool push_back(T p_elem);
-	_FORCE_INLINE_ bool append(const T &p_elem) { return push_back(p_elem); } //alias
+	_FORCE_INLINE_ bool append(const T &p_elem) { return push_back(p_elem); } // alias
 	void fill(T p_elem);
 
-	void remove_at(Size p_index) { _cowdata.remove_at(p_index); }
-	_FORCE_INLINE_ bool erase(const T &p_val) {
-		Size idx = find(p_val);
+	void remove_at(int p_index) { _cowdata.remove_at(p_index); }
+	void erase(const T &p_val) {
+		int idx = find(p_val);
 		if (idx >= 0) {
 			remove_at(idx);
-			return true;
 		}
-		return false;
 	}
-
 	void reverse();
 
 	_FORCE_INLINE_ T *ptrw() { return _cowdata.ptrw(); }
@@ -90,45 +86,37 @@ public:
 	_FORCE_INLINE_ void clear() { resize(0); }
 	_FORCE_INLINE_ bool is_empty() const { return _cowdata.is_empty(); }
 
-	_FORCE_INLINE_ T get(Size p_index) { return _cowdata.get(p_index); }
-	_FORCE_INLINE_ const T &get(Size p_index) const { return _cowdata.get(p_index); }
-	_FORCE_INLINE_ void set(Size p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); }
-	_FORCE_INLINE_ Size size() const { return _cowdata.size(); }
-	Error resize(Size p_size) { return _cowdata.resize(p_size); }
-	Error resize_zeroed(Size p_size) { return _cowdata.template resize<true>(p_size); }
-	_FORCE_INLINE_ const T &operator[](Size p_index) const { return _cowdata.get(p_index); }
-	Error insert(Size p_pos, T p_val) { return _cowdata.insert(p_pos, p_val); }
-	Size find(const T &p_val, Size p_from = 0) const { return _cowdata.find(p_val, p_from); }
-	Size rfind(const T &p_val, Size p_from = -1) const { return _cowdata.rfind(p_val, p_from); }
-	Size count(const T &p_val) const { return _cowdata.count(p_val); }
+	_FORCE_INLINE_ T get(int p_index) { return _cowdata.get(p_index); }
+	_FORCE_INLINE_ const T &get(int p_index) const { return _cowdata.get(p_index); }
+	_FORCE_INLINE_ void set(int p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); }
+	_FORCE_INLINE_ int size() const { return _cowdata.size(); }
+	Error resize(int p_size) { return _cowdata.resize(p_size); }
+	_FORCE_INLINE_ const T &operator[](int p_index) const { return _cowdata.get(p_index); }
+	Error insert(int p_pos, T p_val) { return _cowdata.insert(p_pos, p_val); }
+	int find(const T &p_val, int p_from = 0) const { return _cowdata.find(p_val, p_from); }
 
 	void append_array(Vector<T> p_other);
 
 	_FORCE_INLINE_ bool has(const T &p_val) const { return find(p_val) != -1; }
 
-	void sort() {
-		sort_custom<_DefaultComparator<T>>();
-	}
-
-	template <typename Comparator, bool Validate = SORT_ARRAY_VALIDATE_ENABLED, typename... Args>
-	void sort_custom(Args &&...args) {
-		Size len = _cowdata.size();
+	template <class C>
+	void sort_custom() {
+		int len = _cowdata.size();
 		if (len == 0) {
 			return;
 		}
 
 		T *data = ptrw();
-		SortArray<T, Comparator, Validate> sorter{ args... };
+		SortArray<T, C> sorter;
 		sorter.sort(data, len);
 	}
 
-	Size bsearch(const T &p_value, bool p_before) {
-		return bsearch_custom<_DefaultComparator<T>>(p_value, p_before);
+	void sort() {
+		sort_custom<_DefaultComparator<T>>();
 	}
 
-	template <typename Comparator, typename Value, typename... Args>
-	Size bsearch_custom(const Value &p_value, bool p_before, Args &&...args) {
-		SearchArray<T, Comparator> search{ args... };
+	int bsearch(const T &p_value, bool p_before) {
+		SearchArray<T> search;
 		return search.bisect(ptrw(), size(), p_value, p_before);
 	}
 
@@ -137,7 +125,7 @@ public:
 	}
 
 	void ordered_insert(const T &p_val) {
-		Size i;
+		int i;
 		for (i = 0; i < _cowdata.size(); i++) {
 			if (p_val < operator[](i)) {
 				break;
@@ -152,36 +140,33 @@ public:
 
 	Vector<uint8_t> to_byte_array() const {
 		Vector<uint8_t> ret;
-		if (is_empty()) {
-			return ret;
-		}
 		ret.resize(size() * sizeof(T));
 		memcpy(ret.ptrw(), ptr(), sizeof(T) * size());
 		return ret;
 	}
 
-	Vector<T> slice(Size p_begin, Size p_end = CowData<T>::MAX_INT) const {
+	Vector<T> slice(int p_begin, int p_end = INT_MAX) const {
 		Vector<T> result;
 
-		const Size s = size();
+		const int s = size();
 
-		Size begin = CLAMP(p_begin, -s, s);
+		int begin = Math::clamp(p_begin, -s, s);
 		if (begin < 0) {
 			begin += s;
 		}
-		Size end = CLAMP(p_end, -s, s);
+		int end = Math::clamp(p_end, -s, s);
 		if (end < 0) {
 			end += s;
 		}
 
 		ERR_FAIL_COND_V(begin > end, result);
 
-		Size result_size = end - begin;
+		int result_size = end - begin;
 		result.resize(result_size);
 
 		const T *const r = ptr();
 		T *const w = result.ptrw();
-		for (Size i = 0; i < result_size; ++i) {
+		for (int i = 0; i < result_size; ++i) {
 			w[i] = r[begin + i];
 		}
 
@@ -189,11 +174,11 @@ public:
 	}
 
 	bool operator==(const Vector<T> &p_arr) const {
-		Size s = size();
+		int s = size();
 		if (s != p_arr.size()) {
 			return false;
 		}
-		for (Size i = 0; i < s; i++) {
+		for (int i = 0; i < s; i++) {
 			if (operator[](i) != p_arr[i]) {
 				return false;
 			}
@@ -202,11 +187,11 @@ public:
 	}
 
 	bool operator!=(const Vector<T> &p_arr) const {
-		Size s = size();
+		int s = size();
 		if (s != p_arr.size()) {
 			return true;
 		}
-		for (Size i = 0; i < s; i++) {
+		for (int i = 0; i < s; i++) {
 			if (operator[](i) != p_arr[i]) {
 				return true;
 			}
@@ -283,7 +268,7 @@ public:
 		Error err = _cowdata.resize(p_init.size());
 		ERR_FAIL_COND(err);
 
-		Size i = 0;
+		int i = 0;
 		for (const T &element : p_init) {
 			_cowdata.set(i++, element);
 		}
@@ -293,28 +278,28 @@ public:
 	_FORCE_INLINE_ ~Vector() {}
 };
 
-template <typename T>
+template <class T>
 void Vector<T>::reverse() {
-	for (Size i = 0; i < size() / 2; i++) {
+	for (int i = 0; i < size() / 2; i++) {
 		T *p = ptrw();
 		SWAP(p[i], p[size() - i - 1]);
 	}
 }
 
-template <typename T>
+template <class T>
 void Vector<T>::append_array(Vector<T> p_other) {
-	const Size ds = p_other.size();
+	const int ds = p_other.size();
 	if (ds == 0) {
 		return;
 	}
-	const Size bs = size();
+	const int bs = size();
 	resize(bs + ds);
-	for (Size i = 0; i < ds; ++i) {
+	for (int i = 0; i < ds; ++i) {
 		ptrw()[bs + i] = p_other[i];
 	}
 }
 
-template <typename T>
+template <class T>
 bool Vector<T>::push_back(T p_elem) {
 	Error err = resize(size() + 1);
 	ERR_FAIL_COND_V(err, true);
@@ -323,10 +308,10 @@ bool Vector<T>::push_back(T p_elem) {
 	return false;
 }
 
-template <typename T>
+template <class T>
 void Vector<T>::fill(T p_elem) {
 	T *p = ptrw();
-	for (Size i = 0; i < size(); i++) {
+	for (int i = 0; i < size(); i++) {
 		p[i] = p_elem;
 	}
 }

include/godot_cpp/templates/vmap.hpp

@@ -35,7 +35,7 @@
 
 namespace godot {
 
-template <typename T, typename V>
+template <class T, class V>
 class VMap {
 public:
 	struct Pair {

include/godot_cpp/templates/vset.hpp

@@ -35,7 +35,7 @@
 
 namespace godot {
 
-template <typename T>
+template <class T>
 class VSet {
 	Vector<T> _data;
 

include/godot_cpp/variant/aabb.hpp

@@ -65,7 +65,6 @@ struct _NO_DISCARD_ AABB {
 	bool operator!=(const AABB &p_rval) const;
 
 	bool is_equal_approx(const AABB &p_aabb) const;
-	bool is_finite() const;
 	_FORCE_INLINE_ bool intersects(const AABB &p_aabb) const; /// Both AABBs overlap
 	_FORCE_INLINE_ bool intersects_inclusive(const AABB &p_aabb) const; /// Both AABBs (or their faces) overlap
 	_FORCE_INLINE_ bool encloses(const AABB &p_aabb) const; /// p_aabb is completely inside this
@@ -202,11 +201,11 @@ inline bool AABB::encloses(const AABB &p_aabb) const {
 
 	return (
 			(src_min.x <= dst_min.x) &&
-			(src_max.x >= dst_max.x) &&
+			(src_max.x > dst_max.x) &&
 			(src_min.y <= dst_min.y) &&
-			(src_max.y >= dst_max.y) &&
+			(src_max.y > dst_max.y) &&
 			(src_min.z <= dst_min.z) &&
-			(src_max.z >= dst_max.z));
+			(src_max.z > dst_max.z));
 }
 
 Vector3 AABB::get_support(const Vector3 &p_normal) const {

include/godot_cpp/variant/array_helpers.hpp

@@ -28,9 +28,6 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
 /**************************************************************************/
 
-#ifndef GODOT_ARRAY_HELPERS_HPP
-#define GODOT_ARRAY_HELPERS_HPP
-
 namespace godot {
 namespace helpers {
 template <typename T, typename ValueT>
@@ -51,5 +48,3 @@ T append_all(T appendable) {
 }
 } // namespace helpers
 } // namespace godot
-
-#endif // GODOT_ARRAY_HELPERS_HPP

include/godot_cpp/variant/basis.hpp

@@ -128,7 +128,6 @@ struct _NO_DISCARD_ Basis {
 	}
 
 	bool is_equal_approx(const Basis &p_basis) const;
-	bool is_finite() const;
 
 	bool operator==(const Basis &p_matrix) const;
 	bool operator!=(const Basis &p_matrix) const;
@@ -224,7 +223,7 @@ struct _NO_DISCARD_ Basis {
 
 	operator Quaternion() const { return get_quaternion(); }
 
-	static Basis looking_at(const Vector3 &p_target, const Vector3 &p_up = Vector3(0, 1, 0), bool p_use_model_front = false);
+	static Basis looking_at(const Vector3 &p_target, const Vector3 &p_up = Vector3(0, 1, 0));
 
 	Basis(const Quaternion &p_quaternion) { set_quaternion(p_quaternion); }
 	Basis(const Quaternion &p_quaternion, const Vector3 &p_scale) { set_quaternion_scale(p_quaternion, p_scale); }

include/godot_cpp/variant/callable_custom.hpp

@@ -1,64 +0,0 @@
-/**************************************************************************/
-/*  callable_custom.hpp                                                   */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* 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_CALLABLE_CUSTOM_HPP
-#define GODOT_CALLABLE_CUSTOM_HPP
-
-#include <godot_cpp/core/object_id.hpp>
-#include <godot_cpp/variant/string_name.hpp>
-
-namespace godot {
-
-class Object;
-
-class CallableCustomBase {
-public:
-	virtual ObjectID get_object() const = 0;
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const = 0;
-	virtual ~CallableCustomBase() {}
-};
-
-class CallableCustom : public CallableCustomBase {
-public:
-	typedef bool (*CompareEqualFunc)(const CallableCustom *p_a, const CallableCustom *p_b);
-	typedef bool (*CompareLessFunc)(const CallableCustom *p_a, const CallableCustom *p_b);
-
-	virtual uint32_t hash() const = 0;
-	virtual String get_as_text() const = 0;
-	virtual CompareEqualFunc get_compare_equal_func() const = 0;
-	virtual CompareLessFunc get_compare_less_func() const = 0;
-	virtual bool is_valid() const;
-	virtual ObjectID get_object() const = 0;
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const = 0;
-};
-
-} // namespace godot
-
-#endif // GODOT_CALLABLE_CUSTOM_HPP

include/godot_cpp/variant/callable_method_pointer.hpp

@@ -1,248 +0,0 @@
-/**************************************************************************/
-/*  callable_method_pointer.hpp                                           */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* 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_CALLABLE_METHOD_POINTER_HPP
-#define GODOT_CALLABLE_METHOD_POINTER_HPP
-
-#include <godot_cpp/core/binder_common.hpp>
-#include <godot_cpp/variant/variant.hpp>
-
-namespace godot {
-
-class CallableCustomMethodPointerBase : public CallableCustomBase {
-	uint32_t *comp_ptr = nullptr;
-	uint32_t comp_size;
-	uint32_t h;
-
-protected:
-	void _setup(uint32_t *p_base_ptr, uint32_t p_ptr_size);
-
-public:
-	_FORCE_INLINE_ const uint32_t *get_comp_ptr() const { return comp_ptr; }
-	_FORCE_INLINE_ uint32_t get_comp_size() const { return comp_size; }
-	_FORCE_INLINE_ uint32_t get_hash() const { return h; }
-};
-
-namespace internal {
-
-Callable create_callable_from_ccmp(CallableCustomMethodPointerBase *p_callable_method_pointer);
-
-} // namespace internal
-
-//
-// No return value.
-//
-
-template <typename T, typename... P>
-class CallableCustomMethodPointer : public CallableCustomMethodPointerBase {
-	struct Data {
-		T *instance;
-		void (T::*method)(P...);
-	} data;
-	static_assert(sizeof(Data) % 4 == 0);
-
-public:
-	virtual ObjectID get_object() const override {
-		return ObjectID(data.instance->get_instance_id());
-	}
-
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const override {
-		call_with_variant_args(data.instance, data.method, p_arguments, p_argcount, r_call_error);
-	}
-
-	CallableCustomMethodPointer(T *p_instance, void (T::*p_method)(P...)) {
-		memset(&data, 0, sizeof(Data));
-		data.instance = p_instance;
-		data.method = p_method;
-		_setup((uint32_t *)&data, sizeof(Data));
-	}
-};
-
-template <typename T, typename... P>
-Callable create_custom_callable_function_pointer(T *p_instance, void (T::*p_method)(P...)) {
-	typedef CallableCustomMethodPointer<T, P...> CCMP;
-	CCMP *ccmp = memnew(CCMP(p_instance, p_method));
-	return ::godot::internal::create_callable_from_ccmp(ccmp);
-}
-
-//
-// With return value.
-//
-
-template <typename T, typename R, typename... P>
-class CallableCustomMethodPointerRet : public CallableCustomMethodPointerBase {
-	struct Data {
-		T *instance;
-		R(T::*method)
-		(P...);
-	} data;
-	static_assert(sizeof(Data) % 4 == 0);
-
-public:
-	virtual ObjectID get_object() const override {
-		return ObjectID(data.instance->get_instance_id());
-	}
-
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const override {
-		call_with_variant_args_ret(data.instance, data.method, p_arguments, p_argcount, r_return_value, r_call_error);
-	}
-
-	CallableCustomMethodPointerRet(T *p_instance, R (T::*p_method)(P...)) {
-		memset(&data, 0, sizeof(Data));
-		data.instance = p_instance;
-		data.method = p_method;
-		_setup((uint32_t *)&data, sizeof(Data));
-	}
-};
-
-template <typename T, typename R, typename... P>
-Callable create_custom_callable_function_pointer(T *p_instance, R (T::*p_method)(P...)) {
-	typedef CallableCustomMethodPointerRet<T, R, P...> CCMP; // Messes with memnew otherwise.
-	CCMP *ccmp = memnew(CCMP(p_instance, p_method));
-	return ::godot::internal::create_callable_from_ccmp(ccmp);
-}
-
-//
-// Const with return value.
-//
-
-template <typename T, typename R, typename... P>
-class CallableCustomMethodPointerRetC : public CallableCustomMethodPointerBase {
-	struct Data {
-		T *instance;
-		R(T::*method)
-		(P...) const;
-	} data;
-	static_assert(sizeof(Data) % 4 == 0);
-
-public:
-	virtual ObjectID get_object() const override {
-		return ObjectID(data.instance->get_instance_id());
-	}
-
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const override {
-		call_with_variant_args_retc(data.instance, data.method, p_arguments, p_argcount, r_return_value, r_call_error);
-	}
-
-	CallableCustomMethodPointerRetC(const T *p_instance, R (T::*p_method)(P...) const) {
-		memset(&data, 0, sizeof(Data));
-		data.instance = const_cast<T *>(p_instance);
-		data.method = p_method;
-		_setup((uint32_t *)&data, sizeof(Data));
-	}
-};
-
-template <typename T, typename R, typename... P>
-Callable create_custom_callable_function_pointer(const T *p_instance, R (T::*p_method)(P...) const) {
-	typedef CallableCustomMethodPointerRetC<T, R, P...> CCMP; // Messes with memnew otherwise.
-	CCMP *ccmp = memnew(CCMP(p_instance, p_method));
-	return ::godot::internal::create_callable_from_ccmp(ccmp);
-}
-
-//
-// Static method with no return value.
-//
-
-template <typename... P>
-class CallableCustomStaticMethodPointer : public CallableCustomMethodPointerBase {
-	struct Data {
-		void (*method)(P...);
-	} data;
-	static_assert(sizeof(Data) % 4 == 0);
-
-public:
-	virtual ObjectID get_object() const override {
-		return ObjectID();
-	}
-
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const override {
-		call_with_variant_args_static_ret(data.method, p_arguments, p_argcount, r_return_value, r_call_error);
-		r_return_value = Variant();
-	}
-
-	CallableCustomStaticMethodPointer(void (*p_method)(P...)) {
-		memset(&data, 0, sizeof(Data));
-		data.method = p_method;
-		_setup((uint32_t *)&data, sizeof(Data));
-	}
-};
-
-template <typename... P>
-Callable create_custom_callable_static_function_pointer(void (*p_method)(P...)) {
-	typedef CallableCustomStaticMethodPointer<P...> CCMP;
-	CCMP *ccmp = memnew(CCMP(p_method));
-	return ::godot::internal::create_callable_from_ccmp(ccmp);
-}
-
-//
-// Static method with return value.
-//
-
-template <typename R, typename... P>
-class CallableCustomStaticMethodPointerRet : public CallableCustomMethodPointerBase {
-	struct Data {
-		R(*method)
-		(P...);
-	} data;
-	static_assert(sizeof(Data) % 4 == 0);
-
-public:
-	virtual ObjectID get_object() const override {
-		return ObjectID();
-	}
-
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const override {
-		call_with_variant_args_static_ret(data.method, p_arguments, p_argcount, r_return_value, r_call_error);
-	}
-
-	CallableCustomStaticMethodPointerRet(R (*p_method)(P...)) {
-		memset(&data, 0, sizeof(Data));
-		data.method = p_method;
-		_setup((uint32_t *)&data, sizeof(Data));
-	}
-};
-
-template <typename R, typename... P>
-Callable create_custom_callable_static_function_pointer(R (*p_method)(P...)) {
-	typedef CallableCustomStaticMethodPointerRet<R, P...> CCMP;
-	CCMP *ccmp = memnew(CCMP(p_method));
-	return ::godot::internal::create_callable_from_ccmp(ccmp);
-}
-
-//
-// The API:
-//
-
-#define callable_mp(I, M) ::godot::create_custom_callable_function_pointer(I, M)
-#define callable_mp_static(M) ::godot::create_custom_callable_static_function_pointer(M)
-
-} // namespace godot
-
-#endif // GODOT_CALLABLE_METHOD_POINTER_HPP

include/godot_cpp/variant/char_string.hpp

@@ -38,19 +38,19 @@
 
 namespace godot {
 
-template <typename T>
+template <class T>
 class CharStringT;
 
-template <typename T>
+template <class T>
 class CharProxy {
-	template <typename TS>
+	template <class TS>
 	friend class CharStringT;
 
-	const int64_t _index;
+	const int _index;
 	CowData<T> &_cowdata;
 	static inline const T _null = 0;
 
-	_FORCE_INLINE_ CharProxy(const int64_t &p_index, CowData<T> &p_cowdata) :
+	_FORCE_INLINE_ CharProxy(const int &p_index, CowData<T> &p_cowdata) :
 			_index(p_index),
 			_cowdata(p_cowdata) {}
 
@@ -80,7 +80,7 @@ public:
 	}
 };
 
-template <typename T>
+template <class T>
 class CharStringT {
 	friend class String;
 
@@ -90,19 +90,19 @@ class CharStringT {
 public:
 	_FORCE_INLINE_ T *ptrw() { return _cowdata.ptrw(); }
 	_FORCE_INLINE_ const T *ptr() const { return _cowdata.ptr(); }
-	_FORCE_INLINE_ int64_t size() const { return _cowdata.size(); }
-	Error resize(int64_t p_size) { return _cowdata.resize(p_size); }
+	_FORCE_INLINE_ int size() const { return _cowdata.size(); }
+	Error resize(int p_size) { return _cowdata.resize(p_size); }
 
-	_FORCE_INLINE_ T get(int64_t p_index) const { return _cowdata.get(p_index); }
-	_FORCE_INLINE_ void set(int64_t p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); }
-	_FORCE_INLINE_ const T &operator[](int64_t p_index) const {
+	_FORCE_INLINE_ T get(int p_index) const { return _cowdata.get(p_index); }
+	_FORCE_INLINE_ void set(int p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); }
+	_FORCE_INLINE_ const T &operator[](int p_index) const {
 		if (unlikely(p_index == _cowdata.size())) {
 			return _null;
 		}
 
 		return _cowdata.get(p_index);
 	}
-	_FORCE_INLINE_ CharProxy<T> operator[](int64_t p_index) { return CharProxy<T>(p_index, _cowdata); }
+	_FORCE_INLINE_ CharProxy<T> operator[](int p_index) { return CharProxy<T>(p_index, _cowdata); }
 
 	_FORCE_INLINE_ CharStringT() {}
 	_FORCE_INLINE_ CharStringT(const CharStringT<T> &p_str) { _cowdata._ref(p_str._cowdata); }
@@ -112,7 +112,7 @@ public:
 	void operator=(const T *p_cstr);
 	bool operator<(const CharStringT<T> &p_right) const;
 	CharStringT<T> &operator+=(T p_char);
-	int64_t length() const { return size() ? size() - 1 : 0; }
+	int length() const { return size() ? size() - 1 : 0; }
 	const T *get_data() const;
 	operator const T *() const { return get_data(); };
 
@@ -120,18 +120,6 @@ protected:
 	void copy_from(const T *p_cstr);
 };
 
-template <>
-const char *CharStringT<char>::get_data() const;
-
-template <>
-const char16_t *CharStringT<char16_t>::get_data() const;
-
-template <>
-const char32_t *CharStringT<char32_t>::get_data() const;
-
-template <>
-const wchar_t *CharStringT<wchar_t>::get_data() const;
-
 typedef CharStringT<char> CharString;
 typedef CharStringT<char16_t> Char16String;
 typedef CharStringT<char32_t> Char32String;

include/godot_cpp/variant/color_names.inc.hpp

@@ -28,9 +28,6 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
 /**************************************************************************/
 
-#ifndef GODOT_COLOR_NAMES_INC_HPP
-#define GODOT_COLOR_NAMES_INC_HPP
-
 namespace godot {
 
 // Names from https://en.wikipedia.org/wiki/X11_color_names
@@ -192,5 +189,3 @@ static NamedColor named_colors[] = {
 };
 
 } // namespace godot
-
-#endif // GODOT_COLOR_NAMES_INC_HPP

include/godot_cpp/variant/plane.hpp

@@ -77,7 +77,6 @@ struct _NO_DISCARD_ Plane {
 	Plane operator-() const { return Plane(-normal, -d); }
 	bool is_equal_approx(const Plane &p_plane) const;
 	bool is_equal_approx_any_side(const Plane &p_plane) const;
-	bool is_finite() const;
 
 	_FORCE_INLINE_ bool operator==(const Plane &p_plane) const;
 	_FORCE_INLINE_ bool operator!=(const Plane &p_plane) const;

include/godot_cpp/variant/quaternion.hpp

@@ -31,7 +31,6 @@
 #ifndef GODOT_QUATERNION_HPP
 #define GODOT_QUATERNION_HPP
 
-#include <godot_cpp/classes/global_constants.hpp>
 #include <godot_cpp/core/math.hpp>
 #include <godot_cpp/variant/vector3.hpp>
 
@@ -48,15 +47,14 @@ struct _NO_DISCARD_ Quaternion {
 		real_t components[4] = { 0, 0, 0, 1.0 };
 	};
 
-	_FORCE_INLINE_ real_t &operator[](int p_idx) {
-		return components[p_idx];
+	_FORCE_INLINE_ real_t &operator[](int idx) {
+		return components[idx];
 	}
-	_FORCE_INLINE_ const real_t &operator[](int p_idx) const {
-		return components[p_idx];
+	_FORCE_INLINE_ const real_t &operator[](int idx) const {
+		return components[idx];
 	}
 	_FORCE_INLINE_ real_t length_squared() const;
 	bool is_equal_approx(const Quaternion &p_quaternion) const;
-	bool is_finite() const;
 	real_t length() const;
 	void normalize();
 	Quaternion normalized() const;
@@ -67,13 +65,14 @@ struct _NO_DISCARD_ Quaternion {
 	_FORCE_INLINE_ real_t dot(const Quaternion &p_q) const;
 	real_t angle_to(const Quaternion &p_to) const;
 
-	Vector3 get_euler(EulerOrder p_order = EulerOrder::EULER_ORDER_YXZ) const;
-	static Quaternion from_euler(const Vector3 &p_euler);
+	Vector3 get_euler_xyz() const;
+	Vector3 get_euler_yxz() const;
+	Vector3 get_euler() const { return get_euler_yxz(); }
 
-	Quaternion slerp(const Quaternion &p_to, real_t p_weight) const;
-	Quaternion slerpni(const Quaternion &p_to, real_t p_weight) const;
-	Quaternion spherical_cubic_interpolate(const Quaternion &p_b, const Quaternion &p_pre_a, const Quaternion &p_post_b, real_t p_weight) const;
-	Quaternion spherical_cubic_interpolate_in_time(const Quaternion &p_b, const Quaternion &p_pre_a, const Quaternion &p_post_b, real_t p_weight, real_t p_b_t, real_t p_pre_a_t, real_t p_post_b_t) const;
+	Quaternion slerp(const Quaternion &p_to, const real_t &p_weight) const;
+	Quaternion slerpni(const Quaternion &p_to, const real_t &p_weight) const;
+	Quaternion spherical_cubic_interpolate(const Quaternion &p_b, const Quaternion &p_pre_a, const Quaternion &p_post_b, const real_t &p_weight) const;
+	Quaternion spherical_cubic_interpolate_in_time(const Quaternion &p_b, const Quaternion &p_pre_a, const Quaternion &p_post_b, const real_t &p_weight, const real_t &p_b_t, const real_t &p_pre_a_t, const real_t &p_post_b_t) const;
 
 	Vector3 get_axis() const;
 	real_t get_angle() const;
@@ -89,28 +88,28 @@ struct _NO_DISCARD_ Quaternion {
 	void operator*=(const Quaternion &p_q);
 	Quaternion operator*(const Quaternion &p_q) const;
 
-	_FORCE_INLINE_ Vector3 xform(const Vector3 &p_v) const {
+	_FORCE_INLINE_ Vector3 xform(const Vector3 &v) const {
 #ifdef MATH_CHECKS
-		ERR_FAIL_COND_V_MSG(!is_normalized(), p_v, "The quaternion " + operator String() + " must be normalized.");
+		ERR_FAIL_COND_V_MSG(!is_normalized(), v, "The quaternion must be normalized.");
 #endif
 		Vector3 u(x, y, z);
-		Vector3 uv = u.cross(p_v);
-		return p_v + ((uv * w) + u.cross(uv)) * ((real_t)2);
+		Vector3 uv = u.cross(v);
+		return v + ((uv * w) + u.cross(uv)) * ((real_t)2);
 	}
 
-	_FORCE_INLINE_ Vector3 xform_inv(const Vector3 &p_v) const {
-		return inverse().xform(p_v);
+	_FORCE_INLINE_ Vector3 xform_inv(const Vector3 &v) const {
+		return inverse().xform(v);
 	}
 
 	_FORCE_INLINE_ void operator+=(const Quaternion &p_q);
 	_FORCE_INLINE_ void operator-=(const Quaternion &p_q);
-	_FORCE_INLINE_ void operator*=(real_t p_s);
-	_FORCE_INLINE_ void operator/=(real_t p_s);
-	_FORCE_INLINE_ Quaternion operator+(const Quaternion &p_q2) const;
-	_FORCE_INLINE_ Quaternion operator-(const Quaternion &p_q2) const;
+	_FORCE_INLINE_ void operator*=(const real_t &s);
+	_FORCE_INLINE_ void operator/=(const real_t &s);
+	_FORCE_INLINE_ Quaternion operator+(const Quaternion &q2) const;
+	_FORCE_INLINE_ Quaternion operator-(const Quaternion &q2) const;
 	_FORCE_INLINE_ Quaternion operator-() const;
-	_FORCE_INLINE_ Quaternion operator*(real_t p_s) const;
-	_FORCE_INLINE_ Quaternion operator/(real_t p_s) const;
+	_FORCE_INLINE_ Quaternion operator*(const real_t &s) const;
+	_FORCE_INLINE_ Quaternion operator/(const real_t &s) const;
 
 	_FORCE_INLINE_ bool operator==(const Quaternion &p_quaternion) const;
 	_FORCE_INLINE_ bool operator!=(const Quaternion &p_quaternion) const;
@@ -128,6 +127,8 @@ struct _NO_DISCARD_ Quaternion {
 
 	Quaternion(const Vector3 &p_axis, real_t p_angle);
 
+	Quaternion(const Vector3 &p_euler);
+
 	Quaternion(const Quaternion &p_q) :
 			x(p_q.x),
 			y(p_q.y),
@@ -142,9 +143,9 @@ struct _NO_DISCARD_ Quaternion {
 		w = p_q.w;
 	}
 
-	Quaternion(const Vector3 &p_v0, const Vector3 &p_v1) { // Shortest arc.
-		Vector3 c = p_v0.cross(p_v1);
-		real_t d = p_v0.dot(p_v1);
+	Quaternion(const Vector3 &v0, const Vector3 &v1) { // Shortest arc.
+		Vector3 c = v0.cross(v1);
+		real_t d = v0.dot(v1);
 
 		if (d < -1.0f + (real_t)CMP_EPSILON) {
 			x = 0;
@@ -185,25 +186,25 @@ void Quaternion::operator-=(const Quaternion &p_q) {
 	w -= p_q.w;
 }
 
-void Quaternion::operator*=(real_t p_s) {
-	x *= p_s;
-	y *= p_s;
-	z *= p_s;
-	w *= p_s;
+void Quaternion::operator*=(const real_t &s) {
+	x *= s;
+	y *= s;
+	z *= s;
+	w *= s;
 }
 
-void Quaternion::operator/=(real_t p_s) {
-	*this *= 1.0f / p_s;
+void Quaternion::operator/=(const real_t &s) {
+	*this *= 1.0f / s;
 }
 
-Quaternion Quaternion::operator+(const Quaternion &p_q2) const {
+Quaternion Quaternion::operator+(const Quaternion &q2) const {
 	const Quaternion &q1 = *this;
-	return Quaternion(q1.x + p_q2.x, q1.y + p_q2.y, q1.z + p_q2.z, q1.w + p_q2.w);
+	return Quaternion(q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w);
 }
 
-Quaternion Quaternion::operator-(const Quaternion &p_q2) const {
+Quaternion Quaternion::operator-(const Quaternion &q2) const {
 	const Quaternion &q1 = *this;
-	return Quaternion(q1.x - p_q2.x, q1.y - p_q2.y, q1.z - p_q2.z, q1.w - p_q2.w);
+	return Quaternion(q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w);
 }
 
 Quaternion Quaternion::operator-() const {
@@ -211,12 +212,12 @@ Quaternion Quaternion::operator-() const {
 	return Quaternion(-q2.x, -q2.y, -q2.z, -q2.w);
 }
 
-Quaternion Quaternion::operator*(real_t p_s) const {
-	return Quaternion(x * p_s, y * p_s, z * p_s, w * p_s);
+Quaternion Quaternion::operator*(const real_t &s) const {
+	return Quaternion(x * s, y * s, z * s, w * s);
 }
 
-Quaternion Quaternion::operator/(real_t p_s) const {
-	return *this * (1.0f / p_s);
+Quaternion Quaternion::operator/(const real_t &s) const {
+	return *this * (1.0f / s);
 }
 
 bool Quaternion::operator==(const Quaternion &p_quaternion) const {
@@ -227,7 +228,7 @@ bool Quaternion::operator!=(const Quaternion &p_quaternion) const {
 	return x != p_quaternion.x || y != p_quaternion.y || z != p_quaternion.z || w != p_quaternion.w;
 }
 
-_FORCE_INLINE_ Quaternion operator*(real_t p_real, const Quaternion &p_quaternion) {
+_FORCE_INLINE_ Quaternion operator*(const real_t &p_real, const Quaternion &p_quaternion) {
 	return p_quaternion * p_real;
 }
 

include/godot_cpp/variant/rect2.hpp

@@ -146,7 +146,7 @@ struct _NO_DISCARD_ Rect2 {
 		return size.x > 0.0f && size.y > 0.0f;
 	}
 
-	// Returns the intersection between two Rect2s or an empty Rect2 if there is no intersection
+	// Returns the instersection between two Rect2s or an empty Rect2 if there is no intersection
 	inline Rect2 intersection(const Rect2 &p_rect) const {
 		Rect2 new_rect = p_rect;
 
@@ -209,7 +209,6 @@ struct _NO_DISCARD_ Rect2 {
 	}
 
 	bool is_equal_approx(const Rect2 &p_rect) const;
-	bool is_finite() const;
 
 	bool operator==(const Rect2 &p_rect) const { return position == p_rect.position && size == p_rect.size; }
 	bool operator!=(const Rect2 &p_rect) const { return position != p_rect.position || size != p_rect.size; }

include/godot_cpp/variant/rect2i.hpp

@@ -89,7 +89,7 @@ struct _NO_DISCARD_ Rect2i {
 		return size.x > 0 && size.y > 0;
 	}
 
-	// Returns the intersection between two Rect2is or an empty Rect2i if there is no intersection
+	// Returns the instersection between two Rect2is or an empty Rect2i if there is no intersection
 	inline Rect2i intersection(const Rect2i &p_rect) const {
 		Rect2i new_rect = p_rect;
 

include/godot_cpp/variant/transform2d.hpp

@@ -99,7 +99,6 @@ struct _NO_DISCARD_ Transform2D {
 	void orthonormalize();
 	Transform2D orthonormalized() const;
 	bool is_equal_approx(const Transform2D &p_transform) const;
-	bool is_finite() const;
 
 	Transform2D looking_at(const Vector2 &p_target) const;
 

include/godot_cpp/variant/transform3d.hpp

@@ -78,7 +78,6 @@ struct _NO_DISCARD_ Transform3D {
 	void orthogonalize();
 	Transform3D orthogonalized() const;
 	bool is_equal_approx(const Transform3D &p_transform) const;
-	bool is_finite() const;
 
 	bool operator==(const Transform3D &p_transform) const;
 	bool operator!=(const Transform3D &p_transform) const;

include/godot_cpp/variant/typed_array.hpp

@@ -36,7 +36,7 @@
 
 namespace godot {
 
-template <typename T>
+template <class T>
 class TypedArray : public Array {
 public:
 	_FORCE_INLINE_ void operator=(const Array &p_array) {
@@ -44,15 +44,10 @@ public:
 		_ref(p_array);
 	}
 	_FORCE_INLINE_ TypedArray(const Variant &p_variant) :
-			TypedArray(Array(p_variant)) {
+			Array(p_variant.operator Array(), Variant::OBJECT, T::get_class_static(), Variant()) {
 	}
-	_FORCE_INLINE_ TypedArray(const Array &p_array) {
-		set_typed(Variant::OBJECT, T::get_class_static(), Variant());
-		if (is_same_typed(p_array)) {
-			_ref(p_array);
-		} else {
-			assign(p_array);
-		}
+	_FORCE_INLINE_ TypedArray(const Array &p_array) :
+			Array(p_array, Variant::OBJECT, T::get_class_static(), Variant()) {
 	}
 	_FORCE_INLINE_ TypedArray() {
 		set_typed(Variant::OBJECT, T::get_class_static(), Variant());
@@ -70,15 +65,10 @@ public:
 			_ref(p_array);                                                                                       \
 		}                                                                                                        \
 		_FORCE_INLINE_ TypedArray(const Variant &p_variant) :                                                    \
-				TypedArray(Array(p_variant)) {                                                                   \
+				Array(p_variant.operator Array(), m_variant_type, StringName(), Variant()) {                     \
 		}                                                                                                        \
-		_FORCE_INLINE_ TypedArray(const Array &p_array) {                                                        \
-			set_typed(m_variant_type, StringName(), Variant());                                                  \
-			if (is_same_typed(p_array)) {                                                                        \
-				_ref(p_array);                                                                                   \
-			} else {                                                                                             \
-				assign(p_array);                                                                                 \
-			}                                                                                                    \
+		_FORCE_INLINE_ TypedArray(const Array &p_array) :                                                        \
+				Array(p_array, m_variant_type, StringName(), Variant()) {                                        \
 		}                                                                                                        \
 		_FORCE_INLINE_ TypedArray() {                                                                            \
 			set_typed(m_variant_type, StringName(), Variant());                                                  \

include/godot_cpp/variant/variant.hpp

@@ -47,6 +47,8 @@ class ObjectID;
 class Variant {
 	uint8_t opaque[GODOT_CPP_VARIANT_SIZE]{ 0 };
 
+	_FORCE_INLINE_ GDExtensionVariantPtr _native_ptr() const { return const_cast<uint8_t(*)[GODOT_CPP_VARIANT_SIZE]>(&opaque); }
+
 	friend class GDExtensionBinding;
 	friend class MethodBind;
 
@@ -120,7 +122,6 @@ public:
 		OP_NEGATE,
 		OP_POSITIVE,
 		OP_MODULE,
-		OP_POWER,
 		// bitwise
 		OP_SHIFT_LEFT,
 		OP_SHIFT_RIGHT,
@@ -143,7 +144,6 @@ private:
 	static GDExtensionTypeFromVariantConstructorFunc to_type_constructor[VARIANT_MAX];
 
 public:
-	_FORCE_INLINE_ GDExtensionVariantPtr _native_ptr() const { return const_cast<uint8_t(*)[GODOT_CPP_VARIANT_SIZE]>(&opaque); }
 	Variant();
 	Variant(std::nullptr_t n) :
 			Variant() {}
@@ -154,17 +154,9 @@ public:
 	Variant(int64_t v);
 	Variant(int32_t v) :
 			Variant(static_cast<int64_t>(v)) {}
-	Variant(int16_t v) :
-			Variant(static_cast<int64_t>(v)) {}
-	Variant(int8_t v) :
-			Variant(static_cast<int64_t>(v)) {}
-	Variant(uint64_t v) :
-			Variant(static_cast<int64_t>(v)) {}
 	Variant(uint32_t v) :
 			Variant(static_cast<int64_t>(v)) {}
-	Variant(uint16_t v) :
-			Variant(static_cast<int64_t>(v)) {}
-	Variant(uint8_t v) :
+	Variant(uint64_t v) :
 			Variant(static_cast<int64_t>(v)) {}
 	Variant(double v);
 	Variant(float v) :
@@ -217,12 +209,8 @@ public:
 	operator bool() const;
 	operator int64_t() const;
 	operator int32_t() const;
-	operator int16_t() const;
-	operator int8_t() const;
 	operator uint64_t() const;
 	operator uint32_t() const;
-	operator uint16_t() const;
-	operator uint8_t() const;
 	operator double() const;
 	operator float() const;
 	operator String() const;
@@ -267,33 +255,25 @@ public:
 	bool operator!=(const Variant &other) const;
 	bool operator<(const Variant &other) const;
 
-	void callp(const StringName &method, const Variant **args, int argcount, Variant &r_ret, GDExtensionCallError &r_error);
+	void call(const StringName &method, const Variant **args, int argcount, Variant &r_ret, GDExtensionCallError &r_error);
 
-	template <typename... Args>
+	template <class... Args>
 	Variant call(const StringName &method, Args... args) {
-		std::array<Variant, sizeof...(args)> vargs = { args... };
-		std::array<const Variant *, sizeof...(args)> argptrs;
-		for (size_t i = 0; i < vargs.size(); i++) {
-			argptrs[i] = &vargs[i];
-		}
 		Variant result;
 		GDExtensionCallError error;
-		callp(method, argptrs.data(), argptrs.size(), result, error);
+		std::array<GDExtensionConstVariantPtr, sizeof...(Args)> call_args = { Variant(args)... };
+		call(method, call_args.data(), call_args.size(), result, error);
 		return result;
 	}
 
-	static void callp_static(Variant::Type type, const StringName &method, const Variant **args, int argcount, Variant &r_ret, GDExtensionCallError &r_error);
+	static void call_static(Variant::Type type, const StringName &method, const Variant **args, int argcount, Variant &r_ret, GDExtensionCallError &r_error);
 
-	template <typename... Args>
+	template <class... Args>
 	static Variant call_static(Variant::Type type, const StringName &method, Args... args) {
-		std::array<Variant, sizeof...(args)> vargs = { args... };
-		std::array<const Variant *, sizeof...(args)> argptrs;
-		for (size_t i = 0; i < vargs.size(); i++) {
-			argptrs[i] = &vargs[i];
-		}
 		Variant result;
 		GDExtensionCallError error;
-		callp_static(type, method, argptrs.data(), argptrs.size(), sizeof...(args), result, error);
+		std::array<GDExtensionConstVariantPtr, sizeof...(Args)> call_args = { Variant(args)... };
+		call_static(type, method, call_args.data(), call_args.size(), result, error);
 		return result;
 	}
 
@@ -324,6 +304,8 @@ public:
 	bool booleanize() const;
 	String stringify() const;
 	Variant duplicate(bool deep = false) const;
+	static void blend(const Variant &a, const Variant &b, float c, Variant &r_dst);
+	static void interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst);
 
 	static String get_type_name(Variant::Type type);
 	static bool can_convert(Variant::Type from, Variant::Type to);
@@ -352,14 +334,6 @@ String vformat(const String &p_text, const VarArgs... p_args) {
 	return p_text % args_array;
 }
 
-#include <godot_cpp/variant/builtin_vararg_methods.hpp>
-
-#ifdef REAL_T_IS_DOUBLE
-using PackedRealArray = PackedFloat64Array;
-#else
-using PackedRealArray = PackedFloat32Array;
-#endif // REAL_T_IS_DOUBLE
-
 } // namespace godot
 
 #endif // GODOT_VARIANT_HPP

include/godot_cpp/variant/vector2.hpp

@@ -123,7 +123,6 @@ struct _NO_DISCARD_ Vector2 {
 
 	bool is_equal_approx(const Vector2 &p_v) const;
 	bool is_zero_approx() const;
-	bool is_finite() const;
 
 	Vector2 operator+(const Vector2 &p_v) const;
 	void operator+=(const Vector2 &p_v);

include/godot_cpp/variant/vector3.hpp

@@ -146,7 +146,6 @@ struct _NO_DISCARD_ Vector3 {
 
 	bool is_equal_approx(const Vector3 &p_v) const;
 	bool is_zero_approx() const;
-	bool is_finite() const;
 
 	/* Operators */
 

include/godot_cpp/variant/vector4.hpp

@@ -55,17 +55,16 @@ struct _NO_DISCARD_ Vector4 {
 			real_t z;
 			real_t w;
 		};
-		[[deprecated("Use coord instead")]] real_t components[4];
-		real_t coord[4] = { 0, 0, 0, 0 };
+		real_t components[4] = { 0, 0, 0, 0 };
 	};
 
 	_FORCE_INLINE_ real_t &operator[](const int p_axis) {
 		DEV_ASSERT((unsigned int)p_axis < 4);
-		return coord[p_axis];
+		return components[p_axis];
 	}
 	_FORCE_INLINE_ const real_t &operator[](const int p_axis) const {
 		DEV_ASSERT((unsigned int)p_axis < 4);
-		return coord[p_axis];
+		return components[p_axis];
 	}
 
 	Vector4::Axis min_axis_index() const;
@@ -82,7 +81,6 @@ struct _NO_DISCARD_ Vector4 {
 	_FORCE_INLINE_ real_t length_squared() const;
 	bool is_equal_approx(const Vector4 &p_vec4) const;
 	bool is_zero_approx() const;
-	bool is_finite() const;
 	real_t length() const;
 	void normalize();
 	Vector4 normalized() const;

misc/hooks/README.md

@@ -0,0 +1,37 @@
+# Git hooks for Godot Engine
+
+This folder contains Git hooks meant to be installed locally by Godot Engine
+contributors to make sure they comply with our requirements.
+
+## List of hooks
+
+- Pre-commit hook for `clang-format`: Applies `clang-format` to the staged
+  files before accepting a commit; blocks the commit and generates a patch if
+  the style is not respected.
+  You may need to edit the file if your `clang-format` binary is not in the
+  `PATH`, or if you want to enable colored output with `pygmentize`.
+- Pre-commit hook for `black`: Applies `black` to the staged Python files
+  before accepting a commit.
+- Pre-commit hook for `make_rst`: Checks the class reference syntax using
+  `make_rst.py`.
+
+## Installation
+
+Copy all the files from this folder into your `.git/hooks` folder, and make
+sure the hooks and helper scripts are executable.
+
+#### Linux/MacOS
+
+The hooks rely on bash scripts and tools which should be in the system `PATH`,
+so they should work out of the box on Linux/macOS.
+
+#### Windows
+
+##### clang-format
+- Download LLVM for Windows (version 13 or later) from
+  <https://releases.llvm.org/download.html>
+- Make sure LLVM is added to the `PATH` during installation
+
+##### black
+- Python installation: make sure Python is added to the `PATH`
+- Install `black` - in any console: `pip3 install black`

misc/hooks/canonicalize_filename.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+
+# Provide the canonicalize filename (physical filename with out any symlinks)
+# like the GNU version readlink with the -f option regardless of the version of
+# readlink (GNU or BSD).
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+###########################################################
+# There should be no need to change anything below this line.
+
+# Canonicalize by recursively following every symlink in every component of the
+# specified filename. This should reproduce the results of the GNU version of
+# readlink with the -f option.
+#
+# Reference: https://stackoverflow.com/questions/1055671/how-can-i-get-the-behavior-of-gnus-readlink-f-on-a-mac
+canonicalize_filename () {
+    local target_file="$1"
+    local physical_directory=""
+    local result=""
+
+    # Need to restore the working directory after work.
+    local working_dir="`pwd`"
+
+    cd -- "$(dirname -- "$target_file")"
+    target_file="$(basename -- "$target_file")"
+
+    # Iterate down a (possible) chain of symlinks
+    while [ -L "$target_file" ]
+    do
+        target_file="$(readlink -- "$target_file")"
+        cd -- "$(dirname -- "$target_file")"
+        target_file="$(basename -- "$target_file")"
+    done
+
+    # Compute the canonicalized name by finding the physical path
+    # for the directory we're in and appending the target file.
+    physical_directory="`pwd -P`"
+    result="$physical_directory/$target_file"
+
+    # restore the working directory after work.
+    cd -- "$working_dir"
+
+    echo "$result"
+}

misc/hooks/pre-commit

@@ -0,0 +1,50 @@
+#!/bin/sh
+# Git pre-commit hook that runs multiple hooks specified in $HOOKS.
+# Make sure this script is executable. Bypass hooks with git commit --no-verify.
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+
+###########################################################
+# CONFIGURATION:
+# pre-commit hooks to be executed. They should be in the same .git/hooks/ folder
+# as this script. Hooks should return 0 if successful and nonzero to cancel the
+# commit. They are executed in the order in which they are listed.
+#HOOKS="pre-commit-compile pre-commit-uncrustify"
+HOOKS="pre-commit-clang-format pre-commit-black"
+###########################################################
+# There should be no need to change anything below this line.
+
+. "$(dirname -- "$0")/canonicalize_filename.sh"
+
+# exit on error
+set -e
+
+# Absolute path to this script, e.g. /home/user/bin/foo.sh
+SCRIPT="$(canonicalize_filename "$0")"
+
+# Absolute path this script is in, thus /home/user/bin
+SCRIPTPATH="$(dirname -- "$SCRIPT")"
+
+
+for hook in $HOOKS
+do
+    echo "Running hook: $hook"
+    # run hook if it exists
+    # if it returns with nonzero exit with 1 and thus abort the commit
+    if [ -f "$SCRIPTPATH/$hook" ]; then
+        "$SCRIPTPATH/$hook"
+        if [ $? != 0 ]; then
+            exit 1
+        fi
+    else
+        echo "Error: file $hook not found."
+        echo "Aborting commit. Make sure the hook is in $SCRIPTPATH and executable."
+        echo "You can disable it by removing it from the list in $SCRIPT."
+        echo "You can skip all pre-commit hooks with --no-verify (not recommended)."
+        exit 1
+    fi
+done

misc/hooks/pre-commit-black

@@ -0,0 +1,202 @@
+#!/usr/bin/env bash
+
+# git pre-commit hook that runs a black stylecheck.
+# Based on pre-commit-clang-format.
+
+##################################################################
+# SETTINGS
+# Set path to black binary.
+BLACK=`which black 2>/dev/null`
+BLACK_OPTIONS="-l 120"
+
+# Remove any older patches from previous commits. Set to true or false.
+DELETE_OLD_PATCHES=false
+
+# File types to parse.
+FILE_NAMES="SConstruct SCsub"
+FILE_EXTS=".py"
+
+# Use pygmentize instead of cat to parse diff with highlighting.
+# Install it with `pip install pygments` (Linux) or `easy_install Pygments` (Mac)
+PYGMENTIZE=`which pygmentize 2>/dev/null`
+if [ ! -z "$PYGMENTIZE" ]; then
+  READER="pygmentize -l diff"
+else
+  READER=cat
+fi
+
+# Path to zenity
+ZENITY=`which zenity 2>/dev/null`
+
+# Path to xmessage
+XMSG=`which xmessage 2>/dev/null`
+
+# Path to powershell (Windows only)
+PWSH=`which powershell 2>/dev/null`
+
+##################################################################
+# There should be no need to change anything below this line.
+
+. "$(dirname -- "$0")/canonicalize_filename.sh"
+
+# exit on error
+set -e
+
+# check whether the given file matches any of the set extensions
+matches_name_or_extension() {
+    local filename=$(basename "$1")
+    local extension=".${filename##*.}"
+
+    for name in $FILE_NAMES; do [[ "$name" == "$filename" ]] && return 0; done
+    for ext in $FILE_EXTS; do [[ "$ext" == "$extension" ]] && return 0; done
+
+    return 1
+}
+
+# necessary check for initial commit
+if git rev-parse --verify HEAD >/dev/null 2>&1 ; then
+    against=HEAD
+else
+    # Initial commit: diff against an empty tree object
+    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+if [ ! -x "$BLACK" ] ; then
+    if [ ! -t 1 ] ; then
+        if [ -x "$ZENITY" ] ; then
+            $ZENITY --error --title="Error" --text="Error: black executable not found."
+            exit 1
+        elif [ -x "$XMSG" ] ; then
+            $XMSG -center -title "Error" "Error: black executable not found."
+            exit 1
+        elif [ \( \( "$OSTYPE" = "msys" \) -o \( "$OSTYPE" = "win32" \) \) -a \( -x "$PWSH" \) ]; then
+            winmessage="$(canonicalize_filename "./.git/hooks/winmessage.ps1")"
+            $PWSH -noprofile -executionpolicy bypass -file "$winmessage" -center -title "Error" --text "Error: black executable not found."
+            exit 1
+        fi
+    fi
+    printf "Error: black executable not found.\n"
+    printf "Set the correct path in $(canonicalize_filename "$0").\n"
+    exit 1
+fi
+
+# create a random filename to store our generated patch
+prefix="pre-commit-black"
+suffix="$(date +%s)"
+patch="/tmp/$prefix-$suffix.patch"
+
+# clean up any older black patches
+$DELETE_OLD_PATCHES && rm -f /tmp/$prefix*.patch
+
+# create one patch containing all changes to the files
+git diff-index --cached --diff-filter=ACMR --name-only $against -- | while read file;
+do
+    # ignore thirdparty files
+    if grep -q "thirdparty" <<< $file; then
+        continue;
+    fi
+
+    # ignore file if not one of the names or extensions we handle
+    if ! matches_name_or_extension "$file"; then
+        continue;
+    fi
+
+    # format our file with black, create a patch with diff and append it to our $patch
+    # The sed call is necessary to transform the patch from
+    #    --- $file timestamp
+    #    +++ $file timestamp
+    # to both lines working on the same file and having a/ and b/ prefix.
+    # Else it can not be applied with 'git apply'.
+    "$BLACK" "$BLACK_OPTIONS" --diff "$file" | \
+        sed -e "1s|--- |--- a/|" -e "2s|+++ |+++ b/|" >> "$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 black formatter rules.\n"
+    rm -f "$patch"
+    exit 0
+fi
+
+# a patch has been created, notify the user and exit
+printf "\nThe following differences were found between the code to commit "
+printf "and the black formatter rules:\n\n"
+
+if [ -t 1 ] ; then
+    $READER "$patch"
+    printf "\n"
+    # Allows us to read user input below, assigns stdin to keyboard
+    exec < /dev/tty
+    terminal="1"
+else
+    cat "$patch"
+    printf "\n"
+    # Allows non zero zenity/powershell output
+    set +e
+    terminal="0"
+fi
+
+while true; do
+    if [ $terminal = "0" ] ; then
+        if [ -x "$ZENITY" ] ; then
+            choice=$($ZENITY --text-info --filename="$patch" --width=800 --height=600 --title="Do you want to apply that patch?" --ok-label="Apply" --cancel-label="Do not apply" --extra-button="Apply and stage")
+            if [ "$?" = "0" ] ; then
+                yn="Y"
+            else
+                if [ "$choice" = "Apply and stage" ] ; then
+                    yn="S"
+                else
+                    yn="N"
+                fi
+            fi
+        elif [ -x "$XMSG" ] ; then
+            $XMSG -file "$patch" -buttons "Apply":100,"Apply and stage":200,"Do not apply":0 -center -default "Do not apply" -geometry 800x600 -title "Do you want to apply that patch?"
+            choice=$?
+            if [ "$choice" = "100" ] ; then
+                yn="Y"
+            elif [ "$choice" = "200" ] ; then
+                yn="S"
+            else
+                yn="N"
+            fi
+        elif [ \( \( "$OSTYPE" = "msys" \) -o \( "$OSTYPE" = "win32" \) \) -a \( -x "$PWSH" \) ]; then
+            winmessage="$(canonicalize_filename "./.git/hooks/winmessage.ps1")"
+            $PWSH -noprofile -executionpolicy bypass -file "$winmessage" -file "$patch" -buttons "Apply":100,"Apply and stage":200,"Do not apply":0 -center -default "Do not apply" -geometry 800x600 -title "Do you want to apply that patch?"
+            choice=$?
+            if [ "$choice" = "100" ] ; then
+                yn="Y"
+            elif [ "$choice" = "200" ] ; then
+                yn="S"
+            else
+                yn="N"
+            fi
+        else
+            printf "Error: zenity, xmessage, or powershell executable not found.\n"
+            exit 1
+        fi
+    else
+        read -p "Do you want to apply that patch (Y - Apply, N - Do not apply, S - Apply and stage files)? [Y/N/S] " yn
+    fi
+    case $yn in
+        [Yy] ) git apply $patch;
+        printf "The patch was applied. You can now stage the changes and commit again.\n\n";
+        break
+        ;;
+        [Nn] ) printf "\nYou can apply these changes with:\n  git apply $patch\n";
+        printf "(may need to be called from the root directory of your repository)\n";
+        printf "Aborting commit. Apply changes and commit again or skip checking with";
+        printf " --no-verify (not recommended).\n\n";
+        break
+        ;;
+        [Ss] ) git apply $patch;
+        git diff-index --cached --diff-filter=ACMR --name-only $against -- | while read file;
+        do git add $file;
+        done
+        printf "The patch was applied and the changed files staged. You can now commit.\n\n";
+        break
+        ;;
+        * ) echo "Please answer yes or no."
+        ;;
+    esac
+done
+exit 1 # we don't commit in any case

misc/hooks/pre-commit-clang-format

@@ -0,0 +1,242 @@
+#!/usr/bin/env bash
+
+# git pre-commit hook that runs a clang-format stylecheck.
+# Features:
+#  - abort commit when commit does not comply with the style guidelines
+#  - create a patch of the proposed style changes
+# Modifications for clang-format by rene.milk@wwu.de
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+# Some quality of life modifications made for Godot Engine.
+
+##################################################################
+# SETTINGS
+# Set path to clang-format binary.
+CLANG_FORMAT=`which clang-format 2>/dev/null`
+
+# Remove any older patches from previous commits. Set to true or false.
+DELETE_OLD_PATCHES=false
+
+# Only parse files with the extensions in FILE_EXTS. Set to true or false.
+# If false every changed file in the commit will be parsed with clang-format.
+# If true only files matching one of the extensions are parsed with clang-format.
+PARSE_EXTS=true
+
+# File types to parse. Only effective when PARSE_EXTS is true.
+FILE_EXTS=".c .h .cpp .hpp .cc .hh .cxx .m .mm .inc .java .glsl"
+
+# Use pygmentize instead of cat to parse diff with highlighting.
+# Install it with `pip install pygments` (Linux) or `easy_install Pygments` (Mac)
+PYGMENTIZE=`which pygmentize 2>/dev/null`
+if [ ! -z "$PYGMENTIZE" ]; then
+  READER="pygmentize -l diff"
+else
+  READER=cat
+fi
+
+# Path to zenity
+ZENITY=`which zenity 2>/dev/null`
+
+# Path to xmessage
+XMSG=`which xmessage 2>/dev/null`
+
+# Path to powershell (Windows only)
+PWSH=`which powershell 2>/dev/null`
+
+##################################################################
+# There should be no need to change anything below this line.
+
+. "$(dirname -- "$0")/canonicalize_filename.sh"
+
+# exit on error
+set -e
+
+# check whether the given file matches any of the set extensions
+matches_extension() {
+    local filename=$(basename "$1")
+    local extension=".${filename##*.}"
+    local ext
+
+    for ext in $FILE_EXTS; do [[ "$ext" == "$extension" ]] && return 0; done
+
+    return 1
+}
+
+# necessary check for initial commit
+if git rev-parse --verify HEAD >/dev/null 2>&1 ; then
+    against=HEAD
+else
+    # Initial commit: diff against an empty tree object
+    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+# To get consistent formatting, we recommend contributors to use the same
+# clang-format version as CI.
+RECOMMENDED_CLANG_FORMAT_MAJOR_MIN="12"
+RECOMMENDED_CLANG_FORMAT_MAJOR_MAX="13"
+
+if [ ! -x "$CLANG_FORMAT" ] ; then
+	message="Error: clang-format executable not found. Please install clang-format $RECOMMENDED_CLANG_FORMAT_MAJOR_MAX."
+
+    if [ ! -t 1 ] ; then
+        if [ -x "$ZENITY" ] ; then
+            $ZENITY --error --title="Error" --text="$message"
+            exit 1
+        elif [ -x "$XMSG" ] ; then
+            $XMSG -center -title "Error" "$message"
+            exit 1
+        elif [ \( \( "$OSTYPE" = "msys" \) -o \( "$OSTYPE" = "win32" \) \) -a \( -x "$PWSH" \) ]; then
+            winmessage="$(canonicalize_filename "./.git/hooks/winmessage.ps1")"
+            $PWSH -noprofile -executionpolicy bypass -file "$winmessage" -center -title "Error" --text "$message"
+            exit 1
+        fi
+    fi
+    printf "$message\n"
+    printf "Set the correct path in $(canonicalize_filename "$0").\n"
+    exit 1
+fi
+
+# The returned string can be inconsistent depending on where clang-format comes from.
+# Example output strings reported by `clang-format --version`:
+# - Ubuntu: "Ubuntu clang-format version 11.0.0-2"
+# - Fedora: "clang-format version 11.0.0 (Fedora 11.0.0-2.fc33)"
+CLANG_FORMAT_VERSION="$(clang-format --version | sed "s/[^0-9\.]*\([0-9\.]*\).*/\1/")"
+CLANG_FORMAT_MAJOR="$(echo "$CLANG_FORMAT_VERSION" | cut -d. -f1)"
+
+if [[ "$CLANG_FORMAT_MAJOR" -lt "$RECOMMENDED_CLANG_FORMAT_MAJOR_MIN" || "$CLANG_FORMAT_MAJOR" -gt "$RECOMMENDED_CLANG_FORMAT_MAJOR_MAX" ]]; then
+    echo "Warning: Your clang-format binary is the wrong version ($CLANG_FORMAT_VERSION, expected between $RECOMMENDED_CLANG_FORMAT_MAJOR_MIN and $RECOMMENDED_CLANG_FORMAT_MAJOR_MAX)."
+    echo "         Consider upgrading or downgrading clang-format as formatting may not be applied correctly."
+fi
+
+# create a random filename to store our generated patch
+prefix="pre-commit-clang-format"
+suffix="$(date +%s)"
+patch="/tmp/$prefix-$suffix.patch"
+
+# clean up any older clang-format patches
+$DELETE_OLD_PATCHES && rm -f /tmp/$prefix*.patch
+
+# create one patch containing all changes to the files
+git diff-index --cached --diff-filter=ACMR --name-only $against -- | while read file;
+do
+    # ignore thirdparty files
+    if grep -q "thirdparty" <<< $file; then
+        continue;
+    fi
+    if grep -q "platform/android/java/lib/src/com" <<< $file; then
+        continue;
+    fi
+    if grep -q "\-so_wrap." <<< $file; then
+        continue;
+    fi
+
+    # ignore file if we do check for file extensions and the file
+    # does not match any of the extensions specified in $FILE_EXTS
+    if $PARSE_EXTS && ! matches_extension "$file"; then
+        continue;
+    fi
+
+    # clang-format our sourcefile, create a patch with diff and append it to our $patch
+    # The sed call is necessary to transform the patch from
+    #    --- $file timestamp
+    #    +++ - timestamp
+    # to both lines working on the same file and having a/ and b/ prefix.
+    # Else it can not be applied with 'git apply'.
+    "$CLANG_FORMAT" -style=file "$file" --Wno-error=unknown | \
+        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 "\nThe following differences were found between the code to commit "
+printf "and the clang-format rules:\n\n"
+
+if [ -t 1 ] ; then
+    $READER "$patch"
+    printf "\n"
+    # Allows us to read user input below, assigns stdin to keyboard
+    exec < /dev/tty
+    terminal="1"
+else
+    cat "$patch"
+    printf "\n"
+    # Allows non zero zenity/powershell output
+    set +e
+    terminal="0"
+fi
+
+while true; do
+    if [ $terminal = "0" ] ; then
+        if [ -x "$ZENITY" ] ; then
+            choice=$($ZENITY --text-info --filename="$patch" --width=800 --height=600 --title="Do you want to apply that patch?" --ok-label="Apply" --cancel-label="Do not apply" --extra-button="Apply and stage")
+            if [ "$?" = "0" ] ; then
+                yn="Y"
+            else
+                if [ "$choice" = "Apply and stage" ] ; then
+                    yn="S"
+                else
+                    yn="N"
+                fi
+            fi
+        elif [ -x "$XMSG" ] ; then
+            $XMSG -file "$patch" -buttons "Apply":100,"Apply and stage":200,"Do not apply":0 -center -default "Do not apply" -geometry 800x600 -title "Do you want to apply that patch?"
+            choice=$?
+            if [ "$choice" = "100" ] ; then
+                yn="Y"
+            elif [ "$choice" = "200" ] ; then
+                yn="S"
+            else
+                yn="N"
+            fi
+        elif [ \( \( "$OSTYPE" = "msys" \) -o \( "$OSTYPE" = "win32" \) \) -a \( -x "$PWSH" \) ]; then
+            winmessage="$(canonicalize_filename "./.git/hooks/winmessage.ps1")"
+            $PWSH -noprofile -executionpolicy bypass -file "$winmessage" -file "$patch" -buttons "Apply":100,"Apply and stage":200,"Do not apply":0 -center -default "Do not apply" -geometry 800x600 -title "Do you want to apply that patch?"
+            choice=$?
+            if [ "$choice" = "100" ] ; then
+                yn="Y"
+            elif [ "$choice" = "200" ] ; then
+                yn="S"
+            else
+                yn="N"
+            fi
+        else
+            printf "Error: zenity, xmessage, or powershell executable not found.\n"
+            exit 1
+        fi
+    else
+        read -p "Do you want to apply that patch (Y - Apply, N - Do not apply, S - Apply and stage files)? [Y/N/S] " yn
+    fi
+    case $yn in
+        [Yy] ) git apply $patch;
+        printf "The patch was applied. You can now stage the changes and commit again.\n\n";
+        break
+        ;;
+        [Nn] ) printf "\nYou can apply these changes with:\n  git apply $patch\n";
+        printf "(may need to be called from the root directory of your repository)\n";
+        printf "Aborting commit. Apply changes and commit again or skip checking with";
+        printf " --no-verify (not recommended).\n\n";
+        break
+        ;;
+        [Ss] ) git apply $patch;
+        git diff-index --cached --diff-filter=ACMR --name-only $against -- | while read file;
+        do git add $file;
+        done
+        printf "The patch was applied and the changed files staged. You can now commit.\n\n";
+        break
+        ;;
+        * ) echo "Please answer yes or no."
+        ;;
+    esac
+done
+exit 1 # we don't commit in any case

misc/hooks/winmessage.ps1

@@ -0,0 +1,103 @@
+Param (
+	[string]$file = "",
+	[string]$text = "",
+	[string]$buttons = "OK:0",
+	[string]$default = "",
+	[switch]$nearmouse = $false,
+	[switch]$center = $false,
+	[string]$geometry = "",
+	[int32]$timeout = 0,
+	[string]$title = "Message"
+)
+Add-Type -assembly System.Windows.Forms
+
+$global:Result = 0
+
+$main_form = New-Object System.Windows.Forms.Form
+$main_form.Text = $title
+
+$geometry_data = $geometry.Split("+")
+if ($geometry_data.Length -ge 1) {
+	$size_data = $geometry_data[0].Split("x")
+	if ($size_data.Length -eq 2) {
+		$main_form.Width = $size_data[0]
+		$main_form.Height = $size_data[1]
+	}
+}
+if ($geometry_data.Length -eq 3) {
+	$main_form.StartPosition = [System.Windows.Forms.FormStartPosition]::Manual
+	$main_form.Location = New-Object System.Drawing.Point($geometry_data[1], $geometry_data[2])
+}
+if ($nearmouse) {
+	$main_form.StartPosition = [System.Windows.Forms.FormStartPosition]::Manual
+	$main_form.Location = System.Windows.Forms.Cursor.Position
+}
+if ($center) {
+	$main_form.StartPosition = [System.Windows.Forms.FormStartPosition]::CenterScreen
+}
+
+$main_form.SuspendLayout()
+
+$button_panel = New-Object System.Windows.Forms.FlowLayoutPanel
+$button_panel.SuspendLayout()
+$button_panel.FlowDirection = [System.Windows.Forms.FlowDirection]::RightToLeft
+$button_panel.Dock = [System.Windows.Forms.DockStyle]::Bottom
+$button_panel.Autosize = $true
+
+if ($file -ne "") {
+	$text = [IO.File]::ReadAllText($file).replace("`n", "`r`n")
+}
+
+if ($text -ne "") {
+	$text_box = New-Object System.Windows.Forms.TextBox
+	$text_box.Multiline = $true
+	$text_box.ReadOnly = $true
+	$text_box.Autosize = $true
+	$text_box.Text = $text
+	$text_box.Select(0,0)
+	$text_box.Dock = [System.Windows.Forms.DockStyle]::Fill
+	$main_form.Controls.Add($text_box)
+}
+
+$buttons_array = $buttons.Split(",")
+foreach ($button in $buttons_array) {
+	$button_data = $button.Split(":")
+	$button_ctl = New-Object System.Windows.Forms.Button
+	if ($button_data.Length -eq 2) {
+		$button_ctl.Tag = $button_data[1]
+	} else {
+		$button_ctl.Tag = 100 + $buttons_array.IndexOf($button)
+	}
+	if ($default -eq $button_data[0]) {
+		$main_form.AcceptButton = $button_ctl
+	}
+	$button_ctl.Autosize = $true
+	$button_ctl.Text = $button_data[0]
+	$button_ctl.Add_Click(
+		{
+			Param($sender)
+			$global:Result = $sender.Tag
+			$main_form.Close()
+		}
+	)
+	$button_panel.Controls.Add($button_ctl)
+}
+$main_form.Controls.Add($button_panel)
+
+$button_panel.ResumeLayout($false)
+$main_form.ResumeLayout($false)
+
+if ($timeout -gt 0) {
+	$timer = New-Object System.Windows.Forms.Timer
+	$timer.Add_Tick(
+		{
+			$global:Result = 0
+			$main_form.Close()
+		}
+	)
+	$timer.Interval = $timeout
+	$timer.Start()
+}
+$dlg_res = $main_form.ShowDialog()
+
+[Environment]::Exit($global:Result)

misc/scripts/black_format.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+# This script runs black on all Python files in the repo.
+
+set -uo pipefail
+
+# Apply black.
+echo -e "Formatting Python files..."
+PY_FILES=$(git ls-files -- '*SConstruct' '*SCsub' '*.py' ':!:.git/*' ':!:thirdparty/*')
+black -l 120 $PY_FILES
+
+diff=$(git diff --color)
+
+# If no patch has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "Files in this commit comply with the black style rules.\n"
+    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"
+echo "$diff"
+printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+exit 1

misc/scripts/check_ci_log.py

@@ -9,8 +9,8 @@ if len(sys.argv) < 2:
 
 fname = sys.argv[1]
 
-with open(fname.strip(), "r", encoding="utf-8") as fileread:
-    file_contents = fileread.read()
+fileread = open(fname.strip(), "r")
+file_contents = fileread.read()
 
 # If find "ERROR: AddressSanitizer:", then happens invalid read or write
 # This is critical bug, so we need to fix this as fast as possible
@@ -25,8 +25,6 @@ if (
     file_contents.find("Program crashed with signal") != -1
     or file_contents.find("Dumping the backtrace") != -1
     or file_contents.find("Segmentation fault (core dumped)") != -1
-    or file_contents.find("Aborted (core dumped)") != -1
-    or file_contents.find("terminate called without an active exception") != -1
 ):
     print("FATAL ERROR: Godot has been crashed.")
     sys.exit(52)

misc/scripts/check_get_file_list.py

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

misc/scripts/clang_format.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+# This script runs clang-format and fixes copyright headers on all relevant files in the repo.
+# This is the primary script responsible for fixing style violations.
+
+set -uo pipefail
+
+# Loops through all code files tracked by Git.
+git ls-files -- '*.c' '*.h' '*.cpp' '*.hpp' '*.cc' '*.hh' '*.cxx' '*.m' '*.mm' '*.inc' |
+while read -r f; do
+    # Run clang-format.
+    clang-format --Wno-error=unknown -i "$f"
+
+    # Fix copyright headers, but not all files get them.
+    if [[ "$f" == *"inc" ]]; then
+        continue
+    elif [[ "$f" == *"glsl" ]]; then
+        continue
+    elif [[ "$f" == "test/"* ]]; then
+        continue
+    fi
+
+    python misc/scripts/copyright_headers.py "$f"
+done
+
+diff=$(git diff --color)
+
+# If no patch has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "Files in this commit comply with the clang-tidy style rules.\n"
+    exit 0
+fi
+
+# A patch has been created, notify the user, clean up, and exit.
+printf "\n*** The following changes have been made to comply with the formatting rules:\n\n"
+echo "$diff"
+printf "\n*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+exit 1

misc/scripts/codespell.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+SKIP_LIST="./thirdparty,*.gen.*,*.po,*.pot,package-lock.json,./core/string/locales.h,./DONORS.md,./misc/scripts/codespell.sh"
+IGNORE_LIST="ba,childs,curvelinear,expct,fave,findn,gird,inout,lod,nd,numer,ois,ro,statics,te,varn"
+
+codespell -w -q 3 -S "${SKIP_LIST}" -L "${IGNORE_LIST}"

misc/scripts/copyright_headers.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import os
 import sys
 
 header = """\
@@ -36,61 +35,61 @@ header = """\
 /**************************************************************************/
 """
 
-if len(sys.argv) < 2:
-    print("Invalid usage of copyright_headers.py, it should be called with a path to one or multiple files.")
-    sys.exit(1)
+fname = sys.argv[1]
 
-for f in sys.argv[1:]:
-    fname = f
+# Handle replacing $filename with actual filename and keep alignment
+fsingle = fname.strip()
+if fsingle.find("/") != -1:
+    fsingle = fsingle[fsingle.rfind("/") + 1 :]
+rep_fl = "$filename"
+rep_fi = fsingle
+len_fl = len(rep_fl)
+len_fi = len(rep_fi)
+# Pad with spaces to keep alignment
+if len_fi < len_fl:
+    for x in range(len_fl - len_fi):
+        rep_fi += " "
+elif len_fl < len_fi:
+    for x in range(len_fi - len_fl):
+        rep_fl += " "
+if header.find(rep_fl) != -1:
+    text = header.replace(rep_fl, rep_fi)
+else:
+    text = header.replace("$filename", fsingle)
+text += "\n"
 
-    # Handle replacing $filename with actual filename and keep alignment
-    fsingle = os.path.basename(fname.strip())
-    rep_fl = "$filename"
-    rep_fi = fsingle
-    len_fl = len(rep_fl)
-    len_fi = len(rep_fi)
-    # Pad with spaces to keep alignment
-    if len_fi < len_fl:
-        for x in range(len_fl - len_fi):
-            rep_fi += " "
-    elif len_fl < len_fi:
-        for x in range(len_fi - len_fl):
-            rep_fl += " "
-    if header.find(rep_fl) != -1:
-        text = header.replace(rep_fl, rep_fi)
-    else:
-        text = header.replace("$filename", fsingle)
-    text += "\n"
+# We now have the proper header, so we want to ignore the one in the original file
+# and potentially empty lines and badly formatted lines, while keeping comments that
+# come after the header, and then keep everything non-header unchanged.
+# To do so, we skip empty lines that may be at the top in a first pass.
+# In a second pass, we skip all consecutive comment lines starting with "/*",
+# then we can append the rest (step 2).
 
-    # We now have the proper header, so we want to ignore the one in the original file
-    # and potentially empty lines and badly formatted lines, while keeping comments that
-    # come after the header, and then keep everything non-header unchanged.
-    # To do so, we skip empty lines that may be at the top in a first pass.
-    # In a second pass, we skip all consecutive comment lines starting with "/*",
-    # then we can append the rest (step 2).
+fileread = open(fname.strip(), "r")
+line = fileread.readline()
+header_done = False
 
-    with open(fname.strip(), "r", encoding="utf-8") as fileread:
-        line = fileread.readline()
-        header_done = False
+while line.strip() == "":  # Skip empty lines at the top
+    line = fileread.readline()
 
-        while line.strip() == "" and line != "":  # Skip empty lines at the top
-            line = fileread.readline()
+if line.find("/**********") == -1:  # Godot header starts this way
+    # Maybe starting with a non-Godot comment, abort header magic
+    header_done = True
 
-        if line.find("/**********") == -1:  # Godot header starts this way
-            # Maybe starting with a non-Godot comment, abort header magic
-            header_done = True
-
-        while not header_done:  # Handle header now
-            if line.find("/*") != 0:  # No more starting with a comment
-                header_done = True
-                if line.strip() != "":
-                    text += line
-            line = fileread.readline()
-
-        while line != "":  # Dump everything until EOF
+while not header_done:  # Handle header now
+    if line.find("/*") != 0:  # No more starting with a comment
+        header_done = True
+        if line.strip() != "":
             text += line
-            line = fileread.readline()
+    line = fileread.readline()
 
-    # Write
-    with open(fname.strip(), "w", encoding="utf-8", newline="\n") as filewrite:
-        filewrite.write(text)
+while line != "":  # Dump everything until EOF
+    text += line
+    line = fileread.readline()
+
+fileread.close()
+
+# Write
+filewrite = open(fname.strip(), "w")
+filewrite.write(text)
+filewrite.close()

misc/scripts/file_format.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import sys
-
-if len(sys.argv) < 2:
-    print("Invalid usage of file_format.py, it should be called with a path to one or multiple files.")
-    sys.exit(1)
-
-BOM = b"\xef\xbb\xbf"
-
-changed = []
-invalid = []
-
-for file in sys.argv[1:]:
-    try:
-        with open(file, "rt", encoding="utf-8") as f:
-            original = f.read()
-    except UnicodeDecodeError:
-        invalid.append(file)
-        continue
-
-    if original == "":
-        continue
-
-    revamp = "\n".join([line.rstrip("\n\r\t ") for line in original.splitlines(True)]).rstrip("\n") + "\n"
-
-    new_raw = revamp.encode(encoding="utf-8")
-    if new_raw.startswith(BOM):
-        new_raw = new_raw[len(BOM) :]
-
-    with open(file, "rb") as f:
-        old_raw = f.read()
-
-    if old_raw != new_raw:
-        changed.append(file)
-        with open(file, "wb") as f:
-            f.write(new_raw)
-
-if changed:
-    for file in changed:
-        print(f"FIXED: {file}")
-if invalid:
-    for file in invalid:
-        print(f"REQUIRES MANUAL CHANGES: {file}")
-    sys.exit(1)

misc/scripts/file_format.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+
+# This script ensures proper POSIX text file formatting and a few other things.
+# This is supplementary to clang_format.sh and black_format.sh, but should be
+# run before them.
+
+# We need dos2unix and recode.
+if [ ! -x "$(command -v dos2unix)" -o ! -x "$(command -v recode)" ]; then
+    printf "Install 'dos2unix' and 'recode' to use this script.\n"
+fi
+
+set -uo pipefail
+IFS=$'\n\t'
+
+# Loops through all text files tracked by Git.
+git grep -zIl '' |
+while IFS= read -rd '' f; do
+    # Ensure that files are UTF-8 formatted.
+    recode UTF-8 "$f" 2> /dev/null
+    # Ensure that files have LF line endings and do not contain a BOM.
+    dos2unix "$f" 2> /dev/null
+    # Remove trailing space characters and ensures that files end
+    # with newline characters. -l option handles newlines conveniently.
+    perl -i -ple 's/\s*$//g' "$f"
+done
+
+diff=$(git diff --color)
+
+# If no patch has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "Files in this commit comply with the formatting 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"
+echo "$diff"
+printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+exit 1

misc/scripts/header_guards.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import sys
-from pathlib import Path
-
-if len(sys.argv) < 2:
-    print("Invalid usage of header_guards.py, it should be called with a path to one or multiple files.")
-    sys.exit(1)
-
-HEADER_CHECK_OFFSET = 30
-HEADER_BEGIN_OFFSET = 31
-HEADER_END_OFFSET = -1
-
-changed = []
-invalid = []
-
-for file in sys.argv[1:]:
-    with open(file, "rt", encoding="utf-8", newline="\n") as f:
-        lines = f.readlines()
-
-    if len(lines) <= HEADER_BEGIN_OFFSET:
-        continue  # Most likely a dummy file.
-
-    if lines[HEADER_CHECK_OFFSET].startswith("#import"):
-        continue  # Early catch obj-c file.
-
-    name = f"GODOT_{Path(file).name}".upper().replace(".", "_").replace("-", "_").replace(" ", "_")
-
-    HEADER_CHECK = f"#ifndef {name}\n"
-    HEADER_BEGIN = f"#define {name}\n"
-    HEADER_END = f"#endif // {name}\n"
-
-    if (
-        lines[HEADER_CHECK_OFFSET] == HEADER_CHECK
-        and lines[HEADER_BEGIN_OFFSET] == HEADER_BEGIN
-        and lines[HEADER_END_OFFSET] == HEADER_END
-    ):
-        continue
-
-    # Guards might exist but with the wrong names.
-    if (
-        lines[HEADER_CHECK_OFFSET].startswith("#ifndef")
-        and lines[HEADER_BEGIN_OFFSET].startswith("#define")
-        and lines[HEADER_END_OFFSET].startswith("#endif")
-    ):
-        lines[HEADER_CHECK_OFFSET] = HEADER_CHECK
-        lines[HEADER_BEGIN_OFFSET] = HEADER_BEGIN
-        lines[HEADER_END_OFFSET] = HEADER_END
-        with open(file, "wt", encoding="utf-8", newline="\n") as f:
-            f.writelines(lines)
-        changed.append(file)
-        continue
-
-    header_check = -1
-    header_begin = -1
-    header_end = -1
-    pragma_once = -1
-    objc = False
-
-    for idx, line in enumerate(lines):
-        if not line.startswith("#"):
-            continue
-        elif line.startswith("#ifndef") and header_check == -1:
-            header_check = idx
-        elif line.startswith("#define") and header_begin == -1:
-            header_begin = idx
-        elif line.startswith("#endif") and header_end == -1:
-            header_end = idx
-        elif line.startswith("#pragma once"):
-            pragma_once = idx
-            break
-        elif line.startswith("#import"):
-            objc = True
-            break
-
-    if objc:
-        continue
-
-    if pragma_once != -1:
-        lines.pop(pragma_once)
-        lines.insert(HEADER_CHECK_OFFSET, HEADER_CHECK)
-        lines.insert(HEADER_BEGIN_OFFSET, HEADER_BEGIN)
-        lines.append("\n")
-        lines.append(HEADER_END)
-        with open(file, "wt", encoding="utf-8", newline="\n") as f:
-            f.writelines(lines)
-        changed.append(file)
-        continue
-
-    if header_check == -1 and header_begin == -1 and header_end == -1:
-        # Guards simply didn't exist
-        lines.insert(HEADER_CHECK_OFFSET, HEADER_CHECK)
-        lines.insert(HEADER_BEGIN_OFFSET, HEADER_BEGIN)
-        lines.append("\n")
-        lines.append(HEADER_END)
-        with open(file, "wt", encoding="utf-8", newline="\n") as f:
-            f.writelines(lines)
-        changed.append(file)
-        continue
-
-    if header_check != -1 and header_begin != -1 and header_end != -1:
-        # All prepends "found", see if we can salvage this.
-        if header_check == header_begin - 1 and header_begin < header_end:
-            lines.pop(header_check)
-            lines.pop(header_begin - 1)
-            lines.pop(header_end - 2)
-            if lines[header_end - 3] == "\n":
-                lines.pop(header_end - 3)
-            lines.insert(HEADER_CHECK_OFFSET, HEADER_CHECK)
-            lines.insert(HEADER_BEGIN_OFFSET, HEADER_BEGIN)
-            lines.append("\n")
-            lines.append(HEADER_END)
-            with open(file, "wt", encoding="utf-8", newline="\n") as f:
-                f.writelines(lines)
-            changed.append(file)
-            continue
-
-    invalid.append(file)
-
-if changed:
-    for file in changed:
-        print(f"FIXED: {file}")
-if invalid:
-    for file in invalid:
-        print(f"REQUIRES MANUAL CHANGES: {file}")
-    sys.exit(1)

misc/scripts/header_guards.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+if [ ! -f "SConstruct" ]; then
+  echo "Warning: This script is intended to be run from the root of the Godot repository."
+  echo "Some of the paths checks may not work as intended from a different folder."
+fi
+
+files_invalid_guard=""
+
+for file in $(find . -name "*.hpp" -print); do
+  # Skip generated files.
+  if [[ "$file" == "./gen/"* || "$file" == "./include/gen/"* ]]; then continue; fi
+  # Skip the test project.
+  if [[ "$file" == "./test/"* ]]; then continue; fi
+
+  bname=$(basename $file .hpp)
+
+  # NOTE: The "GODOT_CPP_" prefix is already used by the generated
+  # bindings, so we can't use that. We'll use "GODOT_" instead.
+  prefix="GODOT_"
+
+  # ^^ is bash builtin for UPPERCASE.
+  guard="${prefix}${bname^^}_HPP"
+
+  # Replaces guards to use computed name.
+  # We also add some \n to make sure there's a proper separation.
+  sed -i $file -e "0,/ifndef/s/#ifndef.*/\n#ifndef $guard/"
+  sed -i $file -e "0,/define/s/#define.*/#define $guard\n/"
+  sed -i $file -e "$ s/#endif.*/\n#endif \/\/ $guard/"
+  # Removes redundant \n added before, if they weren't needed.
+  sed -i $file -e "/^$/N;/^\n$/D"
+
+  # Check that first ifndef (should be header guard) is at the expected position.
+  # If not it can mean we have some code before the guard that should be after.
+  # "31" is the expected line with the copyright header.
+  first_ifndef=$(grep -n -m 1 "ifndef" $file | sed 's/\([0-9]*\).*/\1/')
+  if [[ "$first_ifndef" != "31" ]]; then
+    files_invalid_guard+="$file\n"
+  fi
+done
+
+if [[ ! -z "$files_invalid_guard" ]]; then
+  echo -e "The following files were found to have potentially invalid header guard:\n"
+  echo -e "$files_invalid_guard"
+fi
+
+diff=$(git diff --color)
+
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "Files in this commit comply with the header guards formatting rules.\n"
+    exit 0
+fi
+
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n*** The following differences were found between the code "
+printf "and the header guards formatting rules:\n\n"
+echo "$diff"
+printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+exit 1

misc/scripts/mypy.ini

@@ -0,0 +1,11 @@
+[mypy]
+ignore_missing_imports = true
+disallow_any_generics = True
+pretty = True
+show_column_numbers = True
+warn_redundant_casts = True
+warn_return_any = True
+warn_unreachable = True
+
+namespace_packages = True
+explicit_package_bases = True

misc/scripts/mypy_check.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -uo pipefail
+
+echo -e "Python: mypy static analysis..."
+mypy --config-file=./misc/scripts/mypy.ini .

pyproject.toml

@@ -1,58 +0,0 @@
-[tool.mypy]
-disallow_any_generics = true
-explicit_package_bases = true
-ignore_missing_imports = true
-namespace_packages = true
-no_implicit_optional = true
-pretty = true
-scripts_are_modules = true
-show_column_numbers = true
-warn_redundant_casts = true
-warn_return_any = true
-warn_unreachable = true
-
-[tool.ruff]
-extend-include = ["SConstruct"]
-line-length = 120
-target-version = "py37"
-
-[tool.ruff.lint]
-extend-select = [
-	"I", # isort
-]
-
-[tool.ruff.lint.per-file-ignores]
-"SConstruct" = [
-	"F821", # Undefined name
-]
-
-[tool.codespell]
-enable-colors = ""
-write-changes = ""
-check-hidden = ""
-quiet-level = 3
-builtin = "clear,rare,en-GB_to_en-US"
-ignore-words-list = """\
-	breaked,
-	cancelled,
-	checkin,
-	curvelinear,
-	doubleclick,
-	expct,
-	findn,
-	gird,
-	hel,
-	inout,
-	labelin,
-	lod,
-	mis,
-	nd,
-	numer,
-	ot,
-	outin,
-	requestor,
-	te,
-	textin,
-	thirdparty,
-	vai
-"""

src/classes/editor_plugin.cpp

@@ -1,5 +1,5 @@
 /**************************************************************************/
-/*  editor_plugin_registration.cpp                                        */
+/*  editor_plugin.cpp                                                     */
 /**************************************************************************/
 /*                         This file is part of:                          */
 /*                             GODOT ENGINE                               */
@@ -28,9 +28,9 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
 /**************************************************************************/
 
-#include <godot_cpp/classes/editor_plugin_registration.hpp>
+#include <godot_cpp/classes/editor_plugin.hpp>
 
-#include <godot_cpp/variant/variant.hpp>
+#include <godot_cpp/variant/string_name.hpp>
 
 namespace godot {
 

src/classes/wrapped.cpp

@@ -28,16 +28,12 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
 /**************************************************************************/
 
-#include <vector>
-
 #include <godot_cpp/classes/wrapped.hpp>
 
 #include <godot_cpp/variant/builtin_types.hpp>
 
 #include <godot_cpp/classes/object.hpp>
 
-#include <godot_cpp/core/class_db.hpp>
-
 namespace godot {
 
 const StringName *Wrapped::_get_extension_class_name() const {
@@ -50,31 +46,9 @@ void Wrapped::_postinitialize() {
 		godot::internal::gdextension_interface_object_set_instance(_owner, reinterpret_cast<GDExtensionConstStringNamePtr>(extension_class), this);
 	}
 	godot::internal::gdextension_interface_object_set_instance_binding(_owner, godot::internal::token, this, _get_bindings_callbacks());
-	if (extension_class) {
-		_notificationv(Object::NOTIFICATION_POSTINITIALIZE);
-	}
 }
 
 Wrapped::Wrapped(const StringName p_godot_class) {
-#ifdef HOT_RELOAD_ENABLED
-	if (unlikely(Wrapped::recreate_instance)) {
-		RecreateInstance *recreate_data = Wrapped::recreate_instance;
-		RecreateInstance *previous = nullptr;
-		while (recreate_data) {
-			if (recreate_data->wrapper == this) {
-				_owner = recreate_data->owner;
-				if (previous) {
-					previous->next = recreate_data->next;
-				} else {
-					Wrapped::recreate_instance = recreate_data->next;
-				}
-				return;
-			}
-			previous = recreate_data;
-			recreate_data = recreate_data->next;
-		}
-	}
-#endif
 	_owner = godot::internal::gdextension_interface_classdb_construct_object(reinterpret_cast<GDExtensionConstStringNamePtr>(p_godot_class._native_ptr()));
 }
 
@@ -86,54 +60,4 @@ void postinitialize_handler(Wrapped *p_wrapped) {
 	p_wrapped->_postinitialize();
 }
 
-namespace internal {
-
-std::vector<EngineClassRegistrationCallback> &get_engine_class_registration_callbacks() {
-	static std::vector<EngineClassRegistrationCallback> engine_class_registration_callbacks;
-	return engine_class_registration_callbacks;
-}
-
-GDExtensionPropertyInfo *create_c_property_list(const ::godot::List<::godot::PropertyInfo> &plist_cpp, uint32_t *r_size) {
-	GDExtensionPropertyInfo *plist = nullptr;
-	// Linked list size can be expensive to get so we cache it
-	const uint32_t plist_size = plist_cpp.size();
-	if (r_size != nullptr) {
-		*r_size = plist_size;
-	}
-	plist = reinterpret_cast<GDExtensionPropertyInfo *>(memalloc(sizeof(GDExtensionPropertyInfo) * plist_size));
-	unsigned int i = 0;
-	for (const ::godot::PropertyInfo &E : plist_cpp) {
-		plist[i].type = static_cast<GDExtensionVariantType>(E.type);
-		plist[i].name = E.name._native_ptr();
-		plist[i].hint = E.hint;
-		plist[i].hint_string = E.hint_string._native_ptr();
-		plist[i].class_name = E.class_name._native_ptr();
-		plist[i].usage = E.usage;
-		++i;
-	}
-	return plist;
-}
-
-void free_c_property_list(GDExtensionPropertyInfo *plist) {
-	memfree(plist);
-}
-
-void add_engine_class_registration_callback(EngineClassRegistrationCallback p_callback) {
-	get_engine_class_registration_callbacks().push_back(p_callback);
-}
-
-void register_engine_class(const StringName &p_name, const GDExtensionInstanceBindingCallbacks *p_callbacks) {
-	ClassDB::_register_engine_class(p_name, p_callbacks);
-}
-
-void register_engine_classes() {
-	std::vector<EngineClassRegistrationCallback> &engine_class_registration_callbacks = get_engine_class_registration_callbacks();
-	for (EngineClassRegistrationCallback cb : engine_class_registration_callbacks) {
-		cb();
-	}
-	engine_class_registration_callbacks.clear();
-}
-
-} // namespace internal
-
 } // namespace godot

src/core/class_db.cpp

@@ -42,8 +42,6 @@ namespace godot {
 std::unordered_map<StringName, ClassDB::ClassInfo> ClassDB::classes;
 std::unordered_map<StringName, const GDExtensionInstanceBindingCallbacks *> ClassDB::instance_binding_callbacks;
 std::vector<StringName> ClassDB::class_register_order;
-std::unordered_map<StringName, Object *> ClassDB::engine_singletons;
-std::mutex ClassDB::engine_singletons_mutex;
 GDExtensionInitializationLevel ClassDB::current_level = GDEXTENSION_INITIALIZATION_CORE;
 
 MethodDefinition D_METHOD(StringName p_name) {
@@ -79,7 +77,7 @@ void ClassDB::add_property(const StringName &p_class, const PropertyInfo &p_pinf
 	if (p_setter != String("")) {
 		setter = get_method(p_class, p_setter);
 
-		ERR_FAIL_NULL_MSG(setter, String("Setter method '{0}::{1}()' not found for property '{2}::{3}'.").format(Array::make(p_class, p_setter, p_class, p_pinfo.name)));
+		ERR_FAIL_COND_MSG(!setter, String("Setter method '{0}::{1}()' not found for property '{2}::{3}'.").format(Array::make(p_class, p_setter, p_class, p_pinfo.name)));
 
 		size_t exp_args = 1 + (p_index >= 0 ? 1 : 0);
 		ERR_FAIL_COND_MSG((int)exp_args != setter->get_argument_count(), String("Setter method '{0}::{1}()' must take a single argument.").format(Array::make(p_class, p_setter)));
@@ -88,7 +86,7 @@ void ClassDB::add_property(const StringName &p_class, const PropertyInfo &p_pinf
 	ERR_FAIL_COND_MSG(p_getter == String(""), String("Getter method must be specified for '{0}::{1}'.").format(Array::make(p_class, p_pinfo.name)));
 
 	MethodBind *getter = get_method(p_class, p_getter);
-	ERR_FAIL_NULL_MSG(getter, String("Getter method '{0}::{1}()' not found for property '{2}::{3}'.").format(Array::make(p_class, p_getter, p_class, p_pinfo.name)));
+	ERR_FAIL_COND_MSG(!getter, String("Getter method '{0}::{1}()' not found for property '{2}::{3}'.").format(Array::make(p_class, p_getter, p_class, p_pinfo.name)));
 	{
 		size_t exp_args = 0 + (p_index >= 0 ? 1 : 0);
 		ERR_FAIL_COND_MSG((int)exp_args != getter->get_argument_count(), String("Getter method '{0}::{1}()' must not take any argument.").format(Array::make(p_class, p_getter)));
@@ -107,7 +105,15 @@ void ClassDB::add_property(const StringName &p_class, const PropertyInfo &p_pinf
 		p_pinfo.usage, // DEFAULT //uint32_t usage;
 	};
 
-	internal::gdextension_interface_classdb_register_extension_class_property_indexed(internal::library, info.name._native_ptr(), &prop_info, p_setter._native_ptr(), p_getter._native_ptr(), p_index);
+	PropertySetGet setget;
+	setget.setter = p_setter;
+	setget.getter = p_getter;
+	setget._setptr = setter;
+	setget._getptr = getter;
+	setget.index = p_index;
+	setget.type = p_pinfo.type;
+
+	internal::gdextension_interface_classdb_register_extension_class_property(internal::library, info.name._native_ptr(), &prop_info, setget.setter._native_ptr(), setget.getter._native_ptr());
 }
 
 MethodBind *ClassDB::get_method(const StringName &p_class, const StringName &p_method) {
@@ -312,18 +318,7 @@ GDExtensionClassCallVirtual ClassDB::get_virtual_func(void *p_userdata, GDExtens
 
 const GDExtensionInstanceBindingCallbacks *ClassDB::get_instance_binding_callbacks(const StringName &p_class) {
 	std::unordered_map<StringName, const GDExtensionInstanceBindingCallbacks *>::iterator callbacks_it = instance_binding_callbacks.find(p_class);
-	if (likely(callbacks_it != instance_binding_callbacks.end())) {
-		return callbacks_it->second;
-	}
-
-	// If we don't have an instance binding callback for the given class, find the closest parent where we do.
-	StringName class_name = p_class;
-	do {
-		class_name = get_parent_class(class_name);
-		ERR_FAIL_COND_V_MSG(class_name == StringName(), nullptr, String("Cannot find instance binding callbacks for class '{0}'.").format(Array::make(p_class)));
-		callbacks_it = instance_binding_callbacks.find(class_name);
-	} while (callbacks_it == instance_binding_callbacks.end());
-
+	ERR_FAIL_COND_V_MSG(callbacks_it == instance_binding_callbacks.end(), nullptr, String("Cannot find instance binding callbacks for class '{0}'.").format(Array::make(p_class)));
 	return callbacks_it->second;
 }
 
@@ -354,7 +349,6 @@ void ClassDB::initialize(GDExtensionInitializationLevel p_level) {
 }
 
 void ClassDB::deinitialize(GDExtensionInitializationLevel p_level) {
-	std::set<StringName> to_erase;
 	for (std::vector<StringName>::reverse_iterator i = class_register_order.rbegin(); i != class_register_order.rend(); ++i) {
 		const StringName &name = *i;
 		const ClassInfo &cl = classes[name];
@@ -365,36 +359,9 @@ void ClassDB::deinitialize(GDExtensionInitializationLevel p_level) {
 
 		internal::gdextension_interface_classdb_unregister_extension_class(internal::library, name._native_ptr());
 
-		for (const std::pair<const StringName, MethodBind *> &method : cl.method_map) {
+		for (auto method : cl.method_map) {
 			memdelete(method.second);
 		}
-
-		classes.erase(name);
-		to_erase.insert(name);
-	}
-
-	{
-		// The following is equivalent to c++20 `std::erase_if(class_register_order, [&](const StringName& name){ return to_erase.contains(name); });`
-		std::vector<StringName>::iterator it = std::remove_if(class_register_order.begin(), class_register_order.end(), [&](const StringName &p_name) {
-			return to_erase.count(p_name) > 0;
-		});
-		class_register_order.erase(it, class_register_order.end());
-	}
-
-	if (p_level == GDEXTENSION_INITIALIZATION_CORE) {
-		// Make a new list of the singleton objects, since freeing the instance bindings will lead to
-		// elements getting removed from engine_singletons.
-		std::vector<Object *> singleton_objects;
-		{
-			std::lock_guard<std::mutex> lock(engine_singletons_mutex);
-			singleton_objects.reserve(engine_singletons.size());
-			for (const std::pair<const StringName, Object *> &pair : engine_singletons) {
-				singleton_objects.push_back(pair.second);
-			}
-		}
-		for (std::vector<Object *>::iterator i = singleton_objects.begin(); i != singleton_objects.end(); i++) {
-			internal::gdextension_interface_object_free_instance_binding((*i)->_owner, internal::token);
-		}
 	}
 }
 

src/core/memory.cpp

@@ -36,17 +36,17 @@ namespace godot {
 
 void *Memory::alloc_static(size_t p_bytes, bool p_pad_align) {
 #ifdef DEBUG_ENABLED
-	bool prepad = false; // Already pre paded in the engine.
+	bool prepad = false; // Alredy pre paded in the engine.
 #else
 	bool prepad = p_pad_align;
 #endif
 
-	void *mem = internal::gdextension_interface_mem_alloc(p_bytes + (prepad ? DATA_OFFSET : 0));
-	ERR_FAIL_NULL_V(mem, nullptr);
+	void *mem = internal::gdextension_interface_mem_alloc(p_bytes + (prepad ? PAD_ALIGN : 0));
+	ERR_FAIL_COND_V(!mem, nullptr);
 
 	if (prepad) {
 		uint8_t *s8 = (uint8_t *)mem;
-		return s8 + DATA_OFFSET;
+		return s8 + PAD_ALIGN;
 	} else {
 		return mem;
 	}
@@ -63,16 +63,16 @@ void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) {
 	uint8_t *mem = (uint8_t *)p_memory;
 
 #ifdef DEBUG_ENABLED
-	bool prepad = false; // Already pre paded in the engine.
+	bool prepad = false; // Alredy pre paded in the engine.
 #else
 	bool prepad = p_pad_align;
 #endif
 
 	if (prepad) {
-		mem -= DATA_OFFSET;
-		mem = (uint8_t *)internal::gdextension_interface_mem_realloc(mem, p_bytes + DATA_OFFSET);
-		ERR_FAIL_NULL_V(mem, nullptr);
-		return mem + DATA_OFFSET;
+		mem -= PAD_ALIGN;
+		mem = (uint8_t *)internal::gdextension_interface_mem_realloc(mem, p_bytes + PAD_ALIGN);
+		ERR_FAIL_COND_V(!mem, nullptr);
+		return mem + PAD_ALIGN;
 	} else {
 		return (uint8_t *)internal::gdextension_interface_mem_realloc(mem, p_bytes);
 	}
@@ -82,13 +82,13 @@ void Memory::free_static(void *p_ptr, bool p_pad_align) {
 	uint8_t *mem = (uint8_t *)p_ptr;
 
 #ifdef DEBUG_ENABLED
-	bool prepad = false; // Already pre paded in the engine.
+	bool prepad = false; // Alredy pre paded in the engine.
 #else
 	bool prepad = p_pad_align;
 #endif
 
 	if (prepad) {
-		mem -= DATA_OFFSET;
+		mem -= PAD_ALIGN;
 	}
 	internal::gdextension_interface_mem_free(mem);
 }
@@ -103,29 +103,28 @@ _GlobalNil _GlobalNilClass::_nil;
 
 } // namespace godot
 
-// p_dummy argument is added to avoid conflicts with the engine functions when both engine and GDExtension are built as a static library on iOS.
-void *operator new(size_t p_size, const char *p_dummy, const char *p_description) {
+void *operator new(size_t p_size, const char *p_description) {
 	return godot::Memory::alloc_static(p_size);
 }
 
-void *operator new(size_t p_size, const char *p_dummy, void *(*p_allocfunc)(size_t p_size)) {
+void *operator new(size_t p_size, void *(*p_allocfunc)(size_t p_size)) {
 	return p_allocfunc(p_size);
 }
 
 using namespace godot;
 
 #ifdef _MSC_VER
-void operator delete(void *p_mem, const char *p_dummy, const char *p_description) {
+void operator delete(void *p_mem, const char *p_description) {
 	ERR_PRINT("Call to placement delete should not happen.");
 	CRASH_NOW();
 }
 
-void operator delete(void *p_mem, const char *p_dummy, void *(*p_allocfunc)(size_t p_size)) {
+void operator delete(void *p_mem, void *(*p_allocfunc)(size_t p_size)) {
 	ERR_PRINT("Call to placement delete should not happen.");
 	CRASH_NOW();
 }
 
-void operator delete(void *p_mem, const char *p_dummy, void *p_pointer, size_t check, const char *p_description) {
+void operator delete(void *p_mem, void *p_pointer, size_t check, const char *p_description) {
 	ERR_PRINT("Call to placement delete should not happen.");
 	CRASH_NOW();
 }

src/core/object.cpp

@@ -60,66 +60,8 @@ Object *get_object_instance_binding(GodotObject *p_engine_object) {
 	return reinterpret_cast<Object *>(gdextension_interface_object_get_instance_binding(p_engine_object, token, binding_callbacks));
 }
 
-TypedArray<Dictionary> convert_property_list(const std::vector<PropertyInfo> &p_list) {
-	TypedArray<Dictionary> va;
-	for (const PropertyInfo &pi : p_list) {
-		va.push_back(Dictionary(pi));
-	}
-	return va;
-}
-
 } // namespace internal
 
-MethodInfo::operator Dictionary() const {
-	Dictionary dict;
-	dict["name"] = name;
-	dict["args"] = internal::convert_property_list(arguments);
-	Array da;
-	for (size_t i = 0; i < default_arguments.size(); i++) {
-		da.push_back(default_arguments[i]);
-	}
-	dict["default_args"] = da;
-	dict["flags"] = flags;
-	dict["id"] = id;
-	Dictionary r = return_val;
-	dict["return"] = r;
-	return dict;
-}
-
-MethodInfo MethodInfo::from_dict(const Dictionary &p_dict) {
-	MethodInfo mi;
-
-	if (p_dict.has("name")) {
-		mi.name = p_dict["name"];
-	}
-	Array args;
-	if (p_dict.has("args")) {
-		args = p_dict["args"];
-	}
-
-	for (int i = 0; i < args.size(); i++) {
-		Dictionary d = args[i];
-		mi.arguments.push_back(PropertyInfo::from_dict(d));
-	}
-	Array defargs;
-	if (p_dict.has("default_args")) {
-		defargs = p_dict["default_args"];
-	}
-	for (int i = 0; i < defargs.size(); i++) {
-		mi.default_arguments.push_back(defargs[i]);
-	}
-
-	if (p_dict.has("return")) {
-		mi.return_val = PropertyInfo::from_dict(p_dict["return"]);
-	}
-
-	if (p_dict.has("flags")) {
-		mi.flags = p_dict["flags"];
-	}
-
-	return mi;
-}
-
 MethodInfo::MethodInfo() :
 		flags(GDEXTENSION_METHOD_FLAG_NORMAL) {}
 

src/godot.cpp

@@ -30,7 +30,7 @@
 
 #include <godot_cpp/godot.hpp>
 
-#include <godot_cpp/classes/editor_plugin_registration.hpp>
+#include <godot_cpp/classes/editor_plugin.hpp>
 #include <godot_cpp/classes/wrapped.hpp>
 #include <godot_cpp/core/class_db.hpp>
 #include <godot_cpp/core/memory.hpp>
@@ -129,8 +129,6 @@ GDExtensionInterfaceStringOperatorPlusEqChar gdextension_interface_string_operat
 GDExtensionInterfaceStringOperatorPlusEqCstr gdextension_interface_string_operator_plus_eq_cstr = nullptr;
 GDExtensionInterfaceStringOperatorPlusEqWcstr gdextension_interface_string_operator_plus_eq_wcstr = nullptr;
 GDExtensionInterfaceStringOperatorPlusEqC32str gdextension_interface_string_operator_plus_eq_c32str = nullptr;
-GDExtensionInterfaceStringResize gdextension_interface_string_resize = nullptr;
-GDExtensionInterfaceStringNameNewWithLatin1Chars gdextension_interface_string_name_new_with_latin1_chars = nullptr;
 GDExtensionInterfaceXmlParserOpenBuffer gdextension_interface_xml_parser_open_buffer = nullptr;
 GDExtensionInterfaceFileAccessStoreBuffer gdextension_interface_file_access_store_buffer = nullptr;
 GDExtensionInterfaceFileAccessGetBuffer gdextension_interface_file_access_get_buffer = nullptr;
@@ -166,27 +164,21 @@ GDExtensionInterfaceObjectDestroy gdextension_interface_object_destroy = nullptr
 GDExtensionInterfaceGlobalGetSingleton gdextension_interface_global_get_singleton = nullptr;
 GDExtensionInterfaceObjectGetInstanceBinding gdextension_interface_object_get_instance_binding = nullptr;
 GDExtensionInterfaceObjectSetInstanceBinding gdextension_interface_object_set_instance_binding = nullptr;
-GDExtensionInterfaceObjectFreeInstanceBinding gdextension_interface_object_free_instance_binding = nullptr;
 GDExtensionInterfaceObjectSetInstance gdextension_interface_object_set_instance = nullptr;
 GDExtensionInterfaceObjectGetClassName gdextension_interface_object_get_class_name = nullptr;
 GDExtensionInterfaceObjectCastTo gdextension_interface_object_cast_to = nullptr;
 GDExtensionInterfaceObjectGetInstanceFromId gdextension_interface_object_get_instance_from_id = nullptr;
 GDExtensionInterfaceObjectGetInstanceId gdextension_interface_object_get_instance_id = nullptr;
-GDExtensionInterfaceCallableCustomCreate gdextension_interface_callable_custom_create = nullptr;
-GDExtensionInterfaceCallableCustomGetUserData gdextension_interface_callable_custom_get_userdata = nullptr;
 GDExtensionInterfaceRefGetObject gdextension_interface_ref_get_object = nullptr;
 GDExtensionInterfaceRefSetObject gdextension_interface_ref_set_object = nullptr;
-GDExtensionInterfaceScriptInstanceCreate2 gdextension_interface_script_instance_create2 = nullptr;
-GDExtensionInterfacePlaceHolderScriptInstanceCreate gdextension_interface_placeholder_script_instance_create = nullptr;
-GDExtensionInterfacePlaceHolderScriptInstanceUpdate gdextension_interface_placeholder_script_instance_update = nullptr;
+GDExtensionInterfaceScriptInstanceCreate gdextension_interface_script_instance_create = nullptr;
 GDExtensionInterfaceClassdbConstructObject gdextension_interface_classdb_construct_object = nullptr;
 GDExtensionInterfaceClassdbGetMethodBind gdextension_interface_classdb_get_method_bind = nullptr;
 GDExtensionInterfaceClassdbGetClassTag gdextension_interface_classdb_get_class_tag = nullptr;
-GDExtensionInterfaceClassdbRegisterExtensionClass2 gdextension_interface_classdb_register_extension_class2 = nullptr;
+GDExtensionInterfaceClassdbRegisterExtensionClass gdextension_interface_classdb_register_extension_class = nullptr;
 GDExtensionInterfaceClassdbRegisterExtensionClassMethod gdextension_interface_classdb_register_extension_class_method = nullptr;
 GDExtensionInterfaceClassdbRegisterExtensionClassIntegerConstant gdextension_interface_classdb_register_extension_class_integer_constant = nullptr;
 GDExtensionInterfaceClassdbRegisterExtensionClassProperty gdextension_interface_classdb_register_extension_class_property = nullptr;
-GDExtensionInterfaceClassdbRegisterExtensionClassPropertyIndexed gdextension_interface_classdb_register_extension_class_property_indexed = nullptr;
 GDExtensionInterfaceClassdbRegisterExtensionClassPropertyGroup gdextension_interface_classdb_register_extension_class_property_group = nullptr;
 GDExtensionInterfaceClassdbRegisterExtensionClassPropertySubgroup gdextension_interface_classdb_register_extension_class_property_subgroup = nullptr;
 GDExtensionInterfaceClassdbRegisterExtensionClassSignal gdextension_interface_classdb_register_extension_class_signal = nullptr;
@@ -197,9 +189,9 @@ GDExtensionInterfaceEditorRemovePlugin gdextension_interface_editor_remove_plugi
 
 } // namespace internal
 
-bool GDExtensionBinding::api_initialized = false;
-int GDExtensionBinding::level_initialized[MODULE_INITIALIZATION_LEVEL_MAX] = { 0 };
-GDExtensionBinding::InitDataList GDExtensionBinding::initdata;
+GDExtensionBinding::Callback GDExtensionBinding::init_callback = nullptr;
+GDExtensionBinding::Callback GDExtensionBinding::terminate_callback = nullptr;
+GDExtensionInitializationLevel GDExtensionBinding::minimum_initialization_level = GDEXTENSION_INITIALIZATION_CORE;
 
 #define ERR_PRINT_EARLY(m_msg) \
 	internal::gdextension_interface_print_error(m_msg, FUNCTION_STR, __FILE__, __LINE__, false)
@@ -226,20 +218,7 @@ typedef struct {
 	GDExtensionInterfacePrintErrorWithMessage print_error_with_message;
 } LegacyGDExtensionInterface;
 
-GDExtensionBool GDExtensionBinding::init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, InitData *p_init_data, GDExtensionInitialization *r_initialization) {
-	if (!p_init_data || !p_init_data->init_callback) {
-		ERR_FAIL_V_MSG(false, "Initialization callback must be defined.");
-	}
-
-	if (api_initialized) {
-		r_initialization->initialize = initialize_level;
-		r_initialization->deinitialize = deinitialize_level;
-		r_initialization->userdata = p_init_data;
-		r_initialization->minimum_initialization_level = p_init_data->minimum_initialization_level;
-
-		return true;
-	}
-
+GDExtensionBool GDExtensionBinding::init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
 	// Make sure we weren't passed the legacy struct.
 	uint32_t *raw_interface = (uint32_t *)(void *)p_get_proc_address;
 	if (raw_interface[0] == 4 && raw_interface[1] == 0) {
@@ -272,12 +251,7 @@ GDExtensionBool GDExtensionBinding::init(GDExtensionInterfaceGetProcAddress p_ge
 	} else if (internal::godot_version.minor != GODOT_VERSION_MINOR) {
 		compatible = internal::godot_version.minor > GODOT_VERSION_MINOR;
 	} else {
-#if GODOT_VERSION_PATCH > 0
 		compatible = internal::godot_version.patch >= GODOT_VERSION_PATCH;
-#else
-		// Prevent -Wtype-limits warning due to unsigned comparison.
-		compatible = true;
-#endif
 	}
 	if (!compatible) {
 		// We need to use snprintf() here because vformat() uses Variant, and we haven't loaded
@@ -367,8 +341,6 @@ GDExtensionBool GDExtensionBinding::init(GDExtensionInterfaceGetProcAddress p_ge
 	LOAD_PROC_ADDRESS(string_operator_plus_eq_cstr, GDExtensionInterfaceStringOperatorPlusEqCstr);
 	LOAD_PROC_ADDRESS(string_operator_plus_eq_wcstr, GDExtensionInterfaceStringOperatorPlusEqWcstr);
 	LOAD_PROC_ADDRESS(string_operator_plus_eq_c32str, GDExtensionInterfaceStringOperatorPlusEqC32str);
-	LOAD_PROC_ADDRESS(string_resize, GDExtensionInterfaceStringResize);
-	LOAD_PROC_ADDRESS(string_name_new_with_latin1_chars, GDExtensionInterfaceStringNameNewWithLatin1Chars);
 	LOAD_PROC_ADDRESS(xml_parser_open_buffer, GDExtensionInterfaceXmlParserOpenBuffer);
 	LOAD_PROC_ADDRESS(file_access_store_buffer, GDExtensionInterfaceFileAccessStoreBuffer);
 	LOAD_PROC_ADDRESS(file_access_get_buffer, GDExtensionInterfaceFileAccessGetBuffer);
@@ -404,27 +376,21 @@ GDExtensionBool GDExtensionBinding::init(GDExtensionInterfaceGetProcAddress p_ge
 	LOAD_PROC_ADDRESS(global_get_singleton, GDExtensionInterfaceGlobalGetSingleton);
 	LOAD_PROC_ADDRESS(object_get_instance_binding, GDExtensionInterfaceObjectGetInstanceBinding);
 	LOAD_PROC_ADDRESS(object_set_instance_binding, GDExtensionInterfaceObjectSetInstanceBinding);
-	LOAD_PROC_ADDRESS(object_free_instance_binding, GDExtensionInterfaceObjectFreeInstanceBinding);
 	LOAD_PROC_ADDRESS(object_set_instance, GDExtensionInterfaceObjectSetInstance);
 	LOAD_PROC_ADDRESS(object_get_class_name, GDExtensionInterfaceObjectGetClassName);
 	LOAD_PROC_ADDRESS(object_cast_to, GDExtensionInterfaceObjectCastTo);
 	LOAD_PROC_ADDRESS(object_get_instance_from_id, GDExtensionInterfaceObjectGetInstanceFromId);
 	LOAD_PROC_ADDRESS(object_get_instance_id, GDExtensionInterfaceObjectGetInstanceId);
-	LOAD_PROC_ADDRESS(callable_custom_create, GDExtensionInterfaceCallableCustomCreate);
-	LOAD_PROC_ADDRESS(callable_custom_get_userdata, GDExtensionInterfaceCallableCustomGetUserData);
 	LOAD_PROC_ADDRESS(ref_get_object, GDExtensionInterfaceRefGetObject);
 	LOAD_PROC_ADDRESS(ref_set_object, GDExtensionInterfaceRefSetObject);
-	LOAD_PROC_ADDRESS(script_instance_create2, GDExtensionInterfaceScriptInstanceCreate2);
-	LOAD_PROC_ADDRESS(placeholder_script_instance_create, GDExtensionInterfacePlaceHolderScriptInstanceCreate);
-	LOAD_PROC_ADDRESS(placeholder_script_instance_update, GDExtensionInterfacePlaceHolderScriptInstanceUpdate);
+	LOAD_PROC_ADDRESS(script_instance_create, GDExtensionInterfaceScriptInstanceCreate);
 	LOAD_PROC_ADDRESS(classdb_construct_object, GDExtensionInterfaceClassdbConstructObject);
 	LOAD_PROC_ADDRESS(classdb_get_method_bind, GDExtensionInterfaceClassdbGetMethodBind);
 	LOAD_PROC_ADDRESS(classdb_get_class_tag, GDExtensionInterfaceClassdbGetClassTag);
-	LOAD_PROC_ADDRESS(classdb_register_extension_class2, GDExtensionInterfaceClassdbRegisterExtensionClass2);
+	LOAD_PROC_ADDRESS(classdb_register_extension_class, GDExtensionInterfaceClassdbRegisterExtensionClass);
 	LOAD_PROC_ADDRESS(classdb_register_extension_class_method, GDExtensionInterfaceClassdbRegisterExtensionClassMethod);
 	LOAD_PROC_ADDRESS(classdb_register_extension_class_integer_constant, GDExtensionInterfaceClassdbRegisterExtensionClassIntegerConstant);
 	LOAD_PROC_ADDRESS(classdb_register_extension_class_property, GDExtensionInterfaceClassdbRegisterExtensionClassProperty);
-	LOAD_PROC_ADDRESS(classdb_register_extension_class_property_indexed, GDExtensionInterfaceClassdbRegisterExtensionClassPropertyIndexed);
 	LOAD_PROC_ADDRESS(classdb_register_extension_class_property_group, GDExtensionInterfaceClassdbRegisterExtensionClassPropertyGroup);
 	LOAD_PROC_ADDRESS(classdb_register_extension_class_property_subgroup, GDExtensionInterfaceClassdbRegisterExtensionClassPropertySubgroup);
 	LOAD_PROC_ADDRESS(classdb_register_extension_class_signal, GDExtensionInterfaceClassdbRegisterExtensionClassSignal);
@@ -435,96 +401,59 @@ GDExtensionBool GDExtensionBinding::init(GDExtensionInterfaceGetProcAddress p_ge
 
 	r_initialization->initialize = initialize_level;
 	r_initialization->deinitialize = deinitialize_level;
-	r_initialization->userdata = p_init_data;
-	r_initialization->minimum_initialization_level = p_init_data->minimum_initialization_level;
+	r_initialization->minimum_initialization_level = minimum_initialization_level;
+
+	ERR_FAIL_COND_V_MSG(init_callback == nullptr, false, "Initialization callback must be defined.");
 
 	Variant::init_bindings();
-	godot::internal::register_engine_classes();
+	register_engine_classes();
 
-	api_initialized = true;
 	return true;
 }
 
 #undef LOAD_PROC_ADDRESS
 #undef ERR_PRINT_EARLY
 
-void GDExtensionBinding::initialize_level(void *p_userdata, GDExtensionInitializationLevel p_level) {
-	ERR_FAIL_COND(static_cast<ModuleInitializationLevel>(p_level) >= MODULE_INITIALIZATION_LEVEL_MAX);
+void GDExtensionBinding::initialize_level(void *userdata, GDExtensionInitializationLevel p_level) {
 	ClassDB::current_level = p_level;
 
-	InitData *init_data = static_cast<InitData *>(p_userdata);
-	if (init_data && init_data->init_callback) {
-		init_data->init_callback(static_cast<ModuleInitializationLevel>(p_level));
+	if (init_callback) {
+		init_callback(static_cast<ModuleInitializationLevel>(p_level));
 	}
 
-	if (level_initialized[p_level] == 0) {
-		ClassDB::initialize(p_level);
-	}
-	level_initialized[p_level]++;
+	ClassDB::initialize(p_level);
 }
 
-void GDExtensionBinding::deinitialize_level(void *p_userdata, GDExtensionInitializationLevel p_level) {
-	ERR_FAIL_COND(static_cast<ModuleInitializationLevel>(p_level) >= MODULE_INITIALIZATION_LEVEL_MAX);
+void GDExtensionBinding::deinitialize_level(void *userdata, GDExtensionInitializationLevel p_level) {
 	ClassDB::current_level = p_level;
 
-	InitData *init_data = static_cast<InitData *>(p_userdata);
-	if (init_data && init_data->terminate_callback) {
-		init_data->terminate_callback(static_cast<ModuleInitializationLevel>(p_level));
+	if (terminate_callback) {
+		terminate_callback(static_cast<ModuleInitializationLevel>(p_level));
 	}
 
-	level_initialized[p_level]--;
-	if (level_initialized[p_level] == 0) {
-		EditorPlugins::deinitialize(p_level);
-		ClassDB::deinitialize(p_level);
-	}
+	EditorPlugins::deinitialize(p_level);
+	ClassDB::deinitialize(p_level);
 }
-
-void GDExtensionBinding::InitDataList::add(InitData *p_data) {
-	if (data_count == data_capacity) {
-		void *new_ptr = realloc(data, sizeof(InitData *) * (data_capacity + 32));
-		if (new_ptr) {
-			data = (InitData **)(new_ptr);
-			data_capacity += 32;
-		} else {
-			ERR_FAIL_MSG("Unable to allocate memory for extension callbacks.");
-		}
-	}
-	data[data_count++] = p_data;
-}
-
-GDExtensionBinding::InitDataList::~InitDataList() {
-	for (int i = 0; i < data_count; i++) {
-		if (data[i]) {
-			delete data[i];
-		}
-	}
-	if (data) {
-		free(data);
-	}
-}
-
 GDExtensionBinding::InitObject::InitObject(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
 	get_proc_address = p_get_proc_address;
 	library = p_library;
 	initialization = r_initialization;
-	init_data = new InitData();
-	GDExtensionBinding::initdata.add(init_data);
 }
 
 void GDExtensionBinding::InitObject::register_initializer(Callback p_init) const {
-	init_data->init_callback = p_init;
+	GDExtensionBinding::init_callback = p_init;
 }
 
 void GDExtensionBinding::InitObject::register_terminator(Callback p_terminate) const {
-	init_data->terminate_callback = p_terminate;
+	GDExtensionBinding::terminate_callback = p_terminate;
 }
 
 void GDExtensionBinding::InitObject::set_minimum_library_initialization_level(ModuleInitializationLevel p_level) const {
-	init_data->minimum_initialization_level = static_cast<GDExtensionInitializationLevel>(p_level);
+	GDExtensionBinding::minimum_initialization_level = static_cast<GDExtensionInitializationLevel>(p_level);
 }
 
 GDExtensionBool GDExtensionBinding::InitObject::init() const {
-	return GDExtensionBinding::init(get_proc_address, library, init_data, initialization);
+	return GDExtensionBinding::init(get_proc_address, library, initialization);
 }
 
 } // namespace godot

src/variant/aabb.cpp

@@ -78,10 +78,6 @@ bool AABB::is_equal_approx(const AABB &p_aabb) const {
 	return position.is_equal_approx(p_aabb.position) && size.is_equal_approx(p_aabb.size);
 }
 
-bool AABB::is_finite() const {
-	return position.is_finite() && size.is_finite();
-}
-
 AABB AABB::intersection(const AABB &p_aabb) const {
 #ifdef MATH_CHECKS
 	if (unlikely(size.x < 0 || size.y < 0 || size.z < 0 || p_aabb.size.x < 0 || p_aabb.size.y < 0 || p_aabb.size.z < 0)) {