Merge pull request #1572 from dsnopek/4.1-cherrypicks-13

Cherry-picks for the godot-cpp 4.1 branch - 13th batch

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

@@ -3,22 +3,19 @@ description: Restore Godot build cache.
 inputs:
   cache-name:
     description: The cache base name (job name by default).
-    default: ${{ github.job }}
+    default: "${{github.job}}"
   scons-cache:
-    description: The SCons cache path.
-    default: ${{ github.workspace }}/.scons-cache/
-
+    description: The scons cache path.
+    default: "${{github.workspace}}/.scons-cache/"
 runs:
-  using: composite
+  using: "composite"
   steps:
-    - name: Restore SCons cache directory
-      uses: actions/cache/restore@v4
+    - name: Restore .scons_cache directory
+      uses: actions/cache/restore@v3
       with:
-        path: ${{ inputs.scons-cache }}
-        key: ${{ inputs.cache-name }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}
-
+        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 }}
+          ${{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/godot-cache-save/action.yml

@@ -3,16 +3,15 @@ description: Save Godot build cache.
 inputs:
   cache-name:
     description: The cache base name (job name by default).
-    default: ${{ github.job }}
+    default: "${{github.job}}"
   scons-cache:
     description: The SCons cache path.
-    default: ${{ github.workspace }}/.scons-cache/
-
+    default: "${{github.workspace}}/.scons-cache/"
 runs:
-  using: composite
+  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 }}
+        path: ${{inputs.scons-cache}}
+        key: ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}

.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,14 @@
 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
+  GODOT_TEST_VERSION: 4.1.4-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:
@@ -92,6 +91,7 @@ jobs:
     env:
       SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
       EM_VERSION: 3.1.39
+      EM_CACHE_FOLDER: "emsdk-cache"
 
     steps:
       - name: Checkout
@@ -105,11 +105,34 @@ jobs:
           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@v5
         with:
-          platform: ${{ matrix.platform }}
-          windows-compiler: ${{ contains(matrix.flags, 'use_mingw=yes') && 'mingw' || 'msvc' }}
+          python-version: '3.x'
+
+      - name: Android dependencies
+        if: ${{ matrix.platform == 'android' }}
+        uses: nttld/setup-ndk@v1
+        with:
+          ndk-version: r23c
+          link-to-sdk: true
+
+      - name: Web dependencies
+        if: ${{ matrix.platform == 'web' }}
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: ${{env.EM_VERSION}}
+          actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
+
+      - name: Setup MinGW for Windows/MinGW build
+        if: ${{ matrix.platform == 'windows' && matrix.flags == 'use_mingw=yes' }}
+        uses: egor-tensin/setup-mingw@v2
+        with:
+          version: 12.2.0
+
+      - name: Install scons
+        run: |
+          python -m pip install scons==4.0.0
 
       - name: Generate godot-cpp sources only
         run: |
@@ -138,7 +161,7 @@ jobs:
 
       - name: Download latest Godot artifacts
         uses: dsnopek/action-download-artifact@1322f74e2dac9feed2ee76a32d9ae1ca3b4cf4e9
-        if: matrix.run-tests && env.GODOT_TEST_VERSION == 'master'
+        if: ${{ matrix.run-tests && env.GODOT_TEST_VERSION == 'master' }}
         with:
           repo: godotengine/godot
           branch: master
@@ -152,13 +175,13 @@ jobs:
           path: godot-artifacts
 
       - name: Prepare Godot artifacts for testing
-        if: matrix.run-tests && env.GODOT_TEST_VERSION == 'master'
+        if: ${{ matrix.run-tests && env.GODOT_TEST_VERSION == 'master' }}
         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'
+        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
@@ -166,7 +189,7 @@ jobs:
           echo "GODOT=$(pwd)/Godot_v${GODOT_TEST_VERSION}_linux.x86_64" >> $GITHUB_ENV
 
       - name: Run tests
-        if: matrix.run-tests
+        if: ${{ matrix.run-tests }}
         run: |
           $GODOT --headless --version
           cd test
@@ -241,9 +264,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,9 +1,8 @@
 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:
@@ -32,7 +31,3 @@ jobs:
         uses: pre-commit/action@v3.0.1
         with:
           extra_args: --verbose --hook-stage manual --files ${{ env.CHANGED_FILES }}
-
-      - name: Check generated files consistency
-        run:
-          python misc/scripts/check_get_file_list.py

.gitignore

@@ -195,7 +195,3 @@ compile_commands.json
 # Python development
 .venv
 venv
-
-# Clion Configuration
-.idea/
-cmake-build-*

CMakeLists.txt

@@ -1,24 +1,216 @@
+# 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 suppress 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.13)
 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/" )
+
+# 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(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(FLOAT_PRECISION "single" CACHE STRING "")
+if ("${FLOAT_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
+		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
+	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).
+option(GODOT_DISABLE_EXCEPTIONS OFF "Force disabling exception handling code")
+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(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}\", \"${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)
+
+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`).
 >
@@ -69,7 +68,8 @@ 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
 

binding_generator.py

@@ -72,14 +72,11 @@ def generate_wrappers(target):
 
 def get_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
     api = {}
+    files = []
     with open(api_filepath, encoding="utf-8") as api_file:
         api = json.load(api_file)
 
-    return _get_file_list(api, output_dir, headers, sources)
-
-
-def _get_file_list(api, output_dir, headers=False, sources=False):
-    files = []
+    build_profile = parse_build_profile(profile_filepath, api)
 
     core_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp" / "core"
     include_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp"
@@ -110,13 +107,11 @@ def _get_file_list(api, output_dir, headers=False, sources=False):
         source_filename = source_gen_folder / "classes" / (camel_to_snake(engine_class["name"]) + ".cpp")
         if headers:
             files.append(str(header_filename.as_posix()))
-        if sources:
+        if sources and is_class_included(engine_class["name"], build_profile):
             files.append(str(source_filename.as_posix()))
 
     for native_struct in api["native_structures"]:
         struct_name = native_struct["name"]
-        if struct_name == "ObjectID":
-            continue
         snake_struct_name = camel_to_snake(struct_name)
 
         header_filename = include_gen_folder / "classes" / (snake_struct_name + ".hpp")
@@ -129,7 +124,6 @@ def _get_file_list(api, output_dir, headers=False, sources=False):
             include_gen_folder / "variant" / "builtin_binds.hpp",
             include_gen_folder / "variant" / "utility_functions.hpp",
             include_gen_folder / "variant" / "variant_size.hpp",
-            include_gen_folder / "variant" / "builtin_vararg_methods.hpp",
             include_gen_folder / "classes" / "global_constants.hpp",
             include_gen_folder / "classes" / "global_constants_binds.hpp",
             include_gen_folder / "core" / "version.hpp",
@@ -142,19 +136,128 @@ def _get_file_list(api, output_dir, headers=False, sources=False):
     return files
 
 
-def print_file_list(api_filepath, output_dir, headers=False, sources=False):
-    print(*get_file_list(api_filepath, output_dir, headers, sources), sep=";", end=None)
+def print_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
+    print(*get_file_list(api_filepath, output_dir, headers, sources, profile_filepath), sep=";", end=None)
+
+
+def parse_build_profile(profile_filepath, api):
+    if profile_filepath == "":
+        return {}
+    print("Using feature build profile: " + profile_filepath)
+
+    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)
+
+    # Parse methods dependencies
+    deps = {}
+    reverse_deps = {}
+    for name, engine_class in api_dict.items():
+        ref_cls = set()
+        for method in engine_class.get("methods", []):
+            rtype = method.get("return_value", {}).get("type", "")
+            args = [a["type"] for a in method.get("arguments", [])]
+            if rtype in api_dict:
+                ref_cls.add(rtype)
+            elif is_enum(rtype) and get_enum_class(rtype) in api_dict:
+                ref_cls.add(get_enum_class(rtype))
+            for arg in args:
+                if arg in api_dict:
+                    ref_cls.add(arg)
+                elif is_enum(arg) and get_enum_class(arg) in api_dict:
+                    ref_cls.add(get_enum_class(arg))
+        deps[engine_class["name"]] = set(filter(lambda x: x != name, ref_cls))
+        for acls in ref_cls:
+            if acls == name:
+                continue
+            reverse_deps[acls] = reverse_deps.get(acls, set())
+            reverse_deps[acls].add(name)
+
+    included = []
+    front = list(profile.get("enabled_classes", []))
+    if front:
+        # These must always be included
+        front.append("WorkerThreadPool")
+        front.append("ClassDB")
+        front.append("ClassDBSingleton")
+    while front:
+        cls = front.pop()
+        if cls in included:
+            continue
+        included.append(cls)
+        parent = parents.get(cls, "")
+        if parent:
+            front.append(parent)
+        for rcls in deps.get(cls, set()):
+            if rcls in included or rcls in front:
+                continue
+            front.append(rcls)
+
+    excluded = []
+    front = list(profile.get("disabled_classes", []))
+    while front:
+        cls = front.pop()
+        if cls in excluded:
+            continue
+        excluded.append(cls)
+        front += children.get(cls, [])
+        for rcls in reverse_deps.get(cls, set()):
+            if rcls in excluded or rcls in front:
+                continue
+            front.append(rcls)
+
+    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 scons_emit_files(target, source, env):
+    profile_filepath = env.get("build_profile", "")
+    if profile_filepath and not Path(profile_filepath).is_absolute():
+        profile_filepath = str((Path(env.Dir("#").abspath) / profile_filepath).as_posix())
+
+    files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True, profile_filepath)]
+    env.Clean(target, files)
+    env["godot_cpp_gen_dir"] = target[0].abspath
+    return files, source
+
+
+def scons_generate_bindings(target, source, env):
+    generate_bindings(
+        str(source[0]),
+        env["generate_template_get_node"],
+        "32" if "32" in env["arch"] else "64",
+        env["precision"],
+        env["godot_cpp_gen_dir"],
+    )
+    return None
 
 
 def generate_bindings(api_filepath, use_template_get_node, bits="64", precision="single", output_dir="."):
-    api = {}
+    api = None
+
+    target_dir = Path(output_dir) / "gen"
+
     with open(api_filepath, encoding="utf-8") as api_file:
         api = json.load(api_file)
-    _generate_bindings(api, use_template_get_node, bits, precision, output_dir)
-
-
-def _generate_bindings(api, use_template_get_node, bits="64", precision="single", output_dir="."):
-    target_dir = Path(output_dir) / "gen"
 
     shutil.rmtree(target_dir, ignore_errors=True)
     target_dir.mkdir(parents=True)
@@ -307,14 +410,8 @@ def generate_builtin_bindings(api, output_dir, build_config):
 
         builtin_header.append("")
 
-        includes = []
         for builtin in builtin_classes:
-            includes.append(f"godot_cpp/variant/{camel_to_snake(builtin)}.hpp")
-
-        includes.sort()
-
-        for include in includes:
-            builtin_header.append(f"#include <{include}>")
+            builtin_header.append(f"#include <godot_cpp/variant/{camel_to_snake(builtin)}.hpp>")
 
         builtin_header.append("")
 
@@ -345,39 +442,6 @@ def generate_builtin_bindings(api, output_dir, build_config):
 
         builtin_binds_file.write("\n".join(builtin_binds))
 
-    # Create a header to implement all builtin class vararg methods and be included in "variant.hpp".
-    builtin_vararg_methods_header = include_gen_folder / "builtin_vararg_methods.hpp"
-    builtin_vararg_methods_header.open("w+").write(
-        generate_builtin_class_vararg_method_implements_header(api["builtin_classes"])
-    )
-
-
-def generate_builtin_class_vararg_method_implements_header(builtin_classes):
-    result = []
-
-    add_header("builtin_vararg_methods.hpp", result)
-
-    header_guard = "GODOT_CPP_BUILTIN_VARARG_METHODS_HPP"
-    result.append(f"#ifndef {header_guard}")
-    result.append(f"#define {header_guard}")
-    result.append("")
-    for builtin_api in builtin_classes:
-        if "methods" not in builtin_api:
-            continue
-        class_name = builtin_api["name"]
-        for method in builtin_api["methods"]:
-            if not method["is_vararg"]:
-                continue
-
-            result += make_varargs_template(
-                method, "is_static" in method and method["is_static"], class_name, False, True
-            )
-            result.append("")
-
-    result.append(f"#endif // ! {header_guard}")
-
-    return "\n".join(result)
-
 
 def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_classes):
     result = []
@@ -398,50 +462,32 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
 
     # Special cases.
     if class_name == "String":
-        result.append("#include <godot_cpp/classes/global_constants.hpp>")
         result.append("#include <godot_cpp/variant/char_string.hpp>")
         result.append("#include <godot_cpp/variant/char_utils.hpp>")
-        result.append("")
 
     if class_name == "PackedStringArray":
         result.append("#include <godot_cpp/variant/string.hpp>")
-        result.append("")
     if class_name == "PackedColorArray":
         result.append("#include <godot_cpp/variant/color.hpp>")
-        result.append("")
     if class_name == "PackedVector2Array":
         result.append("#include <godot_cpp/variant/vector2.hpp>")
-        result.append("")
     if class_name == "PackedVector3Array":
         result.append("#include <godot_cpp/variant/vector3.hpp>")
-        result.append("")
 
     if is_packed_array(class_name):
         result.append("#include <godot_cpp/core/error_macros.hpp>")
         result.append("#include <initializer_list>")
-        result.append("")
 
     if class_name == "Array":
         result.append("#include <godot_cpp/variant/array_helpers.hpp>")
-        result.append("")
 
-    if class_name == "Callable":
-        result.append("#include <godot_cpp/variant/callable_custom.hpp>")
-        result.append("")
+    for include in fully_used_classes:
+        if include == "TypedArray":
+            result.append("#include <godot_cpp/variant/typed_array.hpp>")
+        else:
+            result.append(f"#include <godot_cpp/{get_include_path(include)}>")
 
     if len(fully_used_classes) > 0:
-        includes = []
-        for include in fully_used_classes:
-            if include == "TypedArray":
-                includes.append("godot_cpp/variant/typed_array.hpp")
-            else:
-                includes.append(f"godot_cpp/{get_include_path(include)}")
-
-        includes.sort()
-
-        for include in includes:
-            result.append(f"#include <{include}>")
-
         result.append("")
 
     result.append("#include <gdextension_interface.h>")
@@ -519,7 +565,7 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
     result.append("public:")
 
     result.append(
-        f"\t_FORCE_INLINE_ GDExtensionTypePtr _native_ptr() const {{ return const_cast<uint8_t(*)[{snake_class_name}_SIZE]>(&opaque); }}"
+        f"\t_FORCE_INLINE_ GDExtensionTypePtr _native_ptr() const {{ return const_cast<uint8_t (*)[{snake_class_name}_SIZE]>(&opaque); }}"
     )
 
     copy_constructor_index = -1
@@ -542,16 +588,10 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
 
     # Special cases.
     if class_name == "String" or class_name == "StringName" or class_name == "NodePath":
-        if class_name == "StringName":
-            result.append(f"\t{class_name}(const char *p_from, bool p_static = false);")
-        else:
-            result.append(f"\t{class_name}(const char *p_from);")
+        result.append(f"\t{class_name}(const char *p_from);")
         result.append(f"\t{class_name}(const wchar_t *p_from);")
         result.append(f"\t{class_name}(const char16_t *p_from);")
         result.append(f"\t{class_name}(const char32_t *p_from);")
-    if class_name == "Callable":
-        result.append("\tCallable(CallableCustom *p_custom);")
-        result.append("\tCallableCustom *get_custom() const;")
 
     if "constants" in builtin_api:
         axis_constants_count = 0
@@ -621,7 +661,6 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
         result.append("\tChar32String utf32() const;")
         result.append("\tCharWideString wide_string() const;")
         result.append("\tstatic String num_real(double p_num, bool p_trailing = true);")
-        result.append("\tError resize(int64_t p_size);")
 
     if "members" in builtin_api:
         for member in builtin_api["members"]:
@@ -698,7 +737,7 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
         result.append(f"\tconst {return_type} *ptr() const;")
         result.append(f"\t{return_type} *ptrw();")
         iterators = """
-	struct Iterator {
+    struct Iterator {
 		_FORCE_INLINE_ $TYPE &operator*() const {
 			return *elem_ptr;
 		}
@@ -760,17 +799,19 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
 	}
 	_FORCE_INLINE_ ConstIterator end() const {
 		return ConstIterator(ptr() + size());
-	}"""
+	}
+"""
         result.append(iterators.replace("$TYPE", return_type))
         init_list = """
-	_FORCE_INLINE_ $CLASS(std::initializer_list<$TYPE> p_init) {
+    _FORCE_INLINE_ $CLASS(std::initializer_list<$TYPE> p_init) {
 		ERR_FAIL_COND(resize(p_init.size()) != 0);
 
 		size_t i = 0;
 		for (const $TYPE &element : p_init) {
 			set(i++, element);
 		}
-	}"""
+	}
+"""
         result.append(init_list.replace("$TYPE", return_type).replace("$CLASS", class_name))
 
     if class_name == "Array":
@@ -809,9 +850,7 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl
     result.append("")
     result.append("} // namespace godot")
 
-    result.append("")
     result.append(f"#endif // ! {header_guard}")
-    result.append("")
 
     return "\n".join(result)
 
@@ -825,6 +864,7 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl
 
     add_header(f"{snake_class_name}.cpp", result)
 
+    result.append("")
     result.append(f"#include <godot_cpp/variant/{snake_class_name}.hpp>")
     result.append("")
     result.append("#include <godot_cpp/core/binder_common.hpp>")
@@ -833,16 +873,10 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl
     result.append("")
 
     # Only used since the "fully used" is included in header already.
+    for include in used_classes:
+        result.append(f"#include <godot_cpp/{get_include_path(include)}>")
+
     if len(used_classes) > 0:
-        includes = []
-        for included in used_classes:
-            includes.append(f"godot_cpp/{get_include_path(included)}")
-
-        includes.sort()
-
-        for included in includes:
-            result.append(f"#include <{included}>")
-
         result.append("")
 
     result.append("#include <godot_cpp/core/builtin_ptrcall.hpp>")
@@ -1092,7 +1126,7 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl
                         f'{correct_type(operator["return_type"])} {class_name}::operator{get_operator_cpp_name(operator["name"])}() const {{'
                     )
                     result.append(
-                        f'\treturn internal::_call_builtin_operator_ptr<{get_gdextension_type(correct_type(operator["return_type"]))}>(_method_bindings.operator_{get_operator_id_name(operator["name"])}, (GDExtensionConstTypePtr)&opaque, (GDExtensionConstTypePtr) nullptr);'
+                        f'\treturn internal::_call_builtin_operator_ptr<{get_gdextension_type(correct_type(operator["return_type"]))}>(_method_bindings.operator_{get_operator_id_name(operator["name"])}, (GDExtensionConstTypePtr)&opaque, (GDExtensionConstTypePtr)nullptr);'
                     )
                     result.append("}")
                 result.append("")
@@ -1128,7 +1162,6 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl
 
     result.append("")
     result.append("} //namespace godot")
-    result.append("")
 
     return "\n".join(result)
 
@@ -1152,8 +1185,6 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
             class_api["name"] = CLASS_ALIASES[class_api["alias_for"]]
         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
         native_structures.append(native_struct["name"])
 
@@ -1281,8 +1312,6 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
 
     for native_struct in api["native_structures"]:
         struct_name = native_struct["name"]
-        if struct_name == "ObjectID":
-            continue
         snake_struct_name = camel_to_snake(struct_name)
 
         header_filename = include_gen_folder / (snake_struct_name + ".hpp")
@@ -1304,18 +1333,11 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
 
         result.append("")
 
-        if len(used_classes) > 0:
-            includes = []
-            for included in used_classes:
-                includes.append(f"godot_cpp/{get_include_path(included)}")
+        for included in used_classes:
+            result.append(f"#include <godot_cpp/{get_include_path(included)}>")
 
-            includes.sort()
-
-            for include in includes:
-                result.append(f"#include <{include}>")
-        else:
+        if len(used_classes) == 0:
             result.append("#include <godot_cpp/core/method_ptrcall.hpp>")
-
         result.append("")
 
         result.append("namespace godot {")
@@ -1355,23 +1377,16 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
 
     result.append("")
 
-    if len(fully_used_classes) > 0:
-        includes = []
-        for included in fully_used_classes:
-            if included == "TypedArray":
-                includes.append("godot_cpp/variant/typed_array.hpp")
-            else:
-                includes.append(f"godot_cpp/{get_include_path(included)}")
-
-        includes.sort()
-
-        for include in includes:
-            result.append(f"#include <{include}>")
-
-        result.append("")
+    for included in fully_used_classes:
+        if included == "TypedArray":
+            result.append("#include <godot_cpp/variant/typed_array.hpp>")
+        else:
+            result.append(f"#include <godot_cpp/{get_include_path(included)}>")
 
     if class_name == "EditorPlugin":
         result.append("#include <godot_cpp/classes/editor_plugin_registration.hpp>")
+
+    if len(fully_used_classes) > 0:
         result.append("")
 
     if class_name != "Object" and class_name != "ClassDBSingleton":
@@ -1405,19 +1420,12 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
         result.append(f"\tGDEXTENSION_CLASS({class_name}, {inherits})")
     result.append("")
 
-    if is_singleton:
-        result.append(f"\tstatic {class_name} *singleton;")
-        result.append("")
-
     result.append("public:")
+    result.append("")
 
     if "enums" in class_api:
         for enum_api in class_api["enums"]:
-            if enum_api["is_bitfield"]:
-                result.append(f'\tenum {enum_api["name"]} : uint64_t {{')
-            else:
-                result.append(f'\tenum {enum_api["name"]} {{')
-
+            result.append(f'\tenum {enum_api["name"]} {{')
             for value in enum_api["values"]:
                 result.append(f'\t\t{value["name"]} = {value["value"]},')
             result.append("\t};")
@@ -1442,10 +1450,6 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
 
             vararg = "is_vararg" in method and method["is_vararg"]
 
-            if vararg:
-                result.append("")
-                result.append("private:")
-
             method_signature = "\t"
             method_signature += make_signature(
                 class_name, method, for_header=True, use_template_get_node=use_template_get_node
@@ -1453,8 +1457,6 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
             result.append(method_signature + ";")
 
             if vararg:
-                result.append("")
-                result.append("public:")
                 # Add templated version.
                 result += make_varargs_template(method)
 
@@ -1469,8 +1471,6 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
             )
             result.append(method_signature + ";")
 
-        result.append("")
-
     result.append("protected:")
     # T is the custom class we want to register (from which the call initiates, going up the inheritance chain),
     # B is its base class (can be a custom class too, that's why we pass it).
@@ -1487,18 +1487,13 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
                     # If the method is different from the base class, it means T overrides it, so it needs to be bound.
                     # Note that with an `if constexpr`, the code inside the `if` will not even be compiled if the
                     # condition returns false (in such cases it can't compile due to ambiguity).
-                    f"\t\tif constexpr (!std::is_same_v<decltype(&B::{method_name}), decltype(&T::{method_name})>) {{"
+                    f"\t\tif constexpr (!std::is_same_v<decltype(&B::{method_name}),decltype(&T::{method_name})>) {{"
                 )
                 result.append(f"\t\t\tBIND_VIRTUAL_METHOD(T, {method_name});")
                 result.append("\t\t}")
 
     result.append("\t}")
     result.append("")
-
-    if is_singleton:
-        result.append(f"\t~{class_name}();")
-        result.append("")
-
     result.append("public:")
 
     # Special cases.
@@ -1511,7 +1506,7 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
 
     if class_name == "WorkerThreadPool":
         result.append("\tenum {")
-        result.append("\t\tINVALID_TASK_ID = -1")
+        result.append("\tINVALID_TASK_ID = -1")
         result.append("\t};")
         result.append("\ttypedef int64_t TaskID;")
         result.append("\ttypedef int64_t GroupID;")
@@ -1523,6 +1518,8 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
         )
 
     if class_name == "Object":
+        result.append("")
+
         result.append("\ttemplate <typename T>")
         result.append("\tstatic T *cast_to(Object *p_object);")
 
@@ -1537,6 +1534,7 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
             "\tT *get_node(const NodePath &p_path) const { return Object::cast_to<T>(get_node_internal(p_path)); }"
         )
 
+    result.append("")
     result.append("};")
     result.append("")
 
@@ -1620,7 +1618,7 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
 
             result.append(method_body)
             result.append("\t} \\")
-        result.append("\t")
+        result.append("\t;")
         result.append("")
 
         result.append("#define CLASSDB_SINGLETON_VARIANT_CAST \\")
@@ -1632,11 +1630,10 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
                 else:
                     result.append(f'\tVARIANT_ENUM_CAST({class_api["alias_for"]}::{enum_api["name"]}); \\')
 
-        result.append("\t")
+        result.append("\t;")
         result.append("")
 
     result.append(f"#endif // ! {header_guard}")
-    result.append("")
 
     return "\n".join(result)
 
@@ -1653,31 +1650,23 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
 
     result.append(f"#include <godot_cpp/classes/{snake_class_name}.hpp>")
     result.append("")
-    result.append("#include <godot_cpp/core/class_db.hpp>")
     result.append("#include <godot_cpp/core/engine_ptrcall.hpp>")
     result.append("#include <godot_cpp/core/error_macros.hpp>")
     result.append("")
 
+    for included in used_classes:
+        result.append(f"#include <godot_cpp/{get_include_path(included)}>")
+
     if len(used_classes) > 0:
-        includes = []
-        for included in used_classes:
-            includes.append(f"godot_cpp/{get_include_path(included)}")
-
-        includes.sort()
-
-        for included in includes:
-            result.append(f"#include <{included}>")
-
         result.append("")
 
     result.append("namespace godot {")
     result.append("")
 
     if is_singleton:
-        result.append(f"{class_name} *{class_name}::singleton = nullptr;")
-        result.append("")
         result.append(f"{class_name} *{class_name}::get_singleton() {{")
         # We assume multi-threaded access is OK because each assignment will assign the same value every time
+        result.append(f"\tstatic {class_name} *singleton = nullptr;")
         result.append("\tif (unlikely(singleton == nullptr)) {")
         result.append(
             f"\t\tGDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton({class_name}::get_class_static()._native_ptr());"
@@ -1691,22 +1680,11 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
         result.append("#ifdef DEBUG_ENABLED")
         result.append("\t\tERR_FAIL_NULL_V(singleton, nullptr);")
         result.append("#endif // DEBUG_ENABLED")
-        result.append("\t\tif (likely(singleton)) {")
-        result.append(f"\t\t\tClassDB::_register_engine_singleton({class_name}::get_class_static(), singleton);")
-        result.append("\t\t}")
         result.append("\t}")
         result.append("\treturn singleton;")
         result.append("}")
         result.append("")
 
-        result.append(f"{class_name}::~{class_name}() {{")
-        result.append("\tif (singleton == this) {")
-        result.append(f"\t\tClassDB::_unregister_engine_singleton({class_name}::get_class_static());")
-        result.append("\t\tsingleton = nullptr;")
-        result.append("\t}")
-        result.append("}")
-        result.append("")
-
     if "methods" in class_api:
         for method in class_api["methods"]:
             if method["is_virtual"]:
@@ -1817,8 +1795,8 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
                 result.append(method_signature)
             result.append("")
 
-    result.append("} // namespace godot")
     result.append("")
+    result.append("} // namespace godot ")
 
     return "\n".join(result)
 
@@ -1841,29 +1819,22 @@ def generate_global_constants(api, output_dir):
     header.append(f"#ifndef {header_guard}")
     header.append(f"#define {header_guard}")
     header.append("")
-    header.append("#include <cstdint>")
-    header.append("")
     header.append("namespace godot {")
     header.append("")
 
-    if len(api["global_constants"]) > 0:
-        for constant in api["global_constants"]:
-            header.append(f'const int64_t {escape_identifier(constant["name"])} = {constant["value"]};')
+    for constant in api["global_constants"]:
+        header.append(f'\tconst int64_t {escape_identifier(constant["name"])} = {constant["value"]};')
 
-        header.append("")
+    header.append("")
 
     for enum_def in api["global_enums"]:
         if enum_def["name"].startswith("Variant."):
             continue
 
-        if enum_def["is_bitfield"]:
-            header.append(f'enum {enum_def["name"]} : uint64_t {{')
-        else:
-            header.append(f'enum {enum_def["name"]} {{')
-
+        header.append(f'\tenum {enum_def["name"]} {{')
         for value in enum_def["values"]:
-            header.append(f'\t{value["name"]} = {value["value"]},')
-        header.append("};")
+            header.append(f'\t\t{value["name"]} = {value["value"]},')
+        header.append("\t};")
         header.append("")
 
     header.append("} // namespace godot")
@@ -1976,17 +1947,11 @@ def generate_utility_functions(api, output_dir):
     for function in api["utility_functions"]:
         vararg = "is_vararg" in function and function["is_vararg"]
 
-        if vararg:
-            header.append("")
-            header.append("private:")
-
         function_signature = "\t"
         function_signature += make_signature("UtilityFunctions", function, for_header=True, static=True)
         header.append(function_signature + ";")
 
         if vararg:
-            header.append("")
-            header.append("public:")
             # Add templated version.
             header += make_varargs_template(function, static=True)
 
@@ -2007,8 +1972,8 @@ def generate_utility_functions(api, output_dir):
 
     source.append("#include <godot_cpp/variant/utility_functions.hpp>")
     source.append("")
-    source.append("#include <godot_cpp/core/engine_ptrcall.hpp>")
     source.append("#include <godot_cpp/core/error_macros.hpp>")
+    source.append("#include <godot_cpp/core/engine_ptrcall.hpp>")
     source.append("")
     source.append("namespace godot {")
     source.append("")
@@ -2107,7 +2072,7 @@ def make_function_parameters(parameters, include_default=False, for_builtin=Fals
         signature.append(parameter)
 
     if is_vararg:
-        signature.append("const Args &...p_args")
+        signature.append("const Args&... p_args")
 
     return ", ".join(signature)
 
@@ -2144,10 +2109,6 @@ def get_encoded_arg(arg_name, type_name, type_meta):
         result.append(f"\t{get_gdextension_type(arg_type)} {name}_encoded;")
         result.append(f"\tPtrToArg<{correct_type(type_name)}>::encode({name}, &{name}_encoded);")
         name = f"&{name}_encoded"
-    elif is_enum(type_name) and not is_bitfield(type_name):
-        result.append(f"\tint64_t {name}_encoded;")
-        result.append(f"\tPtrToArg<int64_t>::encode({name}, &{name}_encoded);")
-        name = f"&{name}_encoded"
     elif is_engine_class(type_name):
         # `{name}` is a C++ wrapper, it contains a field which is the object's pointer Godot expects.
         # We have to check `nullptr` because when the caller sends `nullptr`, the wrapper itself will be null.
@@ -2169,6 +2130,9 @@ def make_signature(
         if "is_virtual" in function_data and function_data["is_virtual"]:
             function_signature += "virtual "
 
+        if is_vararg:
+            function_signature += "private: "
+
         if static:
             function_signature += "static "
 
@@ -2217,18 +2181,10 @@ def make_signature(
     return function_signature
 
 
-def make_varargs_template(
-    function_data,
-    static=False,
-    class_befor_signature="",
-    with_indent=True,
-    for_builtin_classes=False,
-):
+def make_varargs_template(function_data, static=False):
     result = []
 
-    function_signature = ""
-
-    result.append("template <typename... Args>")
+    function_signature = "\tpublic: template <typename... Args> "
 
     if static:
         function_signature += "static "
@@ -2249,8 +2205,6 @@ def make_varargs_template(
     if not function_signature.endswith("*"):
         function_signature += " "
 
-    if len(class_befor_signature) > 0:
-        function_signature += class_befor_signature + "::"
     function_signature += f'{escape_identifier(function_data["name"])}'
 
     method_arguments = []
@@ -2271,7 +2225,7 @@ def make_varargs_template(
     function_signature += " {"
     result.append(function_signature)
 
-    args_array = f"\tstd::array<Variant, {len(method_arguments)} + sizeof...(Args)> variant_args{{ "
+    args_array = f"\t\tstd::array<Variant, {len(method_arguments)} + sizeof...(Args)> variant_args {{ "
     for argument in method_arguments:
         if argument["type"] == "Variant":
             args_array += escape_argument(argument["name"])
@@ -2281,43 +2235,20 @@ def make_varargs_template(
 
     args_array += "Variant(p_args)... };"
     result.append(args_array)
-    result.append(f"\tstd::array<const Variant *, {len(method_arguments)} + sizeof...(Args)> call_args;")
-    result.append("\tfor (size_t i = 0; i < variant_args.size(); i++) {")
-    result.append("\t\tcall_args[i] = &variant_args[i];")
+    result.append(f"\t\tstd::array<const Variant *, {len(method_arguments)} + sizeof...(Args)> call_args;")
+    result.append("\t\tfor(size_t i = 0; i < variant_args.size(); i++) {")
+    result.append("\t\t\tcall_args[i] = &variant_args[i];")
+    result.append("\t\t}")
+
+    call_line = "\t\t"
+
+    if return_type != "void":
+        call_line += "return "
+
+    call_line += f'{escape_identifier(function_data["name"])}_internal(call_args.data(), variant_args.size());'
+    result.append(call_line)
     result.append("\t}")
 
-    call_line = "\t"
-
-    if not for_builtin_classes:
-        if return_type != "void":
-            call_line += "return "
-
-        call_line += f'{escape_identifier(function_data["name"])}_internal(call_args.data(), variant_args.size());'
-        result.append(call_line)
-    else:
-        base = "(GDExtensionTypePtr)&opaque"
-        if static:
-            base = "nullptr"
-
-        ret = "nullptr"
-        if return_type != "void":
-            ret = "&ret"
-            result.append(f'\t{correct_type(function_data["return_type"])} ret;')
-
-        function_name = function_data["name"]
-        result.append(
-            f"\t_method_bindings.method_{function_name}({base}, reinterpret_cast<GDExtensionConstTypePtr *>(call_args.data()), {ret}, {len(method_arguments)} + sizeof...(Args));"
-        )
-
-        if return_type != "void":
-            result.append("\treturn ret;")
-
-    result.append("}")
-
-    if with_indent:
-        for i in range(len(result)):
-            result[i] = "\t" + result[i]
-
     return result
 
 
@@ -2456,6 +2387,20 @@ def is_refcounted(type_name):
     return type_name in engine_classes and engine_classes[type_name]
 
 
+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_included(type_name, current_type):
     """
     Check if a builtin type should be included.

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/ref.hpp

@@ -230,9 +230,7 @@ template <typename 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))));
 	}
 
@@ -256,9 +254,7 @@ struct PtrToArg<const Ref<T> &> {
 
 	_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))));
 	}
 };

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,25 +60,23 @@ 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) {}
+	virtual void _notificationv(int32_t p_what) {}
 
 	Wrapped(const StringName p_godot_class);
 	Wrapped(GodotObject *p_godot_object);
@@ -110,9 +98,6 @@ public:
 
 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);
@@ -133,10 +118,7 @@ struct EngineClassRegistration {
 
 } // 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*/) {}                                                                                                                                      \
 	friend class ::godot::ClassDB;                                                                                                                                                     \
@@ -179,10 +161,6 @@ 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;                                                                                                   \
 	}                                                                                                                                                                                  \
@@ -218,18 +196,18 @@ public:
 		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);                                                                                                         \
-			}                                                                                                                                                                          \
+			m_inherits::notification_bind(p_instance, p_what);                                                                                                                         \
 			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);                                                                                                         \
-			}                                                                                                                                                                          \
 		}                                                                                                                                                                              \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
@@ -259,28 +237,40 @@ public:
 		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 +296,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()) {                                                                                                           \
@@ -359,8 +334,8 @@ public:
 	};                                                                                                                                                                                 \
                                                                                                                                                                                        \
 protected:                                                                                                                                                                             \
-	virtual void _notificationv(int32_t p_what, bool p_reversed = false) override {                                                                                                    \
-		m_class::notification_bind(this, p_what, p_reversed);                                                                                                                          \
+	virtual void _notificationv(int32_t p_what) override {                                                                                                                             \
+		m_class::notification_bind(this, p_what);                                                                                                                                      \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
 private:
@@ -437,12 +412,16 @@ public:
 		return m_inherits::get_class_static();                                                                                                                                         \
 	}                                                                                                                                                                                  \
                                                                                                                                                                                        \
+	static GDExtensionObjectPtr create(void *data) {                                                                                                                                   \
+		return nullptr;                                                                                                                                                                \
+	}                                                                                                                                                                                  \
+                                                                                                                                                                                       \
 	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 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 */                                                                                     \

include/godot_cpp/core/binder_common.hpp

@@ -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>
 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
@@ -370,7 +316,7 @@ void call_with_variant_argsc_dv(T *p_instance, void (T::*p_method)(P...) const,
 #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
@@ -405,7 +351,7 @@ void call_with_variant_args_ret_dv(T *p_instance, R (T::*p_method)(P...), const
 #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
@@ -440,7 +386,7 @@ void call_with_variant_args_retc_dv(T *p_instance, R (T::*p_method)(P...) const,
 #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
@@ -552,7 +498,7 @@ void call_with_variant_args_static_dv(void (*p_method)(P...), const GDExtensionC
 #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
@@ -592,42 +538,6 @@ void call_with_ptr_args_static_method(void (*p_method)(P...), const GDExtensionC
 	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>
 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;
@@ -644,7 +554,7 @@ void call_with_variant_args_static_ret_dv(R (*p_method)(P...), const GDExtension
 #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

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,70 +109,24 @@ 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;
-		}
-	}
+	static void _register_class(bool p_virtual = false);
 
 public:
 	template <typename T>
 	static void register_class(bool p_virtual = false);
 	template <typename T>
 	static void register_abstract_class();
-	template <typename T>
-	static void register_internal_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>
 	static MethodBind *bind_method(N p_method_name, M p_method, VarArgs... p_args);
 
@@ -214,7 +172,7 @@ public:
 	}
 
 template <typename T, bool is_abstract>
-void ClassDB::_register_class(bool p_virtual, bool p_exposed) {
+void ClassDB::_register_class(bool p_virtual) {
 	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.");
@@ -234,32 +192,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();
@@ -278,11 +231,6 @@ 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 <typename N, typename 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.
@@ -341,7 +289,6 @@ MethodBind *ClassDB::bind_vararg_method(uint32_t p_flags, StringName p_name, M p
 #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>();
 
 } // namespace godot
 

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)
@@ -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/memory.hpp

@@ -40,21 +40,20 @@
 
 #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
+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, const char *p_dummy, void *p_pointer, size_t check, const char *p_description) {
+_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 {
@@ -94,10 +93,10 @@ _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>
@@ -169,7 +168,7 @@ T *memnew_arr_template(size_t p_elements, const char *p_descr = "") {
 
 		/* 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;
 		}
 	}
 

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>
@@ -51,7 +49,6 @@
 #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)
 
 namespace godot {
 
@@ -108,6 +105,28 @@ MethodInfo::MethodInfo(const PropertyInfo &p_ret, StringName p_name, const Args
 	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) {

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

@@ -114,6 +114,17 @@ struct PropertyInfo {
 		p_info->usage = usage;
 		*(reinterpret_cast<StringName *>(p_info->class_name)) = class_name;
 	}
+
+	GDExtensionPropertyInfo _to_gdextension() const {
+		return {
+			(GDExtensionVariantType)type,
+			name._native_ptr(),
+			class_name._native_ptr(),
+			hint,
+			hint_string._native_ptr(),
+			usage,
+		};
+	}
 };
 
 } // namespace godot

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;

include/godot_cpp/variant/aabb.hpp

@@ -202,11 +202,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/basis.hpp

@@ -224,7 +224,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/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,11 +47,11 @@ 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;
@@ -67,13 +66,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 +89,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 +128,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 +144,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 +187,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 +213,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 +229,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/variant.hpp

@@ -324,6 +324,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 +354,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/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;

misc/scripts/check_get_file_list.py

@@ -6,40 +6,26 @@ 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 generate_bindings, get_file_list
 
 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!")

src/classes/wrapped.cpp

@@ -56,25 +56,6 @@ void Wrapped::_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()));
 }
 
@@ -93,31 +74,6 @@ std::vector<EngineClassRegistrationCallback> &get_engine_class_registration_call
 	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);
 }

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) {
@@ -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) {
@@ -380,22 +386,6 @@ void ClassDB::deinitialize(GDExtensionInitializationLevel p_level) {
 		});
 		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);
-		}
-	}
 }
 
 } // namespace godot

src/core/memory.cpp

@@ -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/godot.cpp

@@ -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;
@@ -367,8 +359,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 +394,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);

src/variant/basis.cpp

@@ -1037,15 +1037,12 @@ void Basis::rotate_sh(real_t *p_values) {
 	p_values[8] = d4 * s_scale_dst4;
 }
 
-Basis Basis::looking_at(const Vector3 &p_target, const Vector3 &p_up, bool p_use_model_front) {
+Basis Basis::looking_at(const Vector3 &p_target, const Vector3 &p_up) {
 #ifdef MATH_CHECKS
 	ERR_FAIL_COND_V_MSG(p_target.is_zero_approx(), Basis(), "The target vector can't be zero.");
 	ERR_FAIL_COND_V_MSG(p_up.is_zero_approx(), Basis(), "The up vector can't be zero.");
 #endif
-	Vector3 v_z = p_target.normalized();
-	if (!p_use_model_front) {
-		v_z = -v_z;
-	}
+	Vector3 v_z = -p_target.normalized();
 	Vector3 v_x = p_up.cross(v_z);
 #ifdef MATH_CHECKS
 	ERR_FAIL_COND_V_MSG(v_x.is_zero_approx(), Basis(), "The target vector and up vector can't be parallel to each other.");

src/variant/callable_custom.cpp

@@ -1,113 +0,0 @@
-/**************************************************************************/
-/*  callable_custom.cpp                                                   */
-/**************************************************************************/
-/*                         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.                 */
-/**************************************************************************/
-
-#include <godot_cpp/variant/callable_custom.hpp>
-
-#include <godot_cpp/core/object.hpp>
-#include <godot_cpp/variant/callable.hpp>
-
-namespace godot {
-
-static void callable_custom_call(void *p_userdata, const GDExtensionConstVariantPtr *p_args, GDExtensionInt p_argument_count, GDExtensionVariantPtr r_return, GDExtensionCallError *r_error) {
-	CallableCustom *callable_custom = (CallableCustom *)p_userdata;
-	callable_custom->call((const Variant **)p_args, p_argument_count, *(Variant *)r_return, *r_error);
-}
-
-static GDExtensionBool callable_custom_is_valid(void *p_userdata) {
-	CallableCustom *callable_custom = (CallableCustom *)p_userdata;
-	return callable_custom->is_valid();
-}
-
-static void callable_custom_free(void *p_userdata) {
-	CallableCustom *callable_custom = (CallableCustom *)p_userdata;
-	memdelete(callable_custom);
-}
-
-static uint32_t callable_custom_hash(void *p_userdata) {
-	CallableCustom *callable_custom = (CallableCustom *)p_userdata;
-	return callable_custom->hash();
-}
-
-static void callable_custom_to_string(void *p_userdata, GDExtensionBool *r_is_valid, GDExtensionStringPtr r_out) {
-	CallableCustom *callable_custom = (CallableCustom *)p_userdata;
-	*((String *)r_out) = callable_custom->get_as_text();
-	*r_is_valid = true;
-}
-
-static GDExtensionBool callable_custom_equal_func(void *p_a, void *p_b) {
-	CallableCustom *a = (CallableCustom *)p_a;
-	CallableCustom *b = (CallableCustom *)p_b;
-	CallableCustom::CompareEqualFunc func_a = a->get_compare_equal_func();
-	CallableCustom::CompareEqualFunc func_b = b->get_compare_equal_func();
-	if (func_a != func_b) {
-		return false;
-	}
-	return func_a(a, b);
-}
-
-static GDExtensionBool callable_custom_less_than_func(void *p_a, void *p_b) {
-	CallableCustom *a = (CallableCustom *)p_a;
-	CallableCustom *b = (CallableCustom *)p_b;
-	CallableCustom::CompareEqualFunc func_a = a->get_compare_less_func();
-	CallableCustom::CompareEqualFunc func_b = b->get_compare_less_func();
-	if (func_a != func_b) {
-		// Just compare the addresses.
-		return p_a < p_b;
-	}
-	return func_a(a, b);
-}
-
-bool CallableCustom::is_valid() const {
-	// The same default implementation as in Godot.
-	return ObjectDB::get_instance(get_object());
-}
-
-Callable::Callable(CallableCustom *p_callable_custom) {
-	GDExtensionCallableCustomInfo info = {};
-	info.callable_userdata = p_callable_custom;
-	info.token = internal::token;
-	info.object_id = p_callable_custom->get_object();
-	info.call_func = &callable_custom_call;
-	info.is_valid_func = &callable_custom_is_valid;
-	info.free_func = &callable_custom_free;
-	info.hash_func = &callable_custom_hash;
-	info.equal_func = &callable_custom_equal_func;
-	info.less_than_func = &callable_custom_less_than_func;
-	info.to_string_func = &callable_custom_to_string;
-
-	::godot::internal::gdextension_interface_callable_custom_create(_native_ptr(), &info);
-}
-
-CallableCustom *Callable::get_custom() const {
-	CallableCustomBase *callable_custom = (CallableCustomBase *)::godot::internal::gdextension_interface_callable_custom_get_userdata(_native_ptr(), internal::token);
-	return dynamic_cast<CallableCustom *>(callable_custom);
-}
-
-} // namespace godot

src/variant/callable_method_pointer.cpp

@@ -1,114 +0,0 @@
-/**************************************************************************/
-/*  callable_method_pointer.cpp                                           */
-/**************************************************************************/
-/*                         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.                 */
-/**************************************************************************/
-
-#include <godot_cpp/variant/callable_method_pointer.hpp>
-
-#include <godot_cpp/templates/hashfuncs.hpp>
-
-namespace godot {
-
-static void custom_callable_mp_call(void *p_userdata, const GDExtensionConstVariantPtr *p_args, GDExtensionInt p_argument_count, GDExtensionVariantPtr r_return, GDExtensionCallError *r_error) {
-	CallableCustomMethodPointerBase *callable_method_pointer = (CallableCustomMethodPointerBase *)p_userdata;
-	callable_method_pointer->call((const Variant **)p_args, p_argument_count, *(Variant *)r_return, *r_error);
-}
-
-static GDExtensionBool custom_callable_mp_is_valid(void *p_userdata) {
-	CallableCustomMethodPointerBase *callable_method_pointer = (CallableCustomMethodPointerBase *)p_userdata;
-	ObjectID object = callable_method_pointer->get_object();
-	return object == ObjectID() || ObjectDB::get_instance(object);
-}
-
-static void custom_callable_mp_free(void *p_userdata) {
-	CallableCustomMethodPointerBase *callable_method_pointer = (CallableCustomMethodPointerBase *)p_userdata;
-	memdelete(callable_method_pointer);
-}
-
-static uint32_t custom_callable_mp_hash(void *p_userdata) {
-	CallableCustomMethodPointerBase *callable_method_pointer = (CallableCustomMethodPointerBase *)p_userdata;
-	return callable_method_pointer->get_hash();
-}
-
-static GDExtensionBool custom_callable_mp_equal_func(void *p_a, void *p_b) {
-	CallableCustomMethodPointerBase *a = (CallableCustomMethodPointerBase *)p_a;
-	CallableCustomMethodPointerBase *b = (CallableCustomMethodPointerBase *)p_b;
-
-	if (a->get_comp_size() != b->get_comp_size()) {
-		return false;
-	}
-
-	return memcmp(a->get_comp_ptr(), b->get_comp_ptr(), a->get_comp_size() * 4) == 0;
-}
-
-static GDExtensionBool custom_callable_mp_less_than_func(void *p_a, void *p_b) {
-	CallableCustomMethodPointerBase *a = (CallableCustomMethodPointerBase *)p_a;
-	CallableCustomMethodPointerBase *b = (CallableCustomMethodPointerBase *)p_b;
-
-	if (a->get_comp_size() != b->get_comp_size()) {
-		return a->get_comp_size() < b->get_comp_size();
-	}
-
-	return memcmp(a->get_comp_ptr(), b->get_comp_ptr(), a->get_comp_size() * 4) < 0;
-}
-
-void CallableCustomMethodPointerBase::_setup(uint32_t *p_base_ptr, uint32_t p_ptr_size) {
-	comp_ptr = p_base_ptr;
-	comp_size = p_ptr_size / 4;
-
-	for (uint32_t i = 0; i < comp_size; i++) {
-		if (i == 0) {
-			h = hash_murmur3_one_32(comp_ptr[i]);
-		} else {
-			h = hash_murmur3_one_32(comp_ptr[i], h);
-		}
-	}
-}
-
-namespace internal {
-
-Callable create_callable_from_ccmp(CallableCustomMethodPointerBase *p_callable_method_pointer) {
-	GDExtensionCallableCustomInfo info = {};
-	info.callable_userdata = p_callable_method_pointer;
-	info.token = internal::token;
-	info.object_id = p_callable_method_pointer->get_object();
-	info.call_func = &custom_callable_mp_call;
-	info.is_valid_func = &custom_callable_mp_is_valid;
-	info.free_func = &custom_callable_mp_free;
-	info.hash_func = &custom_callable_mp_hash;
-	info.equal_func = &custom_callable_mp_equal_func;
-	info.less_than_func = &custom_callable_mp_less_than_func;
-
-	Callable callable;
-	::godot::internal::gdextension_interface_callable_custom_create(callable._native_ptr(), &info);
-	return callable;
-}
-
-} // namespace internal
-
-} // namespace godot

src/variant/char_string.cpp

@@ -289,10 +289,6 @@ CharWideString String::wide_string() const {
 	return str;
 }
 
-Error String::resize(int64_t p_size) {
-	return (Error)internal::gdextension_interface_string_resize(_native_ptr(), p_size);
-}
-
 String &String::operator=(const char *p_str) {
 	*this = String(p_str);
 	return *this;
@@ -458,9 +454,8 @@ String operator+(char32_t p_char, const String &p_str) {
 	return String::chr(p_char) + p_str;
 }
 
-StringName::StringName(const char *from, bool p_static) {
-	internal::gdextension_interface_string_name_new_with_latin1_chars(&opaque, from, p_static);
-}
+StringName::StringName(const char *from) :
+		StringName(String(from)) {}
 
 StringName::StringName(const wchar_t *from) :
 		StringName(String(from)) {}

src/variant/quaternion.cpp

@@ -37,15 +37,28 @@ namespace godot {
 
 real_t Quaternion::angle_to(const Quaternion &p_to) const {
 	real_t d = dot(p_to);
-	// acos does clamping.
-	return Math::acos(d * d * 2 - 1);
+	return Math::acos(CLAMP(d * d * 2 - 1, -1, 1));
 }
 
-Vector3 Quaternion::get_euler(EulerOrder p_order) const {
+// get_euler_xyz returns a vector containing the Euler angles in the format
+// (ax,ay,az), where ax is the angle of rotation around x axis,
+// and similar for other axes.
+// This implementation uses XYZ convention (Z is the first rotation).
+Vector3 Quaternion::get_euler_xyz() const {
+	Basis m(*this);
+	return m.get_euler(EULER_ORDER_XYZ);
+}
+
+// get_euler_yxz returns a vector containing the Euler angles in the format
+// (ax,ay,az), where ax is the angle of rotation around x axis,
+// and similar for other axes.
+// This implementation uses YXZ convention (Z is the first rotation).
+Vector3 Quaternion::get_euler_yxz() const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V_MSG(!is_normalized(), Vector3(0, 0, 0), "The quaternion " + operator String() + " must be normalized.");
+	ERR_FAIL_COND_V_MSG(!is_normalized(), Vector3(0, 0, 0), "The quaternion must be normalized.");
 #endif
-	return Basis(*this).get_euler(p_order);
+	Basis m(*this);
+	return m.get_euler(EULER_ORDER_YXZ);
 }
 
 void Quaternion::operator*=(const Quaternion &p_q) {
@@ -90,7 +103,7 @@ bool Quaternion::is_normalized() const {
 
 Quaternion Quaternion::inverse() const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The quaternion " + operator String() + " must be normalized.");
+	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The quaternion must be normalized.");
 #endif
 	return Quaternion(-x, -y, -z, w);
 }
@@ -112,10 +125,10 @@ Quaternion Quaternion::exp() const {
 	return Quaternion(src_v, theta);
 }
 
-Quaternion Quaternion::slerp(const Quaternion &p_to, real_t p_weight) const {
+Quaternion Quaternion::slerp(const Quaternion &p_to, const real_t &p_weight) const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion " + operator String() + " must be normalized.");
-	ERR_FAIL_COND_V_MSG(!p_to.is_normalized(), Quaternion(), "The end quaternion " + p_to.operator String() + " must be normalized.");
+	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion must be normalized.");
+	ERR_FAIL_COND_V_MSG(!p_to.is_normalized(), Quaternion(), "The end quaternion must be normalized.");
 #endif
 	Quaternion to1;
 	real_t omega, cosom, sinom, scale0, scale1;
@@ -153,10 +166,10 @@ Quaternion Quaternion::slerp(const Quaternion &p_to, real_t p_weight) const {
 			scale0 * w + scale1 * to1.w);
 }
 
-Quaternion Quaternion::slerpni(const Quaternion &p_to, real_t p_weight) const {
+Quaternion Quaternion::slerpni(const Quaternion &p_to, const real_t &p_weight) const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion " + operator String() + " must be normalized.");
-	ERR_FAIL_COND_V_MSG(!p_to.is_normalized(), Quaternion(), "The end quaternion " + p_to.operator String() + " must be normalized.");
+	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion must be normalized.");
+	ERR_FAIL_COND_V_MSG(!p_to.is_normalized(), Quaternion(), "The end quaternion must be normalized.");
 #endif
 	const Quaternion &from = *this;
 
@@ -177,10 +190,10 @@ Quaternion Quaternion::slerpni(const Quaternion &p_to, real_t p_weight) const {
 			invFactor * from.w + newFactor * p_to.w);
 }
 
-Quaternion Quaternion::spherical_cubic_interpolate(const Quaternion &p_b, const Quaternion &p_pre_a, const Quaternion &p_post_b, real_t p_weight) const {
+Quaternion Quaternion::spherical_cubic_interpolate(const Quaternion &p_b, const Quaternion &p_pre_a, const Quaternion &p_post_b, const real_t &p_weight) const {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion " + operator String() + " must be normalized.");
-	ERR_FAIL_COND_V_MSG(!p_b.is_normalized(), Quaternion(), "The end quaternion " + p_b.operator String() + " must be normalized.");
+	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion must be normalized.");
+	ERR_FAIL_COND_V_MSG(!p_b.is_normalized(), Quaternion(), "The end quaternion must be normalized.");
 #endif
 	Quaternion from_q = *this;
 	Quaternion pre_q = p_pre_a;
@@ -223,15 +236,15 @@ Quaternion Quaternion::spherical_cubic_interpolate(const Quaternion &p_b, const
 	ln.z = Math::cubic_interpolate(ln_from.z, ln_to.z, ln_pre.z, ln_post.z, p_weight);
 	Quaternion q2 = to_q * ln.exp();
 
-	// To cancel error made by Expmap ambiguity, do blending.
+	// To cancel error made by Expmap ambiguity, do blends.
 	return q1.slerp(q2, p_weight);
 }
 
-Quaternion 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 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 {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion " + operator String() + " must be normalized.");
-	ERR_FAIL_COND_V_MSG(!p_b.is_normalized(), Quaternion(), "The end quaternion " + p_b.operator String() + " must be normalized.");
+	ERR_FAIL_COND_V_MSG(!is_normalized(), Quaternion(), "The start quaternion must be normalized.");
+	ERR_FAIL_COND_V_MSG(!p_b.is_normalized(), Quaternion(), "The end quaternion must be normalized.");
 #endif
 	Quaternion from_q = *this;
 	Quaternion pre_q = p_pre_a;
@@ -274,7 +287,7 @@ Quaternion Quaternion::spherical_cubic_interpolate_in_time(const Quaternion &p_b
 	ln.z = Math::cubic_interpolate_in_time(ln_from.z, ln_to.z, ln_pre.z, ln_post.z, p_weight, p_b_t, p_pre_a_t, p_post_b_t);
 	Quaternion q2 = to_q * ln.exp();
 
-	// To cancel error made by Expmap ambiguity, do blending.
+	// To cancel error made by Expmap ambiguity, do blends.
 	return q1.slerp(q2, p_weight);
 }
 
@@ -296,7 +309,7 @@ real_t Quaternion::get_angle() const {
 
 Quaternion::Quaternion(const Vector3 &p_axis, real_t p_angle) {
 #ifdef MATH_CHECKS
-	ERR_FAIL_COND_MSG(!p_axis.is_normalized(), "The axis Vector3 " + p_axis.operator String() + " must be normalized.");
+	ERR_FAIL_COND_MSG(!p_axis.is_normalized(), "The axis Vector3 must be normalized.");
 #endif
 	real_t d = p_axis.length();
 	if (d == 0) {
@@ -319,7 +332,7 @@ Quaternion::Quaternion(const Vector3 &p_axis, real_t p_angle) {
 // (ax, ay, az), where ax is the angle of rotation around x axis,
 // and similar for other axes.
 // This implementation uses YXZ convention (Z is the first rotation).
-Quaternion Quaternion::from_euler(const Vector3 &p_euler) {
+Quaternion::Quaternion(const Vector3 &p_euler) {
 	real_t half_a1 = p_euler.y * 0.5f;
 	real_t half_a2 = p_euler.x * 0.5f;
 	real_t half_a3 = p_euler.z * 0.5f;
@@ -335,11 +348,10 @@ Quaternion Quaternion::from_euler(const Vector3 &p_euler) {
 	real_t cos_a3 = Math::cos(half_a3);
 	real_t sin_a3 = Math::sin(half_a3);
 
-	return Quaternion(
-			sin_a1 * cos_a2 * sin_a3 + cos_a1 * sin_a2 * cos_a3,
-			sin_a1 * cos_a2 * cos_a3 - cos_a1 * sin_a2 * sin_a3,
-			-sin_a1 * sin_a2 * cos_a3 + cos_a1 * cos_a2 * sin_a3,
-			sin_a1 * sin_a2 * sin_a3 + cos_a1 * cos_a2 * cos_a3);
+	x = sin_a1 * cos_a2 * sin_a3 + cos_a1 * sin_a2 * cos_a3;
+	y = sin_a1 * cos_a2 * cos_a3 - cos_a1 * sin_a2 * sin_a3;
+	z = -sin_a1 * sin_a2 * cos_a3 + cos_a1 * cos_a2 * sin_a3;
+	w = sin_a1 * sin_a2 * sin_a3 + cos_a1 * cos_a2 * cos_a3;
 }
 
 } // namespace godot

test/CMakeLists.txt

@@ -72,7 +72,7 @@ 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).
-option(GODOT_DISABLE_EXCEPTIONS ON "Force disabling exception handling code")
+option(GODOT_DISABLE_EXCEPTIONS OFF "Force disabling exception handling code")
 if (GODOT_DISABLE_EXCEPTIONS)
 	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -D_HAS_EXCEPTIONS=0")

test/SConstruct

@@ -21,22 +21,10 @@ if env["platform"] == "macos":
         ),
         source=sources,
     )
-elif env["platform"] == "ios":
-    if env["ios_simulator"]:
-        library = env.StaticLibrary(
-            "project/bin/libgdexample.{}.{}.simulator.a".format(env["platform"], env["target"]),
-            source=sources,
-        )
-    else:
-        library = env.StaticLibrary(
-            "project/bin/libgdexample.{}.{}.a".format(env["platform"], env["target"]),
-            source=sources,
-        )
 else:
     library = env.SharedLibrary(
         "project/bin/libgdexample{}{}".format(env["suffix"], env["SHLIBSUFFIX"]),
         source=sources,
     )
 
-env.NoCache(library)
 Default(library)

test/build_profile.json

@@ -1,13 +1,9 @@
 {
 	"enabled_classes": [
 		"Control",
-		"InputEventKey",
 		"Label",
-		"MultiplayerAPI",
-		"MultiplayerPeer",
 		"OS",
 		"TileMap",
-		"TileSet",
-		"Viewport"
+		"InputEventKey"
 	]
 }

test/generate_xcframework.sh

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-scons arch=universal ios_simulator=yes platform=ios target=$1 $2
-scons arch=arm64 ios_simulator=no platform=ios target=$1 $2
-
-xcodebuild -create-xcframework -library ./project/bin/libgdexample.ios.$1.a -library ./project/bin/libgdexample.ios.$1.simulator.a -output ./project/bin/libgdexample.ios.$1.xcframework
-xcodebuild -create-xcframework -library ../bin/libgodot-cpp.ios.$1.arm64.a -library ../bin/libgodot-cpp.ios.$1.universal.simulator.a  -output ./project/bin/libgodot-cpp.ios.$1.xcframework

test/project/example.gdextension

@@ -11,14 +11,8 @@ windows.debug.x86_32 = "res://bin/libgdexample.windows.template_debug.x86_32.dll
 windows.release.x86_32 = "res://bin/libgdexample.windows.template_release.x86_32.dll"
 windows.debug.x86_64 = "res://bin/libgdexample.windows.template_debug.x86_64.dll"
 windows.release.x86_64 = "res://bin/libgdexample.windows.template_release.x86_64.dll"
-windows.debug.arm64 = "res://bin/libgdexample.windows.template_debug.arm64.dll"
-windows.release.arm64 = "res://bin/libgdexample.windows.template_release.arm64.dll"
-linux.debug.x86_32 = "res://bin/libgdexample.linux.template_debug.x86_32.so"
-linux.release.x86_32 = "res://bin/libgdexample.linux.template_release.x86_32.so"
 linux.debug.x86_64 = "res://bin/libgdexample.linux.template_debug.x86_64.so"
 linux.release.x86_64 = "res://bin/libgdexample.linux.template_release.x86_64.so"
-linux.debug.arm32 = "res://bin/libgdexample.linux.template_debug.arm32.so"
-linux.release.arm32 = "res://bin/libgdexample.linux.template_release.arm32.so"
 linux.debug.arm64 = "res://bin/libgdexample.linux.template_debug.arm64.so"
 linux.release.arm64 = "res://bin/libgdexample.linux.template_release.arm64.so"
 linux.debug.rv64 = "res://bin/libgdexample.linux.template_debug.rv64.so"

test/project/main.gd

@@ -26,10 +26,6 @@ func _ready():
 	# Property list.
 	example.property_from_list = Vector3(100, 200, 300)
 	assert_equal(example.property_from_list, Vector3(100, 200, 300))
-	var prop_list = example.get_property_list()
-	for prop_info in prop_list:
-		if prop_info['name'] == 'mouse_filter':
-			assert_equal(prop_info['usage'], PROPERTY_USAGE_NO_EDITOR)
 
 	# Call simple methods.
 	example.simple_func()
@@ -83,9 +79,6 @@ func _ready():
 	var array: Array[int] = [1, 2, 3]
 	assert_equal(example.test_tarray_arg(array), 6)
 
-	example.callable_bind()
-	assert_equal(custom_signal_emitted, ["bound", 11])
-
 	# String += operator
 	assert_equal(example.test_string_ops(), "ABCĎE")
 
@@ -96,62 +89,6 @@ func _ready():
 	assert_equal(example.test_string_is_forty_two("blah"), false)
 	assert_equal(example.test_string_is_forty_two("forty two"), true)
 
-	# String::resize().
-	assert_equal(example.test_string_resize("What"), "What!?")
-
-	# mp_callable() with void method.
-	var mp_callable: Callable = example.test_callable_mp()
-	assert_equal(mp_callable.is_valid(), true)
-	mp_callable.call(example, "void", 36)
-	assert_equal(custom_signal_emitted, ["unbound_method1: Example - void", 36])
-
-	# Check that it works with is_connected().
-	assert_equal(example.renamed.is_connected(mp_callable), false)
-	example.renamed.connect(mp_callable)
-	assert_equal(example.renamed.is_connected(mp_callable), true)
-	# Make sure a new object is still treated as equivalent.
-	assert_equal(example.renamed.is_connected(example.test_callable_mp()), true)
-	assert_equal(mp_callable.hash(), example.test_callable_mp().hash())
-	example.renamed.disconnect(mp_callable)
-	assert_equal(example.renamed.is_connected(mp_callable), false)
-
-	# mp_callable() with return value.
-	var mp_callable_ret: Callable = example.test_callable_mp_ret()
-	assert_equal(mp_callable_ret.call(example, "test", 77), "unbound_method2: Example - test - 77")
-
-	# mp_callable() with const method and return value.
-	var mp_callable_retc: Callable = example.test_callable_mp_retc()
-	assert_equal(mp_callable_retc.call(example, "const", 101), "unbound_method3: Example - const - 101")
-
-	# mp_callable_static() with void method.
-	var mp_callable_static: Callable = example.test_callable_mp_static()
-	mp_callable_static.call(example, "static", 83)
-	assert_equal(custom_signal_emitted, ["unbound_static_method1: Example - static", 83])
-
-	# Check that it works with is_connected().
-	assert_equal(example.renamed.is_connected(mp_callable_static), false)
-	example.renamed.connect(mp_callable_static)
-	assert_equal(example.renamed.is_connected(mp_callable_static), true)
-	# Make sure a new object is still treated as equivalent.
-	assert_equal(example.renamed.is_connected(example.test_callable_mp_static()), true)
-	assert_equal(mp_callable_static.hash(), example.test_callable_mp_static().hash())
-	example.renamed.disconnect(mp_callable_static)
-	assert_equal(example.renamed.is_connected(mp_callable_static), false)
-
-	# mp_callable_static() with return value.
-	var mp_callable_static_ret: Callable = example.test_callable_mp_static_ret()
-	assert_equal(mp_callable_static_ret.call(example, "static-ret", 84), "unbound_static_method2: Example - static-ret - 84")
-
-	# CallableCustom.
-	var custom_callable: Callable = example.test_custom_callable();
-	assert_equal(custom_callable.is_custom(), true);
-	assert_equal(custom_callable.is_valid(), true);
-	assert_equal(custom_callable.call(), "Hi")
-	assert_equal(custom_callable.hash(), 27);
-	assert_equal(custom_callable.get_object(), null);
-	assert_equal(custom_callable.get_method(), "");
-	assert_equal(str(custom_callable), "<MyCallableCustom>");
-
 	# PackedArray iterators
 	assert_equal(example.test_vector_ops(), 105)
 	assert_equal(example.test_vector_init_list(), 105)
@@ -223,10 +160,6 @@ func _ready():
 	assert_equal(example.test_bitfield(0), 0)
 	assert_equal(example.test_bitfield(Example.FLAG_ONE | Example.FLAG_TWO), 3)
 
-	# Test variant iterator.
-	assert_equal(example.test_variant_iterator([10, 20, 30]), [15, 25, 35])
-	assert_equal(example.test_variant_iterator(null), "iter_init: not valid")
-
 	# RPCs.
 	assert_equal(example.return_last_rpc_arg(), 0)
 	example.test_rpc(42)
@@ -246,22 +179,10 @@ func _ready():
 	assert_equal(new_example_ref.was_post_initialized(), true)
 	assert_equal(example.test_post_initialize(), true)
 
-	# Test that we can access an engine singleton.
-	assert_equal(example.test_use_engine_singleton(), OS.get_name())
-
 	# Test that notifications happen on both parent and child classes.
 	var example_child = $ExampleChild
 	assert_equal(example_child.get_value1(), 11)
 	assert_equal(example_child.get_value2(), 33)
-	example_child.notification(NOTIFICATION_ENTER_TREE, true)
-	assert_equal(example_child.get_value1(), 11)
-	assert_equal(example_child.get_value2(), 22)
-
-	# Test that the extension's library path is absolute and valid.
-	var library_path = Example.test_library_path()
-	assert_equal(library_path.begins_with("res://"), false)
-	assert_equal(library_path, ProjectSettings.globalize_path(library_path))
-	assert_equal(FileAccess.file_exists(library_path), true)
 
 	exit_with_status()
 

test/project/project.godot

@@ -12,7 +12,7 @@ config_version=5
 
 config/name="GDExtension Test Project"
 run/main_scene="res://main.tscn"
-config/features=PackedStringArray("4.2")
+config/features=PackedStringArray("4.1")
 config/icon="res://icon.png"
 
 [native_extensions]
@@ -21,5 +21,4 @@ paths=["res://example.gdextension"]
 
 [rendering]
 
-textures/vram_compression/import_etc2_astc=true
 environment/defaults/default_environment="res://default_env.tres"

test/src/example.cpp

@@ -11,51 +11,10 @@
 #include <godot_cpp/classes/label.hpp>
 #include <godot_cpp/classes/multiplayer_api.hpp>
 #include <godot_cpp/classes/multiplayer_peer.hpp>
-#include <godot_cpp/classes/os.hpp>
 #include <godot_cpp/variant/utility_functions.hpp>
 
 using namespace godot;
 
-class MyCallableCustom : public CallableCustom {
-public:
-	virtual uint32_t hash() const {
-		return 27;
-	}
-
-	virtual String get_as_text() const {
-		return "<MyCallableCustom>";
-	}
-
-	static bool compare_equal_func(const CallableCustom *p_a, const CallableCustom *p_b) {
-		return p_a == p_b;
-	}
-
-	virtual CompareEqualFunc get_compare_equal_func() const {
-		return &MyCallableCustom::compare_equal_func;
-	}
-
-	static bool compare_less_func(const CallableCustom *p_a, const CallableCustom *p_b) {
-		return (void *)p_a < (void *)p_b;
-	}
-
-	virtual CompareLessFunc get_compare_less_func() const {
-		return &MyCallableCustom::compare_less_func;
-	}
-
-	bool is_valid() const {
-		return true;
-	}
-
-	virtual ObjectID get_object() const {
-		return ObjectID();
-	}
-
-	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, GDExtensionCallError &r_call_error) const {
-		r_return_value = "Hi";
-		r_call_error.error = GDEXTENSION_CALL_OK;
-	}
-};
-
 void ExampleRef::set_id(int p_id) {
 	id = p_id;
 }
@@ -166,14 +125,6 @@ bool Example::_property_get_revert(const StringName &p_name, Variant &r_property
 	}
 };
 
-void Example::_validate_property(PropertyInfo &p_property) const {
-	String name = p_property.name;
-	// Test hiding the "mouse_filter" property from the editor.
-	if (name == "mouse_filter") {
-		p_property.usage = PROPERTY_USAGE_NO_EDITOR;
-	}
-}
-
 void Example::_bind_methods() {
 	// Methods.
 	ClassDB::bind_method(D_METHOD("simple_func"), &Example::simple_func);
@@ -196,7 +147,6 @@ void Example::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("test_string_ops"), &Example::test_string_ops);
 	ClassDB::bind_method(D_METHOD("test_str_utility"), &Example::test_str_utility);
 	ClassDB::bind_method(D_METHOD("test_string_is_forty_two"), &Example::test_string_is_forty_two);
-	ClassDB::bind_method(D_METHOD("test_string_resize"), &Example::test_string_resize);
 	ClassDB::bind_method(D_METHOD("test_typed_array_of_packed"), &Example::test_typed_array_of_packed);
 	ClassDB::bind_method(D_METHOD("test_vector_ops"), &Example::test_vector_ops);
 	ClassDB::bind_method(D_METHOD("test_vector_init_list"), &Example::test_vector_init_list);
@@ -214,32 +164,18 @@ void Example::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("test_variant_call", "variant"), &Example::test_variant_call);
 
-	ClassDB::bind_method(D_METHOD("test_callable_mp"), &Example::test_callable_mp);
-	ClassDB::bind_method(D_METHOD("test_callable_mp_ret"), &Example::test_callable_mp_ret);
-	ClassDB::bind_method(D_METHOD("test_callable_mp_retc"), &Example::test_callable_mp_retc);
-	ClassDB::bind_method(D_METHOD("test_callable_mp_static"), &Example::test_callable_mp_static);
-	ClassDB::bind_method(D_METHOD("test_callable_mp_static_ret"), &Example::test_callable_mp_static_ret);
-	ClassDB::bind_method(D_METHOD("test_custom_callable"), &Example::test_custom_callable);
-
 	ClassDB::bind_method(D_METHOD("test_bitfield", "flags"), &Example::test_bitfield);
 
-	ClassDB::bind_method(D_METHOD("test_variant_iterator", "input"), &Example::test_variant_iterator);
-
 	ClassDB::bind_method(D_METHOD("test_rpc", "value"), &Example::test_rpc);
 	ClassDB::bind_method(D_METHOD("test_send_rpc", "value"), &Example::test_send_rpc);
 	ClassDB::bind_method(D_METHOD("return_last_rpc_arg"), &Example::return_last_rpc_arg);
 
 	ClassDB::bind_method(D_METHOD("def_args", "a", "b"), &Example::def_args, DEFVAL(100), DEFVAL(200));
-	ClassDB::bind_method(D_METHOD("callable_bind"), &Example::callable_bind);
 	ClassDB::bind_method(D_METHOD("test_post_initialize"), &Example::test_post_initialize);
 
-	ClassDB::bind_method(D_METHOD("test_use_engine_singleton"), &Example::test_use_engine_singleton);
-
 	ClassDB::bind_static_method("Example", D_METHOD("test_static", "a", "b"), &Example::test_static);
 	ClassDB::bind_static_method("Example", D_METHOD("test_static2"), &Example::test_static2);
 
-	ClassDB::bind_static_method("Example", D_METHOD("test_library_path"), &Example::test_library_path);
-
 	{
 		MethodInfo mi;
 		mi.arguments.push_back(PropertyInfo(Variant::STRING, "some_argument"));
@@ -392,16 +328,6 @@ bool Example::test_string_is_forty_two(const String &p_string) const {
 	return strcmp(p_string.utf8().ptr(), "forty two") == 0;
 }
 
-String Example::test_string_resize(String p_string) const {
-	int orig_len = p_string.length();
-	p_string.resize(orig_len + 3);
-	char32_t *data = p_string.ptrw();
-	data[orig_len + 0] = '!';
-	data[orig_len + 1] = '?';
-	data[orig_len + 2] = '\0';
-	return p_string;
-}
-
 TypedArray<PackedInt32Array> Example::test_typed_array_of_packed() const {
 	TypedArray<PackedInt32Array> arr;
 	PackedInt32Array packed_arr1;
@@ -437,68 +363,6 @@ int Example::test_vector_init_list() const {
 	return ret;
 }
 
-Callable Example::test_callable_mp() {
-	return callable_mp(this, &Example::unbound_method1);
-}
-
-Callable Example::test_callable_mp_ret() {
-	return callable_mp(this, &Example::unbound_method2);
-}
-
-Callable Example::test_callable_mp_retc() const {
-	return callable_mp(this, &Example::unbound_method3);
-}
-
-Callable Example::test_callable_mp_static() const {
-	return callable_mp_static(&Example::unbound_static_method1);
-}
-
-Callable Example::test_callable_mp_static_ret() const {
-	return callable_mp_static(&Example::unbound_static_method2);
-}
-
-Callable Example::test_custom_callable() const {
-	return Callable(memnew(MyCallableCustom));
-}
-
-void Example::unbound_method1(Object *p_object, String p_string, int p_int) {
-	String test = "unbound_method1: ";
-	test += p_object->get_class();
-	test += " - " + p_string;
-	emit_custom_signal(test, p_int);
-}
-
-String Example::unbound_method2(Object *p_object, String p_string, int p_int) {
-	String test = "unbound_method2: ";
-	test += p_object->get_class();
-	test += " - " + p_string;
-	test += " - " + itos(p_int);
-	return test;
-}
-
-String Example::unbound_method3(Object *p_object, String p_string, int p_int) const {
-	String test = "unbound_method3: ";
-	test += p_object->get_class();
-	test += " - " + p_string;
-	test += " - " + itos(p_int);
-	return test;
-}
-
-void Example::unbound_static_method1(Example *p_object, String p_string, int p_int) {
-	String test = "unbound_static_method1: ";
-	test += p_object->get_class();
-	test += " - " + p_string;
-	p_object->emit_custom_signal(test, p_int);
-}
-
-String Example::unbound_static_method2(Object *p_object, String p_string, int p_int) {
-	String test = "unbound_static_method2: ";
-	test += p_object->get_class();
-	test += " - " + p_string;
-	test += " - " + itos(p_int);
-	return test;
-}
-
 int Example::test_tarray_arg(const TypedArray<int64_t> &p_array) {
 	int sum = 0;
 	for (int i = 0; i < p_array.size(); i++) {
@@ -570,41 +434,6 @@ BitField<Example::Flags> Example::test_bitfield(BitField<Flags> flags) {
 	return flags;
 }
 
-Variant Example::test_variant_iterator(const Variant &p_input) {
-	Array output;
-
-	Variant iter;
-
-	bool is_init_valid = true;
-	if (!p_input.iter_init(iter, is_init_valid)) {
-		if (!is_init_valid) {
-			return "iter_init: not valid";
-		}
-		return output;
-	}
-
-	bool is_iter_next_valid = true;
-	bool is_iter_get_valid = true;
-	do {
-		if (!is_iter_next_valid) {
-			return "iter_next: not valid";
-		}
-
-		Variant value = p_input.iter_get(iter, is_iter_get_valid);
-		if (!is_iter_get_valid) {
-			return "iter_get: not valid";
-		}
-		output.push_back(((int)value) + 5);
-
-	} while (p_input.iter_next(iter, is_iter_next_valid));
-
-	if (!is_iter_next_valid) {
-		return "iter_next: not valid";
-	}
-
-	return output;
-}
-
 void Example::test_rpc(int p_value) {
 	last_rpc_arg = p_value;
 }
@@ -617,11 +446,6 @@ int Example::return_last_rpc_arg() {
 	return last_rpc_arg;
 }
 
-void Example::callable_bind() {
-	Callable c = Callable(this, "emit_custom_signal").bind("bound", 11);
-	c.call();
-}
-
 // Properties.
 void Example::set_custom_position(const Vector2 &pos) {
 	custom_position = pos;
@@ -673,13 +497,3 @@ void ExampleChild::_notification(int p_what) {
 		value2 = 33;
 	}
 }
-
-String Example::test_use_engine_singleton() const {
-	return OS::get_singleton()->get_name();
-}
-
-String Example::test_library_path() {
-	String library_path;
-	internal::gdextension_interface_get_library_path(internal::library, library_path._native_ptr());
-	return library_path;
-}

test/src/example.h

@@ -71,7 +71,6 @@ protected:
 	void _get_property_list(List<PropertyInfo> *p_list) const;
 	bool _property_can_revert(const StringName &p_name) const;
 	bool _property_get_revert(const StringName &p_name, Variant &r_property) const;
-	void _validate_property(PropertyInfo &p_property) const;
 
 	String _to_string() const;
 
@@ -127,7 +126,6 @@ public:
 	String test_string_ops() const;
 	String test_str_utility() const;
 	bool test_string_is_forty_two(const String &p_str) const;
-	String test_string_resize(String p_original) const;
 	TypedArray<PackedInt32Array> test_typed_array_of_packed() const;
 	int test_vector_ops() const;
 	int test_vector_init_list() const;
@@ -145,30 +143,13 @@ public:
 
 	Variant test_variant_call(Variant p_variant);
 
-	Callable test_callable_mp();
-	Callable test_callable_mp_ret();
-	Callable test_callable_mp_retc() const;
-	Callable test_callable_mp_static() const;
-	Callable test_callable_mp_static_ret() const;
-	Callable test_custom_callable() const;
-
-	void unbound_method1(Object *p_object, String p_string, int p_int);
-	String unbound_method2(Object *p_object, String p_string, int p_int);
-	String unbound_method3(Object *p_object, String p_string, int p_int) const;
-	static void unbound_static_method1(Example *p_object, String p_string, int p_int);
-	static String unbound_static_method2(Object *p_object, String p_string, int p_int);
-
 	BitField<Flags> test_bitfield(BitField<Flags> flags);
 
-	Variant test_variant_iterator(const Variant &p_input);
-
 	// RPC
 	void test_rpc(int p_value);
 	void test_send_rpc(int p_value);
 	int return_last_rpc_arg();
 
-	void callable_bind();
-
 	// Property.
 	void set_custom_position(const Vector2 &pos);
 	Vector2 get_custom_position() const;
@@ -183,10 +164,6 @@ public:
 	// Virtual function override (no need to bind manually).
 	virtual bool _has_point(const Vector2 &point) const override;
 	virtual void _input(const Ref<InputEvent> &event) override;
-
-	String test_use_engine_singleton() const;
-
-	static String test_library_path();
 };
 
 VARIANT_ENUM_CAST(Example::Constants);
@@ -204,22 +181,11 @@ protected:
 	static void _bind_methods() {}
 };
 
-class ExampleAbstractBase : public Object {
-	GDCLASS(ExampleAbstractBase, Object);
+class ExampleAbstract : public Object {
+	GDCLASS(ExampleAbstract, Object);
 
 protected:
 	static void _bind_methods() {}
-
-	virtual int test_function() = 0;
-};
-
-class ExampleConcrete : public ExampleAbstractBase {
-	GDCLASS(ExampleConcrete, ExampleAbstractBase);
-
-protected:
-	static void _bind_methods() {}
-
-	virtual int test_function() override { return 25; }
 };
 
 class ExampleBase : public Node {

test/src/register_types.cpp

@@ -25,8 +25,7 @@ void initialize_example_module(ModuleInitializationLevel p_level) {
 	GDREGISTER_CLASS(ExampleMin);
 	GDREGISTER_CLASS(Example);
 	GDREGISTER_VIRTUAL_CLASS(ExampleVirtual);
-	GDREGISTER_ABSTRACT_CLASS(ExampleAbstractBase);
-	GDREGISTER_CLASS(ExampleConcrete);
+	GDREGISTER_ABSTRACT_CLASS(ExampleAbstract);
 	GDREGISTER_CLASS(ExampleBase);
 	GDREGISTER_CLASS(ExampleChild);
 }

tools/android.py

@@ -120,9 +120,4 @@ def generate(env):
 
     env.Append(CPPDEFINES=["ANDROID_ENABLED", "UNIX_ENABLED"])
 
-    # Refer to https://github.com/godotengine/godot/blob/master/platform/android/detect.py
-    # LTO benefits for Android (size, performance) haven't been clearly established yet.
-    if env["lto"] == "auto":
-        env["lto"] = "none"
-
     common_compiler_flags.generate(env)

tools/common_compiler_flags.py

@@ -22,10 +22,6 @@ def exists(env):
 
 
 def generate(env):
-    assert env["lto"] in ["thin", "full", "none"], "Unrecognized lto: {}".format(env["lto"])
-    if env["lto"] != "none":
-        print("Using LTO: " + env["lto"])
-
     # Require C++17
     if env.get("is_msvc", False):
         env.Append(CXXFLAGS=["/std:c++17"])
@@ -68,22 +64,6 @@ def generate(env):
             env.Append(LINKFLAGS=["/OPT:REF"])
         elif env["optimize"] == "debug" or env["optimize"] == "none":
             env.Append(CCFLAGS=["/Od"])
-
-        if env["lto"] == "thin":
-            if not env["use_llvm"]:
-                print("ThinLTO is only compatible with LLVM, use `use_llvm=yes` or `lto=full`.")
-                env.Exit(255)
-
-            env.Append(CCFLAGS=["-flto=thin"])
-            env.Append(LINKFLAGS=["-flto=thin"])
-        elif env["lto"] == "full":
-            if env["use_llvm"]:
-                env.Append(CCFLAGS=["-flto"])
-                env.Append(LINKFLAGS=["-flto"])
-            else:
-                env.AppendUnique(CCFLAGS=["/GL"])
-                env.AppendUnique(ARFLAGS=["/LTCG"])
-                env.AppendUnique(LINKFLAGS=["/LTCG"])
     else:
         if env["debug_symbols"]:
             # Adding dwarf-4 explicitly makes stacktraces work with clang builds,
@@ -94,7 +74,7 @@ def generate(env):
             else:
                 env.Append(CCFLAGS=["-g2"])
         else:
-            if using_clang(env) and not is_vanilla_clang(env) and not env["use_mingw"]:
+            if using_clang(env) and not is_vanilla_clang(env):
                 # Apple Clang, its linker doesn't like -s.
                 env.Append(LINKFLAGS=["-Wl,-S", "-Wl,-x", "-Wl,-dead_strip"])
             else:
@@ -111,13 +91,3 @@ def generate(env):
             env.Append(CCFLAGS=["-Og"])
         elif env["optimize"] == "none":
             env.Append(CCFLAGS=["-O0"])
-
-        if env["lto"] == "thin":
-            if (env["platform"] == "windows" or env["platform"] == "linux") and not env["use_llvm"]:
-                print("ThinLTO is only compatible with LLVM, use `use_llvm=yes` or `lto=full`.")
-                env.Exit(255)
-            env.Append(CCFLAGS=["-flto=thin"])
-            env.Append(LINKFLAGS=["-flto=thin"])
-        elif env["lto"] == "full":
-            env.Append(CCFLAGS=["-flto"])
-            env.Append(LINKFLAGS=["-flto"])

tools/godotcpp.py

@@ -10,8 +10,7 @@ from SCons.Tool import Tool
 from SCons.Variables import BoolVariable, EnumVariable, PathVariable
 from SCons.Variables.BoolVariable import _text2bool
 
-from binding_generator import _generate_bindings, _get_file_list, get_file_list
-from build_profile import generate_trimmed_api
+from binding_generator import scons_emit_files, scons_generate_bindings
 
 
 def add_sources(sources, dir, extension):
@@ -130,37 +129,6 @@ def no_verbose(env):
     env.Append(GENCOMSTR=[generated_file_message])
 
 
-def scons_emit_files(target, source, env):
-    profile_filepath = env.get("build_profile", "")
-    if profile_filepath:
-        profile_filepath = normalize_path(profile_filepath, env)
-
-    # Always clean all files
-    env.Clean(target, [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)])
-
-    api = generate_trimmed_api(str(source[0]), profile_filepath)
-    files = [env.File(f) for f in _get_file_list(api, target[0].abspath, True, True)]
-    env["godot_cpp_gen_dir"] = target[0].abspath
-    return files, source
-
-
-def scons_generate_bindings(target, source, env):
-    profile_filepath = env.get("build_profile", "")
-    if profile_filepath:
-        profile_filepath = normalize_path(profile_filepath, env)
-
-    api = generate_trimmed_api(str(source[0]), profile_filepath)
-
-    _generate_bindings(
-        api,
-        env["generate_template_get_node"],
-        "32" if "32" in env["arch"] else "64",
-        env["precision"],
-        env["godot_cpp_gen_dir"],
-    )
-    return None
-
-
 platforms = ["linux", "macos", "windows", "android", "ios", "web"]
 
 # CPU architecture options.
@@ -329,15 +297,9 @@ def options(opts, env):
 
     opts.Add(
         BoolVariable(
-            key="use_hot_reload",
-            help="Enable the extra accounting required to support hot reload.",
-            default=env.get("use_hot_reload", None),
-        )
-    )
-
-    opts.Add(
-        BoolVariable(
-            "disable_exceptions", "Force disabling exception handling code", default=env.get("disable_exceptions", True)
+            "disable_exceptions",
+            "Force disabling exception handling code",
+            default=env.get("disable_exceptions", False),
         )
     )
 
@@ -358,14 +320,6 @@ def options(opts, env):
             ("none", "custom", "debug", "speed", "speed_trace", "size"),
         )
     )
-    opts.Add(
-        EnumVariable(
-            "lto",
-            "Link-time optimization",
-            "none",
-            ("none", "auto", "thin", "full"),
-        )
-    )
     opts.Add(BoolVariable("debug_symbols", "Build with debugging symbols", True))
     opts.Add(BoolVariable("dev_build", "Developer build with dev-only debugging code (DEV_ENABLED)", False))
     opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False))
@@ -423,7 +377,6 @@ def generate(env):
     print("Building for architecture " + env["arch"] + " on platform " + env["platform"])
 
     # These defaults may be needed by platform tools
-    env.use_hot_reload = env.get("use_hot_reload", env["target"] != "template_release")
     env.editor_build = env["target"] == "editor"
     env.dev_build = env["dev_build"]
     env.debug_features = env["target"] in ["editor", "template_debug"]
@@ -448,9 +401,6 @@ def generate(env):
     if env["threads"]:
         env.Append(CPPDEFINES=["THREADS_ENABLED"])
 
-    if env.use_hot_reload:
-        env.Append(CPPDEFINES=["HOT_RELOAD_ENABLED"])
-
     if env.editor_build:
         env.Append(CPPDEFINES=["TOOLS_ENABLED"])
 
@@ -546,7 +496,6 @@ def _godot_cpp(env):
 
     if env["build_library"]:
         library = env.StaticLibrary(target=env.File("bin/%s" % library_name), source=sources)
-        env.NoCache(library)
         default_args = [library]
 
         # Add compiledb if the option is set

tools/ios.py

@@ -13,7 +13,7 @@ def has_ios_osxcross():
 
 def options(opts):
     opts.Add(BoolVariable("ios_simulator", "Target iOS Simulator", False))
-    opts.Add("ios_min_version", "Target minimum iphoneos/iphonesimulator version", "12.0")
+    opts.Add("ios_min_version", "Target minimum iphoneos/iphonesimulator version", "10.0")
     opts.Add(
         "IOS_TOOLCHAIN_PATH",
         "Path to iOS toolchain",
@@ -97,9 +97,4 @@ def generate(env):
 
     env.Append(CPPDEFINES=["IOS_ENABLED", "UNIX_ENABLED"])
 
-    # Refer to https://github.com/godotengine/godot/blob/master/platform/ios/detect.py:
-    # Disable by default as it makes linking in Xcode very slow.
-    if env["lto"] == "auto":
-        env["lto"] = "none"
-
     common_compiler_flags.generate(env)

tools/linux.py

@@ -15,9 +15,6 @@ def generate(env):
     if env["use_llvm"]:
         clang.generate(env)
         clangxx.generate(env)
-    elif env.use_hot_reload:
-        # Required for extensions to truly unload.
-        env.Append(CXXFLAGS=["-fno-gnu-unique"])
 
     env.Append(CCFLAGS=["-fPIC", "-Wwrite-strings"])
     env.Append(LINKFLAGS=["-Wl,-R,'$$ORIGIN'"])
@@ -39,8 +36,4 @@ def generate(env):
 
     env.Append(CPPDEFINES=["LINUX_ENABLED", "UNIX_ENABLED"])
 
-    # Refer to https://github.com/godotengine/godot/blob/master/platform/linuxbsd/detect.py
-    if env["lto"] == "auto":
-        env["lto"] = "full"
-
     common_compiler_flags.generate(env)

tools/macos.py

@@ -73,9 +73,4 @@ def generate(env):
 
     env.Append(CPPDEFINES=["MACOS_ENABLED", "UNIX_ENABLED"])
 
-    # Refer to https://github.com/godotengine/godot/blob/master/platform/macos/detect.py
-    # LTO benefits for macOS (size, performance) haven't been clearly established yet.
-    if env["lto"] == "auto":
-        env["lto"] = "none"
-
     common_compiler_flags.generate(env)

tools/web.py

@@ -48,8 +48,4 @@ def generate(env):
 
     env.Append(CPPDEFINES=["WEB_ENABLED", "UNIX_ENABLED"])
 
-    # Refer to https://github.com/godotengine/godot/blob/master/platform/web/detect.py
-    if env["lto"] == "auto":
-        env["lto"] = "full"
-
     common_compiler_flags.generate(env)

tools/windows.py

@@ -1,4 +1,3 @@
-import os
 import sys
 
 import common_compiler_flags
@@ -73,13 +72,10 @@ def silence_msvc(env):
 
 
 def options(opts):
-    mingw = os.getenv("MINGW_PREFIX", "")
-
     opts.Add(BoolVariable("use_mingw", "Use the MinGW compiler instead of MSVC - only effective on Windows", False))
+    opts.Add(BoolVariable("use_clang_cl", "Use the clang driver instead of MSVC - only effective on Windows", False))
     opts.Add(BoolVariable("use_static_cpp", "Link MinGW/MSVC C++ runtime libraries statically", True))
     opts.Add(BoolVariable("silence_msvc", "Silence MSVC's cl/link stdout bloat, redirecting errors to stderr.", True))
-    opts.Add(BoolVariable("use_llvm", "Use the LLVM compiler (MVSC or MinGW depending on the use_mingw flag)", False))
-    opts.Add("mingw_prefix", "MinGW prefix", mingw)
 
 
 def exists(env):
@@ -90,22 +86,12 @@ def generate(env):
     if not env["use_mingw"] and msvc.exists(env):
         if env["arch"] == "x86_64":
             env["TARGET_ARCH"] = "amd64"
-        elif env["arch"] == "arm64":
-            env["TARGET_ARCH"] = "arm64"
-        elif env["arch"] == "arm32":
-            env["TARGET_ARCH"] = "arm"
         elif env["arch"] == "x86_32":
             env["TARGET_ARCH"] = "x86"
-
-        env["MSVC_SETUP_RUN"] = False  # Need to set this to re-run the tool
-        env["MSVS_VERSION"] = None
-        env["MSVC_VERSION"] = None
-
         env["is_msvc"] = True
 
         # MSVC, linker, and archiver.
         msvc.generate(env)
-        env.Tool("msvc")
         env.Tool("mslib")
         env.Tool("mslink")
 
@@ -113,7 +99,7 @@ def generate(env):
         env.Append(CCFLAGS=["/utf-8"])
         env.Append(LINKFLAGS=["/WX"])
 
-        if env["use_llvm"]:
+        if env["use_clang_cl"]:
             env["CC"] = "clang-cl"
             env["CXX"] = "clang-cl"
 
@@ -125,7 +111,7 @@ def generate(env):
         if env["silence_msvc"] and not env.GetOption("clean"):
             silence_msvc(env)
 
-    elif (sys.platform == "win32" or sys.platform == "msys") and not env["mingw_prefix"]:
+    elif sys.platform == "win32" or sys.platform == "msys":
         env["use_mingw"] = True
         mingw.generate(env)
         # Don't want lib prefixes
@@ -151,32 +137,12 @@ def generate(env):
     else:
         env["use_mingw"] = True
         # Cross-compilation using MinGW
-        prefix = ""
-        if env["mingw_prefix"]:
-            prefix = env["mingw_prefix"] + "/bin/"
-
-        if env["arch"] == "x86_64":
-            prefix += "x86_64"
-        elif env["arch"] == "arm64":
-            prefix += "aarch64"
-        elif env["arch"] == "arm32":
-            prefix += "armv7"
-        elif env["arch"] == "x86_32":
-            prefix += "i686"
-
-        if env["use_llvm"]:
-            env["CXX"] = prefix + "-w64-mingw32-clang++"
-            env["CC"] = prefix + "-w64-mingw32-clang"
-            env["AR"] = prefix + "-w64-mingw32-llvm-ar"
-            env["RANLIB"] = prefix + "-w64-mingw32-ranlib"
-            env["LINK"] = prefix + "-w64-mingw32-clang"
-        else:
-            env["CXX"] = prefix + "-w64-mingw32-g++"
-            env["CC"] = prefix + "-w64-mingw32-gcc"
-            env["AR"] = prefix + "-w64-mingw32-gcc-ar"
-            env["RANLIB"] = prefix + "-w64-mingw32-ranlib"
-            env["LINK"] = prefix + "-w64-mingw32-g++"
-
+        prefix = "i686" if env["arch"] == "x86_32" else env["arch"]
+        env["CXX"] = prefix + "-w64-mingw32-g++"
+        env["CC"] = prefix + "-w64-mingw32-gcc"
+        env["AR"] = prefix + "-w64-mingw32-ar"
+        env["RANLIB"] = prefix + "-w64-mingw32-ranlib"
+        env["LINK"] = prefix + "-w64-mingw32-g++"
         # Want dll suffix
         env["SHLIBSUFFIX"] = ".dll"
 
@@ -190,20 +156,7 @@ def generate(env):
                     "-static-libstdc++",
                 ]
             )
-        if env["use_llvm"]:
-            env.Append(LINKFLAGS=["-lstdc++"])
-
-        if sys.platform == "win32" or sys.platform == "msys":
-            my_spawn.configure(env)
 
     env.Append(CPPDEFINES=["WINDOWS_ENABLED"])
 
-    # Refer to https://github.com/godotengine/godot/blob/master/platform/windows/detect.py
-    if env["lto"] == "auto":
-        if env.get("is_msvc", False):
-            # No LTO by default for MSVC, doesn't help.
-            env["lto"] = "none"
-        else:  # Release
-            env["lto"] = "full"
-
     common_compiler_flags.generate(env)