Merge pull request #175 from Faless/fix/mbedtls_install_dir

mbedTLS: Fix install dir on Linux
2026-01-01 05:48:15 +03:00 · 2025-05-28 18:42:01 +02:00 · 2025-05-28 18:35:26 +02:00 · 2025-05-21 20:59:16 +02:00 · 2025-05-21 17:04:58 +02:00 · 2025-05-21 16:32:00 +02:00
32 changed files with 1109 additions and 512 deletions
--- a/.github/actions/godot-cache/action.yml
+++ b/.github/actions/godot-cache/action.yml
@@ -0,0 +1,22 @@
+name: Setup Godot build cache
+description: Setup Godot build cache.
+inputs:
+  cache-name:
+    description: The cache base name (job name by default).
+    default: "${{github.job}}"
+  scons-cache:
+    description: The scons cache path.
+    default: "${{github.workspace}}/.scons-cache/"
+runs:
+  using: "composite"
+  steps:
+    # Upload cache on completion and check it out now
+    - name: Load .scons_cache directory
+      uses: actions/cache@v4
+      with:
+        path: ${{inputs.scons-cache}}
+        key: ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
+        restore-keys: |
+          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
+          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}
+          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}
--- a/.github/workflows/build_release.yml
+++ b/.github/workflows/build_release.yml
@@ -4,14 +4,16 @@ on: [push, pull_request]
 env:
  # Only used for the cache key. Increment version to force clean build.
  GODOT_BASE_BRANCH: master
+  # Hardcoding this seem to be the only way
+  ANDROID_NDK_ROOT: /usr/local/lib/android/sdk/ndk/23.2.8568313/

 jobs:
  static-checks:
    name: 📊 Static Checks (clang-format, black format, file format)
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
@@ -50,13 +52,13 @@ jobs:
            arch: 'x86_64'
            gdnative_flags: 'android_arch=x86_64'
            sconsflags: ''
-            os: 'ubuntu-20.04'
+            os: 'ubuntu-22.04'
            cache-name: android-x86_64
          - platform: android
            arch: 'arm64'
            gdnative_flags: 'android_arch=arm64v8'
            sconsflags: ''
-            os: 'ubuntu-20.04'
+            os: 'ubuntu-22.04'
            cache-name: android-arm64

          # iOS
@@ -64,37 +66,51 @@ jobs:
            arch: 'x86_64'
            gdnative_flags: 'ios_arch=x86_64'
            sconsflags: 'ios_simulator=true'
-            os: 'macos-11'
+            os: 'macos-latest'
            cache-name: ios-x86_64-simulator
          - platform: ios
            arch: 'arm64'
            gdnative_flags: 'ios_arch=arm64'
            sconsflags: ''
-            os: 'macos-11'
+            os: 'macos-latest'
            cache-name: ios-arm64

          # Linux
          - platform: linux
            arch: 'x86_32'
-            buildroot: 'i686'
+            buildroot: 'i686-godot-linux-gnu_sdk-buildroot'
            gdnative_flags: 'bits=32'
            sconsflags: ''
-            os: 'ubuntu-20.04'
+            os: 'ubuntu-22.04'
            cache-name: linux-x86_32
          - platform: linux
            arch: 'x86_64'
-            buildroot: 'x86_64'
+            buildroot: 'x86_64-godot-linux-gnu_sdk-buildroot'
            gdnative_flags: 'bits=64'
            sconsflags: ''
-            os: 'ubuntu-20.04'
+            os: 'ubuntu-22.04'
            cache-name: linux-x86_64
+          - platform: linux
+            arch: 'arm32'
+            buildroot: 'arm-godot-linux-gnueabihf_sdk-buildroot'
+            gdnative_flags: 'bits=32'
+            sconsflags: ''
+            os: 'ubuntu-22.04'
+            cache-name: linux-arm32
+          - platform: linux
+            arch: 'arm64'
+            buildroot: 'aarch64-godot-linux-gnu_sdk-buildroot'
+            gdnative_flags: 'bits=64'
+            sconsflags: ''
+            os: 'ubuntu-22.04'
+            cache-name: linux-arm64

          # macOS
          - platform: macos
            arch: 'universal'
            gdnative_flags: 'macos_arch=universal bits=64'
            sconsflags: ''
-            os: 'macos-11'
+            os: 'macos-latest'
            cache-name: macos-universal

          # Windows
@@ -102,32 +118,32 @@ jobs:
            arch: 'x86_32'
            gdnative_flags: 'bits=32'
            sconsflags: 'use_mingw=yes'
-            os: 'ubuntu-20.04'
+            os: 'ubuntu-22.04'
            msvc_arch: amd64_x86
            cache-name: win-x86_32
          - platform: windows
            arch: 'x86_64'
            gdnative_flags: 'bits=64'
            sconsflags: 'use_mingw=yes'
-            os: 'ubuntu-20.04'
+            os: 'ubuntu-22.04'
            msvc_arch: amd64
            cache-name: win-x86_64

    env:
      SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
-      SCONSFLAGS: ${{ matrix.sconsflags }} platform=${{ matrix.platform }} arch=${{ matrix.arch }} --jobs=2
+      SCONSFLAGS: ${{ matrix.sconsflags }} platform=${{ matrix.platform }} arch=${{ matrix.arch }} build_profile=build_profile.json --jobs=2

    defaults:
      run:
        shell: bash

    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Setup Godot build cache
-        uses: ./godot-cpp/.github/actions/godot-cache
+        uses: ./.github/actions/godot-cache
        with:
          cache-name: ${{ matrix.cache-name }}
        continue-on-error: true
@@ -144,28 +160,22 @@ jobs:
          dpkg -l | grep ii | grep mingw
          update-alternatives --get-selections | grep mingw

-      - name: Setup Linux buildroot toolchain cache
-        if: ${{ matrix.platform == 'linux' }}
-        uses: actions/cache@v3
-        with:
-          path: |
-            ${{ matrix.buildroot }}-godot-linux-gnu_sdk-buildroot.tar.bz2
-          key: linux-${{ matrix.buildroot }}-buildroot
-
      - name: Install Linux build dependencies
        if: ${{ matrix.platform == 'linux' }}
        run: |
          sudo apt-get update
          sudo apt-get install build-essential gcc-multilib g++-multilib wget
-          if [ ! -f ${{ matrix.buildroot }}-godot-linux-gnu_sdk-buildroot.tar.bz2 ]; then
-            wget https://downloads.tuxfamily.org/godotengine/toolchains/linux/${{ matrix.buildroot }}-godot-linux-gnu_sdk-buildroot.tar.bz2
-          fi
-          tar -xjf ${{ matrix.buildroot }}-godot-linux-gnu_sdk-buildroot.tar.bz2
-          echo "$GITHUB_WORKSPACE/${{ matrix.buildroot }}-godot-linux-gnu_sdk-buildroot/bin" >> $GITHUB_PATH
-          patch -p1 < misc/patches/scons_path.diff
+
+      - name: Setup Linux buildroot toolchain cache
+        if: ${{ matrix.platform == 'linux' }}
+        uses: actions/cache@v4
+        with:
+          path: |
+            ${{ matrix.buildroot }}.tar.bz2
+          key: linux-${{ matrix.buildroot }}-buildroot

      - name: Set up Python 3.x
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
        with:
          python-version: '3.x'
          architecture: 'x64'
@@ -174,31 +184,52 @@ jobs:
        run: |
          python -c "import sys; print(sys.version)"
          python -m pip install scons
+
+      - name: Setup Linux toolchains
+        if: ${{ matrix.platform == 'linux' }}
+        run: |
+          if [ ! -f ${{ matrix.buildroot }}.tar.bz2 ]; then
+            wget https://github.com/godotengine/buildroot/releases/download/godot-2023.08.x-4/${{ matrix.buildroot }}.tar.bz2
+          fi
+          tar -xjf ${{ matrix.buildroot }}.tar.bz2
+          ${{ matrix.buildroot }}/relocate-sdk.sh
+          rm ${{ matrix.buildroot }}/bin/cmake
+          echo "$GITHUB_WORKSPACE/${{ matrix.buildroot }}/bin" >> $GITHUB_PATH
+          echo "PKG_CONFIG=$GITHUB_WORKSPACE/${{ matrix.buildroot }}/share/pkgconfig/" >> $GITHUB_ENV
+          patch -p1 < misc/patches/scons_path.diff
+          patch -p1 < misc/patches/gdnantive_arm_warnings.diff
+
+      - name: Setup Android dependencies
+        if: ${{ matrix.platform  == 'android' }}
+        uses: nttld/setup-ndk@v1
+        with:
+          ndk-version: r23c
+          link-to-sdk: true
+
+      - name: Patch godot-cpp to support build profile.
+        run: |
+          patch -p1 < misc/patches/build_profile.diff
+          patch -p1 < misc/patches/build_profile_3.x.diff
+
+      - name: Print tools versions
+        run: |
          python --version
          scons --version
          cmake --version

      - name: Compile Extension (4.1+) - template_debug - ${{ matrix.platform }} - ${{ matrix.arch }}
        run: |
-          scons target=template_debug godot_version=4.1
+          scons target=template_debug godot_version=4

      - name: Compile Extension (4.1+) - template_release - ${{ matrix.platform }} - ${{ matrix.arch }}
        run: |
-          scons target=template_release godot_version=4.1
-
-      - name: Compile Extension (4.0) - template_debug - ${{ matrix.platform }} - ${{ matrix.arch }}
-        run: |
-          scons target=template_debug godot_version=4.0
-
-      - name: Compile Extension (4.0) - template_release - ${{ matrix.platform }} - ${{ matrix.arch }}
-        run: |
-          scons target=template_release godot_version=4.0
+          scons target=template_release godot_version=4

      - name: Compile GDNative (3.5+) - release ${{ matrix.platform }} - ${{ matrix.arch }}
        run: |
          scons target=release generate_bindings=yes ${{ matrix.gdnative_flags }} godot_version=3

-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
        with:
          name: ${{ github.job }}-${{ matrix.platform }}-${{ matrix.arch }}
          path: |
@@ -210,11 +241,11 @@ jobs:
    needs: build
    runs-on: "ubuntu-latest"
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
        with:
          submodules: recursive

-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
        with:
          path: artifacts

@@ -222,11 +253,10 @@ jobs:
        run: |
          cp LICENSE artifacts/LICENSE.webrtc-native
          cp thirdparty/libdatachannel/LICENSE artifacts/LICENSE.libdatachannel
-          cp thirdparty/openssl/LICENSE.txt artifacts/LICENSE.openssl
+          cp thirdparty/mbedtls/LICENSE artifacts/LICENSE.mbedtls
          cp thirdparty/libdatachannel/deps/libjuice/LICENSE artifacts/LICENSE.libjuice
          cp thirdparty/libdatachannel/deps/usrsctp/LICENSE.md artifacts/LICENSE.usrsctp
          cp thirdparty/libdatachannel/deps/libsrtp/LICENSE artifacts/LICENSE.libsrtp
-          cp thirdparty/libdatachannel/deps/json/LICENSE.MIT artifacts/LICENSE.json
          cp thirdparty/libdatachannel/deps/plog/LICENSE artifacts/LICENSE.plog

      - name: Package artifacts for release
@@ -235,23 +265,17 @@ jobs:
        run: |
          mkdir release

-          VERSION="extension-4.1" TYPE="webrtc" ./misc/scripts/package_release.sh
-          VERSION="extension-4.0" TYPE="webrtc" ./misc/scripts/package_release.sh
+          VERSION="extension" TYPE="webrtc" ./misc/scripts/package_release.sh
          VERSION="gdnative" TYPE="webrtc" ./misc/scripts/package_release.sh

          ls -R release

-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
        with:
-          name: godot-webrtc-extension-4.1
-          path: release/*-extension-4.1-*.zip
+          name: godot-webrtc-extension
+          path: release/*-extension-*.zip

-      - uses: actions/upload-artifact@v3
-        with:
-          name: godot-webrtc-extension-4.0
-          path: release/*-extension-4.0-*.zip
-
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
        with:
          name: godot-webrtc-gdnative
          path: release/*-gdnative-*.zip
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,15 +1,12 @@
 [submodule "godot-cpp"]
 	path = godot-cpp
 	url = https://github.com/godotengine/godot-cpp.git
-[submodule "godot-cpp-4.0"]
-	path = godot-cpp-4.0
-	url = https://github.com/godotengine/godot-cpp.git
 [submodule "godot-cpp-3.x"]
 	path = godot-cpp-3.x
 	url = https://github.com/godotengine/godot-cpp.git
 [submodule "libdatachannel"]
 	path = thirdparty/libdatachannel
 	url = https://github.com/paullouisageneau/libdatachannel.git
-[submodule "openssl"]
-	path = thirdparty/openssl
-	url = https://github.com/openssl/openssl.git
+[submodule "mbedtls"]
+	path = thirdparty/mbedtls
+	url = https://github.com/Mbed-TLS/mbedtls.git
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@

 ### Compiling

-Clone this repository with the following command to checkout all the dependencies: [godot-cpp](https://github.com/godotengine/godot-cpp), [openssl](https://www.openssl.org/) and [libdatachannel](https://github.com/paullouisageneau/libdatachannel) (and sub-dependencies).
+Clone this repository with the following command to checkout all the dependencies: [godot-cpp](https://github.com/godotengine/godot-cpp), [mbedTLS](https://github.com/Mbed-TLS/mbedtls) and [libdatachannel](https://github.com/paullouisageneau/libdatachannel) (and sub-dependencies).

 ```
 $ git clone --recurse-submodules https://github.com/godotengine/webrtc-native.git
--- a/133
+++ b/133
@@ -12,41 +12,63 @@ def add_sources(sources, dirpath, extension):

 def replace_flags(flags, replaces):
    for k, v in replaces.items():
-        if k in flags:
+        if k not in flags:
+            continue
+        if v is None:
+            flags.remove(k)
+        else:
            flags[flags.index(k)] = v


+def validate_godotcpp_dir(key, val, env):
+    normalized = val if os.path.isabs(val) else os.path.join(env.Dir("#").abspath, val)
+    if not os.path.isdir(normalized):
+        raise UserError("GDExtension directory ('%s') does not exist: %s" % (key, val))
+
+
 env = Environment()
 opts = Variables(["customs.py"], ARGUMENTS)
-opts.Add(EnumVariable("godot_version", "The Godot target version", "4.1", ["3", "4.0", "4.1"]))
+opts.Add(EnumVariable("godot_version", "The Godot target version", "4", ["3", "4"], {"4.1+": "4", "4.1": "4"}))
+opts.Add(
+    PathVariable(
+        "godot_cpp",
+        "Path to the directory containing Godot CPP folder",
+        None,
+        validate_godotcpp_dir,
+    )
+)
 opts.Update(env)

 # Minimum target platform versions.
 if "ios_min_version" not in ARGUMENTS:
-    ARGUMENTS["ios_min_version"] = "11.0"
+    ARGUMENTS["ios_min_version"] = "12.0"
 if "macos_deployment_target" not in ARGUMENTS:
    ARGUMENTS["macos_deployment_target"] = "11.0"
 if "android_api_level" not in ARGUMENTS:
    ARGUMENTS["android_api_level"] = "28"

+# Recent godot-cpp versions disables exceptions by default, but libdatachannel requires them.
+ARGUMENTS["disable_exceptions"] = "no"
+
 if env["godot_version"] == "3":
    if "platform" in ARGUMENTS and ARGUMENTS["platform"] == "macos":
        ARGUMENTS["platform"] = "osx"  # compatibility with old osx name

-    env = SConscript("godot-cpp-3.x/SConstruct")
+    sconstruct = env.get("godot_cpp", "godot-cpp-3.x") + "/SConstruct"
+    cpp_env = SConscript(sconstruct)

    # Patch base env
    replace_flags(
-        env["CCFLAGS"],
+        cpp_env["CCFLAGS"],
        {
-            "-mios-simulator-version-min=10.0": "-mios-simulator-version-min=11.0",
-            "-miphoneos-version-min=10.0": "-miphoneos-version-min=11.0",
+            "-mios-simulator-version-min=10.0": "-mios-simulator-version-min=12.0",
+            "-miphoneos-version-min=10.0": "-miphoneos-version-min=12.0",
            "/std:c++14": "/std:c++17",
            "-std=c++14": "-std=c++17",
        },
    )

-    env = env.Clone()
+    env = cpp_env.Clone()

    if env["target"] == "debug":
        env.Append(CPPDEFINES=["DEBUG_ENABLED"])
@@ -60,11 +82,11 @@ if env["godot_version"] == "3":
        env["CC"] = "clang"  # CC is not set in 3.x and can result in it being "gcc".

    if env["platform"] == "ios":
-        env["ios_min_version"] = "11.0"
+        env["ios_min_version"] = "12.0"

    # Normalize suffix
    if env["platform"] in ["windows", "linux"]:
-        env["arch"] = "x86_32" if env["bits"] == "32" else "x86_64"
+        env["arch"] = ARGUMENTS.get("arch", "x86_32" if env["bits"] == "32" else "x86_64")
        env["arch_suffix"] = env["arch"]
    elif env["platform"] == "macos":
        env["arch"] = env["macos_arch"]
@@ -96,10 +118,25 @@ if env["godot_version"] == "3":
        elif not env["use_mingw"]:
            # Mark as MSVC build (would have failed to build the library otherwise).
            env["is_msvc"] = True
-elif env["godot_version"] == "4.0":
-    env = SConscript("godot-cpp-4.0/SConstruct").Clone()
+    # Some linux specific hacks to allow cross-compiling for non-x86 machines.
+    if env["platform"] == "linux" and env["arch"] not in ("x86_32", "x86_64"):
+        for flags in (env["CCFLAGS"], env["LINKFLAGS"], cpp_env["CCFLAGS"], cpp_env["LINKFLAGS"]):
+            replace_flags(flags, {"-m32": None, "-m64": None})
 else:
-    env = SConscript("godot-cpp/SConstruct").Clone()
+    sconstruct = env.get("godot_cpp", "godot-cpp") + "/SConstruct"
+    cpp_env = SConscript(sconstruct)
+    env = cpp_env.Clone()
+
+if cpp_env.get("is_msvc", False):
+    # Make sure we don't build with static cpp on MSVC (default in recent godot-cpp versions).
+    replace_flags(env["CCFLAGS"], {"/MT": "/MD"})
+    replace_flags(cpp_env["CCFLAGS"], {"/MT": "/MD"})
+
+if env["platform"] == "ios":
+    if env["ios_simulator"]:
+        env.AppendUnique(LINKFLAGS=["-mios-simulator-version-min=" + ARGUMENTS["ios_min_version"]])
+    else:
+        env.AppendUnique(LINKFLAGS=["-miphoneos-version-min=" + ARGUMENTS["ios_min_version"]])

 # Should probably go to upstream godot-cpp.
 # We let SCons build its default ENV as it includes OS-specific things which we don't
@@ -120,27 +157,13 @@ if env["platform"] == "macos" and os.environ.get("OSXCROSS_ROOT", ""):
    if env["macos_deployment_target"] != "default":
        env["ENV"]["MACOSX_DEPLOYMENT_TARGET"] = env["macos_deployment_target"]

-# Patch linux flags to statically link libgcc and libstdc++
-if env["platform"] == "linux":
-    env.Append(
-        LINKFLAGS=[
-            "-Wl,--no-undefined",
-            "-static-libgcc",
-            "-static-libstdc++",
-        ]
-    )
-    # And add some linux dependencies.
-    env.Append(LIBS=["pthread", "dl"])
-
 opts.Update(env)

 target = env["target"]
 if env["godot_version"] == "3":
    result_path = os.path.join("bin", "gdnative", "webrtc" if env["target"] == "release" else "webrtc_debug")
-elif env["godot_version"] == "4.0":
-    result_path = os.path.join("bin", "extension-4.0", "webrtc")
 else:
-    result_path = os.path.join("bin", "extension-4.1", "webrtc")
+    result_path = os.path.join("bin", "extension", "webrtc")

 # Our includes and sources
 env.Append(CPPPATH=["src/"])
@@ -158,26 +181,60 @@ if env["godot_version"] == "3":
    add_sources(sources, "src/net/", "cpp")
 else:
    sources.append("src/init_gdextension.cpp")
-    if env["godot_version"] == "4.0":
-        env.Append(CPPDEFINES=["GDEXTENSION_WEBRTC_40"])

 # Add our build tools
-for tool in ["openssl", "cmake", "rtc"]:
+for tool in ["cmake", "mbedtls", "rtc"]:
    env.Tool(tool, toolpath=["tools"])

-ssl = env.OpenSSL()
+# Make sure Substfile is also loaded
+env.Tool("textfile")

-rtc = env.BuildLibDataChannel(ssl)
+mbedtls = env.BuildMbedTLS()
+
+rtc = env.BuildLibDataChannel(mbedtls)

 # Forces building our sources after OpenSSL and libdatachannel.
 # This is because OpenSSL headers are generated by their build system and SCons doesn't know about them.
 # Note: This might not be necessary in this specific case since our sources doesn't include OpenSSL headers directly,
 # but it's better to be safe in case of indirect inclusions by one of our other dependencies.
-env.Depends(sources, ssl + rtc)
+env.Depends(sources, rtc + mbedtls)
+
+# We want to statically link against libstdc++ on Linux to maximize compatibility, but we must restrict the exported
+# symbols using a GCC version script, or we might end up overriding symbols from other libraries.
+# Using "-fvisibility=hidden" will not work, since libstdc++ explicitly exports its symbols.
+symbols_file = None
+if env["platform"] == "linux" or (
+    env["platform"] == "windows" and env.get("use_mingw", False) and not env.get("use_llvm", False)
+):
+    if env["godot_version"] == "3":
+        symbols_file = env.File("misc/gcc/symbols-gdnative.map")
+    else:
+        symbols_file = env.File("misc/gcc/symbols-extension.map")
+    env.Append(
+        LINKFLAGS=[
+            "-Wl,--no-undefined,--version-script=" + symbols_file.abspath,
+            "-static-libgcc",
+            "-static-libstdc++",
+        ]
+    )
+    env.Depends(sources, symbols_file)

 # Make the shared library
 result_name = "libwebrtc_native{}{}".format(env["suffix"], env["SHLIBSUFFIX"])
-library = env.SharedLibrary(target=os.path.join(result_path, "lib", result_name), source=sources)
+if env["godot_version"] != "3" and env["platform"] == "macos":
+    framework_path = os.path.join(
+        result_path, "lib", "libwebrtc_native.macos.{}.{}.framework".format(env["target"], env["arch"])
+    )
+    library_file = env.SharedLibrary(target=os.path.join(framework_path, result_name), source=sources)
+    plist_file = env.Substfile(
+        os.path.join(framework_path, "Resources", "Info.plist"),
+        "misc/dist/macos/Info.plist",
+        SUBST_DICT={"{LIBRARY_NAME}": result_name, "{DISPLAY_NAME}": "libwebrtc_native" + env["suffix"]},
+    )
+    library = [library_file, plist_file]
+else:
+    library = env.SharedLibrary(target=os.path.join(result_path, "lib", result_name), source=sources)
+
 Default(library)

 # GDNativeLibrary
@@ -193,10 +250,6 @@ if env["godot_version"] == "3":
        },
    )
 else:
-    extfile = env.Substfile(
-        os.path.join(result_path, "webrtc.gdextension"),
-        "misc/webrtc.gdextension",
-        SUBST_DICT={"{GODOT_VERSION}": env["godot_version"]},
-    )
+    extfile = env.InstallAs(os.path.join(result_path, "webrtc.gdextension"), "misc/webrtc.gdextension")

 Default(extfile)
--- a/build_profile.json
+++ b/build_profile.json
@@ -0,0 +1,11 @@
+{
+	"enabled_classes": [
+		"WebRTCDataChannelExtension",
+		"WebRTCPeerConnectionExtension",
+		"WebRTCDataChannelGDNative",
+		"WebRTCPeerConnectionGDNative",
+		"NativeScript",
+		"GDNativeLibrary",
+		"Window"
+	]
+}
--- a/2
+++ b/2
--- a/godot-cpp-4.0
+++ b/godot-cpp-4.0
--- a/misc/dist/macos/Info.plist
+++ b/misc/dist/macos/Info.plist
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleExecutable</key>
+	<string>{LIBRARY_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>org.godotengine.webrtc-native</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleDisplayName</key>
+	<string>{DISPLAY_NAME}</string>
+	<key>CFBundleName</key>
+	<string>webrtc_native</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0.0</string>
+	<key>CFBundleSupportedPlatforms</key>
+	<array>
+		<string>MacOSX</string>
+	</array>
+	<key>CFBundleVersion</key>
+	<string>1.0.0</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>11.0</string>
+</dict>
+</plist>
--- a/misc/gcc/symbols-extension.map
+++ b/misc/gcc/symbols-extension.map
@@ -0,0 +1,6 @@
+{
+    global:
+        webrtc_extension_init;
+    local:
+        *;
+};
--- a/misc/gcc/symbols-gdnative.map
+++ b/misc/gcc/symbols-gdnative.map
@@ -0,0 +1,9 @@
+{
+    global:
+        godot_gdnative_singleton;
+        godot_gdnative_init;
+        godot_gdnative_terminate;
+        godot_nativescript_init;
+    local:
+        *;
+};
--- a/misc/patches/build_profile.diff
+++ b/misc/patches/build_profile.diff
@@ -0,0 +1,297 @@
+diff --git a/godot-cpp/binding_generator.py b/godot-cpp/binding_generator.py
+index 18db9fd..e0c8caf 100644
+--- a/godot-cpp/binding_generator.py
+++ b/godot-cpp/binding_generator.py
+@@ -72,9 +72,13 @@ def generate_wrappers(target):
+ 
+ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+     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 = []
+ 
+     core_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp" / "core"
+     include_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp"
+@@ -158,13 +162,15 @@ def scons_generate_bindings(target, source, env):
+     return None
+ 
+ 
+-def generate_bindings(api_filepath, use_template_get_node, bits="64", precision="single", output_dir="."):
+-    api = None
+-
+-    target_dir = Path(output_dir) / "gen"
+-
+def _generate_bindings(api_filepath, use_template_get_node, bits="64", precision="single", output_dir="."):
+    api = {}
+     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)
+diff --git a/godot-cpp/build_profile.py b/godot-cpp/build_profile.py
+new file mode 100644
+index 0000000..b4d19de
+--- /dev/null
+++ b/godot-cpp/build_profile.py
+@@ -0,0 +1,183 @@
+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)
+diff --git a/godot-cpp/tools/godotcpp.py b/godot-cpp/tools/godotcpp.py
+index efe632a..993aa81 100644
+--- a/godot-cpp/tools/godotcpp.py
+++ b/godot-cpp/tools/godotcpp.py
+@@ -5,7 +5,8 @@ from SCons.Tool import Tool
+ from SCons.Builder import Builder
+ from SCons.Errors import UserError
+ 
+-from binding_generator import scons_generate_bindings, scons_emit_files
+from binding_generator import _generate_bindings, _get_file_list, get_file_list
+from build_profile import generate_trimmed_api
+ 
+ 
+ def add_sources(sources, dir, extension):
+@@ -14,6 +15,37 @@ def add_sources(sources, dir, extension):
+             sources.append(dir + "/" + f)
+ 
+ 
+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
+
+
+ def normalize_path(val, env):
+     return val if os.path.isabs(val) else os.path.join(env.Dir("#").abspath, val)
+ 
+@@ -175,6 +207,15 @@ def options(opts, env):
+         )
+     )
+ 
+    opts.Add(
+        PathVariable(
+            "build_profile",
+            "Path to a file containing a feature build profile",
+            default=env.get("build_profile", None),
+            validator=validate_file,
+        )
+    )
+
+     opts.Add(
+         BoolVariable(
+             "disable_exceptions",
--- a/misc/patches/build_profile_3.x.diff
+++ b/misc/patches/build_profile_3.x.diff
@@ -0,0 +1,286 @@
+diff --git a/godot-cpp-3.x/SConstruct b/godot-cpp-3.x/SConstruct
+index f653d54..483f190 100644
+--- a/godot-cpp-3.x/SConstruct
+++ b/godot-cpp-3.x/SConstruct
+@@ -3,7 +3,42 @@
+ import os
+ import sys
+ import subprocess
+-from binding_generator import scons_generate_bindings, scons_emit_files
+from binding_generator import _generate_bindings, _get_file_list, get_file_list
+from build_profile import generate_trimmed_api
+
+
+def normalize_path(val):
+    return val if os.path.isabs(val) else os.path.join(env.Dir("#").abspath, val)
+
+
+def scons_emit_files(target, source, env):
+    profile_filepath = env.get("build_profile", "")
+    if profile_filepath:
+        profile_filepath = normalize_path(profile_filepath)
+
+    # 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)
+
+    api = generate_trimmed_api(str(source[0]), profile_filepath)
+
+    _generate_bindings(
+        api,
+        env["generate_template_get_node"],
+        env["godot_cpp_gen_dir"],
+    )
+    return None
+
+ 
+ if sys.version_info < (3,):
+ 
+@@ -170,6 +205,14 @@ opts.Add(
+         True,
+     )
+ )
+opts.Add(
+    PathVariable(
+        "build_profile",
+        "Path to a file containing a feature build profile",
+        default=env.get("build_profile", None),
+        validator=lambda key, val, env: os.path.isfile(normalize_path(val)),
+    )
+)
+ 
+ opts.Add(BoolVariable("build_library", "Build the godot-cpp library.", True))
+ 
+diff --git a/godot-cpp-3.x/binding_generator.py b/godot-cpp-3.x/binding_generator.py
+index da4bb61..1348a51 100644
+--- a/godot-cpp-3.x/binding_generator.py
+++ b/godot-cpp-3.x/binding_generator.py
+@@ -16,10 +16,16 @@ classes = []
+ 
+ 
+ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+-    global classes
+-    files = []
+    api = {}
+     with open(api_filepath) as api_file:
+         classes = json.load(api_file)
+    return _get_file_list(classes, output_dir, headers, sources)
+
+
+def _get_file_list(api, output_dir, headers=False, sources=False):
+    global classes
+    classes = api
+    files = []
+     include_gen_folder = Path(output_dir) / "include" / "gen"
+     source_gen_folder = Path(output_dir) / "src" / "gen"
+     for _class in classes:
+@@ -58,9 +64,15 @@ def scons_generate_bindings(target, source, env):
+ 
+ 
+ def generate_bindings(api_filepath, use_template_get_node, output_dir="."):
+-    global classes
+    classes = {}
+     with open(api_filepath) as api_file:
+         classes = json.load(api_file)
+    _generate_bindings(classes, use_template_get_node, output_dir)
+
+
+def _generate_bindings(api, use_template_get_node, output_dir="."):
+    global classes
+    classes = api
+ 
+     icalls = set()
+     include_gen_folder = Path(output_dir) / "include" / "gen"
+diff --git a/godot-cpp-3.x/build_profile.py b/godot-cpp-3.x/build_profile.py
+new file mode 100644
+index 0000000..5518f64
+--- /dev/null
+++ b/godot-cpp-3.x/build_profile.py
+@@ -0,0 +1,177 @@
+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:
+        api_dict[engine_class["name"]] = engine_class
+        parent = engine_class.get("base_class", "")
+        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:
+        engine_classes[class_api["name"]] = class_api["is_reference"]
+
+    classes = []
+    for class_api in api:
+        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)
+    return classes
+
+
+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_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)
--- a/misc/patches/gdnantive_arm_warnings.diff
+++ b/misc/patches/gdnantive_arm_warnings.diff
@@ -0,0 +1,34 @@
+diff --git a/godot-cpp-3.x/godot-headers/gdnative/gdnative.h b/godot-cpp-3.x/godot-headers/gdnative/gdnative.h
+index c0573d21b5d7a..ec95c4c4ebfcc 100644
+--- a/godot-cpp-3.x/godot-headers/gdnative/gdnative.h
+++ b/godot-cpp-3.x/godot-headers/gdnative/gdnative.h
+@@ -37,20 +37,24 @@ extern "C" {
+ 
+ #if defined(_WIN32) || defined(__ANDROID__)
+ #define GDCALLINGCONV
+-#define GDAPI GDCALLINGCONV
+
+ #elif defined(__APPLE__)
+ #include "TargetConditionals.h"
+ #if TARGET_OS_IPHONE
+ #define GDCALLINGCONV __attribute__((visibility("default")))
+-#define GDAPI GDCALLINGCONV
+ #elif TARGET_OS_MAC
+ #define GDCALLINGCONV __attribute__((sysv_abi))
+-#define GDAPI GDCALLINGCONV
+ #endif
+-#else // !_WIN32 && !__APPLE__
+
+#else // Linux/BSD/Web
+#if defined(__aarch64__) || defined(__arm__)
+#define GDCALLINGCONV
+#else
+ #define GDCALLINGCONV __attribute__((sysv_abi))
+-#define GDAPI GDCALLINGCONV
+ #endif
+#endif
+
+#define GDAPI GDCALLINGCONV
+ 
+ // This is for libraries *using* the header, NOT GODOT EXPOSING STUFF!!
+ #if !defined(GDN_EXPORT)
--- a/misc/patches/scons_path.diff
+++ b/misc/patches/scons_path.diff
@@ -1,17 +1,3 @@
-diff --git a/godot-cpp-4.0/SConstruct b/godot-cpp-4.0/SConstruct
-index 27ee137..32b425e 100644
--- a/godot-cpp-4.0/SConstruct
-+++ b/godot-cpp-4.0/SConstruct
-@@ -54,6 +54,8 @@ else:
- # Default tools with no platform defaults to gnu toolchain.
- # We apply platform specific toolchains via our custom tools.
- env = Environment(tools=["default"], PLATFORM="")
-+# Allows us to use Godot buildroot toolchain
-+env.PrependENVPath("PATH", os.getenv("PATH"))
-
- # Default num_jobs to local cpu count if not user specified.
- # SCons has a peculiarity where user-specified options won't be overridden
-
 diff --git a/godot-cpp-3.x/SConstruct b/godot-cpp-3.x/SConstruct
 index f653d54..6f40377 100644
 --- a/godot-cpp-3.x/SConstruct
--- a/misc/scripts/file_format.sh
+++ b/misc/scripts/file_format.sh
@@ -39,6 +39,8 @@ for f in "${files[@]}"; do
        continue
    elif [[ "$f" == "thirdparty/"* ]]; then
        continue
+    elif [[ "$f" == "misc/patches/"* ]]; then
+        continue
    elif [[ "$f" == *"/thirdparty/"* ]]; then
        continue
    elif [[ "$f" == "platform/android/java/lib/src/com/google"* ]]; then
--- a/misc/scripts/package_release.sh
+++ b/misc/scripts/package_release.sh
@@ -16,7 +16,7 @@ DESTDIR="${DESTINATION}/${VERSION}/${TYPE}"

 mkdir -p ${DESTDIR}/lib

-find "${ARTIFACTS}" -wholename "*/${VERSION}/${TYPE}/lib/*" | xargs cp -t "${DESTDIR}/lib/"
+find "${ARTIFACTS}" -maxdepth 5 -wholename "*/${VERSION}/${TYPE}/lib/*" | xargs cp -r -t "${DESTDIR}/lib/"
 find "${ARTIFACTS}" -wholename "*/LICENSE*" | xargs cp -t "${DESTDIR}/"

 if [ $VERSION = "gdnative" ]; then
--- a/misc/webrtc.gdextension
+++ b/misc/webrtc.gdextension
@@ -1,30 +1,30 @@
 [configuration]

 entry_symbol = "webrtc_extension_init"
-compatibility_minimum = {GODOT_VERSION}
+compatibility_minimum = 4.1

 [libraries]

-linux.debug.x86_64 = "res://webrtc/lib/libwebrtc_native.linux.template_debug.x86_64.so"
-linux.debug.x86_32 = "res://webrtc/lib/libwebrtc_native.linux.template_debug.x86_32.so"
-linux.debug.arm64 = "res://webrtc/lib/libwebrtc_native.linux.template_debug.arm64.so"
-linux.debug.arm32 = "res://webrtc/lib/libwebrtc_native.linux.template_debug.arm32.so"
-macos.debug = "res://webrtc/lib/libwebrtc_native.macos.template_debug.universal.dylib"
-windows.debug.x86_64 = "res://webrtc/lib/libwebrtc_native.windows.template_debug.x86_64.dll"
-windows.debug.x86_32 = "res://webrtc/lib/libwebrtc_native.windows.template_debug.x86_32.dll"
-android.debug.arm64 = "res://webrtc/lib/libwebrtc_native.android.template_debug.arm64.so"
-android.debug.x86_64 = "res://webrtc/lib/libwebrtc_native.android.template_debug.x86_64.so"
-ios.debug.arm64 = "res://webrtc/lib/libwebrtc_native.ios.template_debug.arm64.dylib"
-ios.debug.x86_64 = "res://webrtc/lib/libwebrtc_native.ios.template_debug.x86_64.simulator.dylib"
+linux.debug.x86_64 = "lib/libwebrtc_native.linux.template_debug.x86_64.so"
+linux.debug.x86_32 = "lib/libwebrtc_native.linux.template_debug.x86_32.so"
+linux.debug.arm64 = "lib/libwebrtc_native.linux.template_debug.arm64.so"
+linux.debug.arm32 = "lib/libwebrtc_native.linux.template_debug.arm32.so"
+macos.debug = "lib/libwebrtc_native.macos.template_debug.universal.framework"
+windows.debug.x86_64 = "lib/libwebrtc_native.windows.template_debug.x86_64.dll"
+windows.debug.x86_32 = "lib/libwebrtc_native.windows.template_debug.x86_32.dll"
+android.debug.arm64 = "lib/libwebrtc_native.android.template_debug.arm64.so"
+android.debug.x86_64 = "lib/libwebrtc_native.android.template_debug.x86_64.so"
+ios.debug.arm64 = "lib/libwebrtc_native.ios.template_debug.arm64.dylib"
+ios.debug.x86_64 = "lib/libwebrtc_native.ios.template_debug.x86_64.simulator.dylib"

-linux.release.x86_64 = "res://webrtc/lib/libwebrtc_native.linux.template_release.x86_64.so"
-linux.release.x86_32 = "res://webrtc/lib/libwebrtc_native.linux.template_release.x86_32.so"
-linux.release.arm64 = "res://webrtc/lib/libwebrtc_native.linux.template_release.arm64.so"
-linux.release.arm32 = "res://webrtc/lib/libwebrtc_native.linux.template_release.arm32.so"
-macos.release = "res://webrtc/lib/libwebrtc_native.macos.template_release.universal.dylib"
-windows.release.x86_64 = "res://webrtc/lib/libwebrtc_native.windows.template_release.x86_64.dll"
-windows.release.x86_32 = "res://webrtc/lib/libwebrtc_native.windows.template_release.x86_32.dll"
-android.release.arm64 = "res://webrtc/lib/libwebrtc_native.android.template_release.arm64.so"
-android.release.x86_64 = "res://webrtc/lib/libwebrtc_native.android.template_release.x86_64.so"
-ios.release.arm64 = "res://webrtc/lib/libwebrtc_native.ios.template_release.arm64.dylib"
-ios.release.x86_64 = "res://webrtc/lib/libwebrtc_native.ios.template_release.x86_64.simulator.dylib"
+linux.release.x86_64 = "lib/libwebrtc_native.linux.template_release.x86_64.so"
+linux.release.x86_32 = "lib/libwebrtc_native.linux.template_release.x86_32.so"
+linux.release.arm64 = "lib/libwebrtc_native.linux.template_release.arm64.so"
+linux.release.arm32 = "lib/libwebrtc_native.linux.template_release.arm32.so"
+macos.release = "lib/libwebrtc_native.macos.template_release.universal.framework"
+windows.release.x86_64 = "lib/libwebrtc_native.windows.template_release.x86_64.dll"
+windows.release.x86_32 = "lib/libwebrtc_native.windows.template_release.x86_32.dll"
+android.release.arm64 = "lib/libwebrtc_native.android.template_release.arm64.so"
+android.release.x86_64 = "lib/libwebrtc_native.android.template_release.x86_64.so"
+ios.release.arm64 = "lib/libwebrtc_native.ios.template_release.arm64.dylib"
+ios.release.x86_64 = "lib/libwebrtc_native.ios.template_release.x86_64.simulator.dylib"
--- a/misc/webrtc.tres
+++ b/misc/webrtc.tres
@@ -6,10 +6,14 @@ reloadable = false
 entry/OSX.64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.macos.{TARGET}.universal.dylib"
 entry/Windows.64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.windows.{TARGET}.x86_64.dll"
 entry/Windows.32 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.windows.{TARGET}.x86_32.dll"
-entry/X11.64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_64.so"
-entry/X11.32 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_32.so"
-entry/Server.64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_64.so"
-entry/Server.32 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_32.so"
+entry/X11.64.x86_64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_64.so"
+entry/X11.32.x86_32 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_32.so"
+entry/X11.64.arm64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.arm64.so"
+entry/X11.32.arm32 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.arm32.so"
+entry/Server.64.x86_64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_64.so"
+entry/Server.32.x86_32 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.x86_32.so"
+entry/Server.64.arm64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.arm64.so"
+entry/Server.32.arm32 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.linux.{TARGET}.arm32.so"
 entry/Android.arm64-v8a = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.android.{TARGET}.arm64.so"
 entry/Android.x64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.android.{TARGET}.x86_64.so"
 entry/iOS.armv7 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.ios.{TARGET}.armv32.dylib"
--- a/src/WebRTCLibDataChannel.cpp
+++ b/src/WebRTCLibDataChannel.cpp
@@ -143,12 +143,12 @@ int32_t WebRTCLibDataChannel::_get_id() const {

 int32_t WebRTCLibDataChannel::_get_max_packet_life_time() const {
 	ERR_FAIL_COND_V(!channel, 0);
-	return channel->reliability().type == rtc::Reliability::Type::Timed ? std::get<std::chrono::milliseconds>(channel->reliability().rexmit).count() : -1;
+	return channel->reliability().maxPacketLifeTime.has_value() ? channel->reliability().maxPacketLifeTime.value().count() : -1;
 }

 int32_t WebRTCLibDataChannel::_get_max_retransmits() const {
 	ERR_FAIL_COND_V(!channel, 0);
-	return channel->reliability().type == rtc::Reliability::Type::Rexmit ? std::get<int>(channel->reliability().rexmit) : -1;
+	return channel->reliability().maxRetransmits.value_or(-1);
 }

 String WebRTCLibDataChannel::_get_protocol() const {
--- a/src/WebRTCLibDataChannel.hpp
+++ b/src/WebRTCLibDataChannel.hpp
@@ -74,6 +74,10 @@ private:
 protected:
 	static void _bind_methods() {}

+	godot::String _to_string() const {
+		return "WebRTCLibDataChannel";
+	}
+
 public:
 	static WebRTCLibDataChannel *new_data_channel(std::shared_ptr<rtc::DataChannel> p_channel, bool p_negotiated);

--- a/src/WebRTCLibPeerConnection.cpp
+++ b/src/WebRTCLibPeerConnection.cpp
@@ -39,15 +39,36 @@ using namespace godot_webrtc;
 #define FAILED Error::FAILED
 #define ERR_UNCONFIGURED Error::ERR_UNCONFIGURED
 #define ERR_INVALID_PARAMETER Error::ERR_INVALID_PARAMETER
+#define VERBOSE_PRINT(str) Godot::print(str)
+#else
+#include <godot_cpp/variant/utility_functions.hpp>
+#define VERBOSE_PRINT(str) UtilityFunctions::print_verbose(str)
 #endif
+void LogCallback(rtc::LogLevel level, std::string message) {
+	switch (level) {
+		case rtc::LogLevel::Fatal:
+		case rtc::LogLevel::Error:
+			ERR_PRINT(message.c_str());
+			return;
+		case rtc::LogLevel::Warning:
+			WARN_PRINT(message.c_str());
+			return;
+		default:
+			VERBOSE_PRINT(message.c_str());
+			return;
+	}
+}

 void WebRTCLibPeerConnection::initialize_signaling() {
 #ifdef DEBUG_ENABLED
-	rtc::InitLogger(rtc::LogLevel::Debug);
+	rtc::InitLogger(rtc::LogLevel::Debug, LogCallback);
+#else
+	rtc::InitLogger(rtc::LogLevel::Warning, LogCallback);
 #endif
 }

 void WebRTCLibPeerConnection::deinitialize_signaling() {
+	rtc::Cleanup();
 }

 Error WebRTCLibPeerConnection::_parse_ice_server(rtc::Configuration &r_config, Dictionary p_server) {
@@ -95,11 +116,9 @@ Error WebRTCLibPeerConnection::_parse_channel_config(rtc::DataChannelInit &r_con
 	// Channels cannot be both time-constrained and retry-constrained.
 	ERR_FAIL_COND_V(p_dict.has("maxPacketLifeTime") && p_dict.has("maxRetransmits"), ERR_INVALID_PARAMETER);
 	if (p_dict.has("maxPacketLifeTime")) {
-		r_config.reliability.type = rtc::Reliability::Type::Timed;
-		r_config.reliability.rexmit = std::chrono::milliseconds(p_dict["maxPacketLifeTime"].operator int32_t());
+		r_config.reliability.maxPacketLifeTime = std::chrono::milliseconds(p_dict["maxPacketLifeTime"].operator int32_t());
 	} else if (p_dict.has("maxRetransmits")) {
-		r_config.reliability.type = rtc::Reliability::Type::Rexmit;
-		r_config.reliability.rexmit = p_dict["maxRetransmits"].operator int32_t();
+		r_config.reliability.maxRetransmits = p_dict["maxRetransmits"].operator int32_t();
 	}
 	if (p_dict.has("ordered") && p_dict["ordered"].operator bool() == false) {
 		r_config.reliability.unordered = true;
@@ -180,7 +199,7 @@ Error WebRTCLibPeerConnection::_initialize(const Dictionary &p_config) {
 	return _create_pc(config);
 }

-#if defined(GDNATIVE_WEBRTC) || defined(GDEXTENSION_WEBRTC_40)
+#if defined(GDNATIVE_WEBRTC)
 Object *WebRTCLibPeerConnection::_create_data_channel(const String &p_channel, const Dictionary &p_channel_config) try {
 #else
 Ref<WebRTCDataChannel> WebRTCLibPeerConnection::_create_data_channel(const String &p_channel, const Dictionary &p_channel_config) try {
--- a/src/WebRTCLibPeerConnection.hpp
+++ b/src/WebRTCLibPeerConnection.hpp
@@ -67,6 +67,10 @@ private:
 protected:
 	static void _bind_methods() {}

+	godot::String _to_string() const {
+		return "WebRTCLibPeerConnection";
+	}
+
 public:
 	static void _register_methods() {}
 	static void initialize_signaling();
@@ -79,7 +83,7 @@ public:
 	SignalingState _get_signaling_state() const override;

 	godot::Error _initialize(const godot::Dictionary &p_config) override;
-#if defined(GDNATIVE_WEBRTC) || defined(GDEXTENSION_WEBRTC_40)
+#if defined(GDNATIVE_WEBRTC)
 	godot::Object *_create_data_channel(const godot::String &p_channel, const godot::Dictionary &p_channel_config) override;
 #else
 	godot::Ref<godot::WebRTCDataChannel> _create_data_channel(const godot::String &p_channel, const godot::Dictionary &p_channel_config) override;
--- a/src/init_gdextension.cpp
+++ b/src/init_gdextension.cpp
@@ -66,11 +66,7 @@ void unregister_webrtc_extension_types(ModuleInitializationLevel p_level) {
 }

 extern "C" {
-#ifdef GDEXTENSION_WEBRTC_40
-GDExtensionBool GDE_EXPORT webrtc_extension_init(const GDExtensionInterface *p_interface, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
-#else
 GDExtensionBool GDE_EXPORT webrtc_extension_init(const GDExtensionInterfaceGetProcAddress p_interface, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
-#endif
 	GDExtensionBinding::InitObject init_obj(p_interface, p_library, r_initialization);

 	init_obj.register_initializer(register_webrtc_extension_types);
--- a/thirdparty/README.md
+++ b/thirdparty/README.md
@@ -5,21 +5,10 @@ respective folder names. Use two empty lines to separate categories for
 readability.


-## json
-
- Upstream: https://github.com/nlohmann/json
- Version: 3.10.5 (4f8fba14066156b73f1189a2b8bd568bde5284c5, 2022)
- License: MIT
-
-Module location:
-
- thirdparty/libdatachannel/deps/json
-
-
 ## libdatachannel

 - Upstream: https://github.com/paullouisageneau/libdatachannel
- Version: 0.18.6 (bf8d8bd86afaffed89ba763107bcd8957c8cc319, 2023)
+- Version: 0.22.6 (0d6adc021953d7263fd4503482ea7bde33553724, 2025)
 - License: MPL 2.0

 Module location:
@@ -30,7 +19,7 @@ Module location:
 # libjuice

 - Upstream: https://github.com/paullouisageneau/libjuice
- Version: 1.2.3 (8c23cc88c6d41e5ccbc44ea0ad3d79b22cf02361, 2023)
+- Version: 1.5.9 (8d1a99a0683a811876c03a73ff764a92774027ad, 2025)
 - License: MPL 2.0

 Module location:
@@ -49,22 +38,22 @@ Module location:
 - thirdparty/libdatachannel/deps/libsrtp


-## openssl
+## mbedTLS

- Upstream: git://git.openssl.org/openssl.git
- Version: 3.0.10 (245cb0291e0db99d9ccf3692fa76f440b2b054c2, 2023)
+- Upstream: https://github.com/Mbed-TLS/mbedtls.git
+- Version: 3.6.3 (22098d41c6620ce07cf8a0134d37302355e1e5ef, 2025)
 - License: Apache 2.0

 Module location:

- thirdparty/openssl
+- thirdparty/mbedtls


 ## plog

 - Upstream: https://github.com/SergiusTheBest/plog
- Version: git (d8461e9d473e59fbcc1f79eee021550dcf81e618, 2021)
- License: MPL 2.0
+- Version: 1.1.10 (e21baecd4753f14da64ede979c5a19302618b752, 2023)
+- License: MIT

 Module location:

@@ -74,7 +63,7 @@ Module location:
 ## usrsctp

 - Upstream: https://github.com/sctplab/usrsctp
- Version: git (7c31bd35c79ba67084ce029511193a19ceb97447, 2021)
+- Version: git (ebb18adac6501bad4501b1f6dccb67a1c85cc299, 2023)
 - License: BSD-3-Clause

 Module location:
--- a/thirdparty/libdatachannel
+++ b/thirdparty/libdatachannel
--- a/thirdparty/mbedtls
+++ b/thirdparty/mbedtls
--- a/thirdparty/openssl
+++ b/thirdparty/openssl
--- a/tools/cmake.py
+++ b/tools/cmake.py
@@ -1,13 +1,20 @@
-import os, sys
+import os
+import shlex
+import sys

-import SCons.Util
-import SCons.Builder
 import SCons.Action
+import SCons.Builder
+import SCons.Util
+
+
+# This must be kept in sync with the value in https://github.com/godotengine/godot/blob/master/platform/android/detect.py#L58.
+def get_ndk_version():
+    return "23.2.8568313"


 def cmake_default_flags(env):
    if env.get("cmake_default_flags", ""):
-        return SCons.Util.CLVar(env["cmake_default_flags"])
+        return shlex.split(env["cmake_default_flags"])

    config = {}

@@ -28,15 +35,16 @@ def cmake_default_flags(env):
        config["CMAKE_SYSTEM_VERSION"] = api
        config["CMAKE_ANDROID_ARCH_ABI"] = abi
        config["ANDROID_ABI"] = abi
-        config["CMAKE_TOOLCHAIN_FILE"] = "%s/build/cmake/android.toolchain.cmake" % env.get(
-            "ANDROID_NDK_ROOT", os.environ.get("ANDROID_NDK_ROOT", "")
-        )
+        ndk_root = os.environ.get("ANDROID_NDK_ROOT", env.get("ANDROID_HOME", "") + "/ndk/" + get_ndk_version())
+        config["CMAKE_TOOLCHAIN_FILE"] = "%s/build/cmake/android.toolchain.cmake" % ndk_root
        config["CMAKE_ANDROID_STL_TYPE"] = "c++_static"

    elif env["platform"] == "linux":
        linux_flags = {
            "x86_64": "-m64",
            "x86_32": "-m32",
+            "arm32": "-march=armv7-a",
+            "arm64": "-march=armv8-a",
        }.get(env["arch"], "")
        if linux_flags:
            config["CMAKE_C_FLAGS"] = linux_flags
@@ -47,10 +55,9 @@ def cmake_default_flags(env):
            config["CMAKE_OSX_ARCHITECTURES"] = '"x86_64;arm64"'
        else:
            config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
-        if env["macos_deployment_target"] != "default":
+        if env.get("macos_deployment_target", "default") != "default":
            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["macos_deployment_target"]
-
-        if env["platform"] == "macos" and sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
+        if sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
            config["CMAKE_AR"] = env["AR"]
            config["CMAKE_RANLIB"] = env["RANLIB"]
            if env["arch"] == "universal":
@@ -74,18 +81,17 @@ def cmake_default_flags(env):

    elif env["platform"] == "windows":
        config["CMAKE_SYSTEM_NAME"] = "Windows"
-
-    flags = ["-D%s=%s" % it for it in config.items()]
-    if env["CMAKEGENERATOR"]:
-        flags.extend(["-G", env["CMAKEGENERATOR"]])
-    elif env["platform"] == "windows":
        if env.get("is_msvc", False):
-            flags.extend(["-G", "NMake Makefiles"])
-        elif sys.platform in ["win32", "msys", "cygwin"]:
-            flags.extend(["-G", "Ninja"])
-        else:
-            flags.extend(["-G", "Unix Makefiles"])
-    return flags
+            config["CMAKE_POLICY_DEFAULT_CMP0091"] = "NEW"
+            if env.get("debug_crt", False):
+                config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreadedDebugDLL"
+            else:
+                if env.get("use_static_cpp", False):
+                    config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreaded"
+                else:
+                    config["CMAKE_MSVC_RUNTIME_LIBRARY"] = "MultiThreadedDLL"
+
+    return ["-D%s=%s" % it for it in config.items()]


 def cmake_emitter(target, source, env):
@@ -95,26 +101,63 @@ def cmake_emitter(target, source, env):
 def cmake_generator(target, source, env, for_signature):
    # Strip the -j option for signature to avoid rebuilding when num_jobs changes.
    build = env["CMAKEBUILDCOM"].replace("-j$CMAKEBUILDJOBS", "") if for_signature else env["CMAKEBUILDCOM"]
-    return [
+    actions = [
        SCons.Action.Action("$CMAKECONFCOM", "$CMAKECONFCOMSTR"),
        SCons.Action.Action(build, "$CMAKEBUILDCOMSTR"),
    ]
+    if env["CMAKE_INSTALL"]:
+        actions.append(
+            SCons.Action.Action("$CMAKEINSTALLCOM", "$CMAKEINSTALLCOMSTR"),
+        )
+    return actions


-def cmake_build(env, target_dir, source_dir, cmake_outputs=[], cmake_targets=[], cmake_options=[], dependencies=[]):
+def cmake_build(
+    env, target_dir, source_dir, cmake_outputs=[], cmake_targets=[], cmake_options=[], dependencies=[], install=False
+):
    cmake_env = env.Clone()
    target = env.Dir("{}/{}/{}".format(target_dir, env["platform"], env["arch"]))
    source = env.Dir(source_dir)
    builder_targets = [target] + [str(target) + "/" + f for f in cmake_outputs]
    builder_sources = [source] + dependencies
-    cmake_env.Append(CMAKECONFFLAGS=["-D%s=%s" % it for it in cmake_options.items()])
+    default_flags = cmake_default_flags(env)
+
+    # Merge flags
+    flags = []
+    for df in default_flags:
+        if not df.startswith("-D"):
+            flags.append(df)
+        else:
+            f = df[2:].split("=")[0]
+            if f in cmake_options:
+                df += " " + cmake_options[f]
+                cmake_options.pop(f)
+            flags.append(df)
+    for opt in cmake_options:
+        flags.append("-D%s=%s" % (opt, cmake_options[opt]))
+
+    # Select generator
+    if env["cmake_generator"]:
+        flags.extend(["-G", env["cmake_generator"]])
+    elif env["platform"] == "windows":
+        if env.get("is_msvc", False):
+            flags.extend(["-G", "NMake Makefiles"])
+        elif sys.platform in ["win32", "msys", "cygwin"]:
+            flags.extend(["-G", "Ninja"])
+        else:
+            flags.extend(["-G", "Unix Makefiles"])
+
+    cmake_env.Append(CMAKECONFFLAGS=flags)
    if len(cmake_targets) > 0:
        cmake_env.Append(CMAKEBUILDFLAGS=["-t"] + [t for t in cmake_targets])
+    cmake_env["CMAKE_INSTALL"] = install
    return cmake_env.CMake(builder_targets, builder_sources)


 def options(opts):
    opts.Add("cmake_default_flags", "Default CMake platform flags override, will be autodetected if not specified.", "")
+    opts.Add("cmake_generator", "CMake generator override, will be autodetected from platform if not specified.", "")
+    opts.Add("cmake", "CMake binary to use", "cmake")


 def exists(env):
@@ -122,14 +165,13 @@ def exists(env):


 def generate(env):
-    env["CMAKE"] = "cmake"
-    env["_cmake_default_flags"] = cmake_default_flags
-    env["CMAKEDEFAULTFLAGS"] = "${_cmake_default_flags(__env__)}"
-    env["CMAKEGENERATOR"] = ""
+    env["CMAKE"] = env["cmake"]
    env["CMAKECONFFLAGS"] = SCons.Util.CLVar("")
-    env["CMAKECONFCOM"] = "$CMAKE -B ${TARGET.dir} $CMAKEDEFAULTFLAGS $CMAKECONFFLAGS ${SOURCE.dir}"
+    env["CMAKECONFCOM"] = "$CMAKE -B ${TARGET.dir} $CMAKECONFFLAGS ${SOURCE.dir}"
    env["CMAKEBUILDJOBS"] = "${__env__.GetOption('num_jobs')}"
    env["CMAKEBUILDFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKEINSTALLFLAGS"] = SCons.Util.CLVar("")
    env["CMAKEBUILDCOM"] = "$CMAKE --build ${TARGET.dir} $CMAKEBUILDFLAGS -j$CMAKEBUILDJOBS"
+    env["CMAKEINSTALLCOM"] = "$CMAKE --install ${TARGET.dir} $CMAKEINSTALLFLAGS"
    env["BUILDERS"]["CMake"] = SCons.Builder.Builder(generator=cmake_generator, emitter=cmake_emitter)
    env.AddMethod(cmake_build, "CMakeBuild")
--- a/tools/mbedtls.py
+++ b/tools/mbedtls.py
@@ -0,0 +1,69 @@
+def build_library(env):
+    mbedtls_bin = env.Dir("bin/thirdparty/mbedtls/{}/{}/install".format(env["platform"], env["arch"]))
+    is_msvc = env.get("is_msvc", False)
+    c_flags = "-DMBEDTLS_SSL_DTLS_SRTP"
+    if env["platform"] == "linux":
+        # This is needed on some arch when building with the godot buildroot toolchain
+        c_flags += " -fPIC"
+    elif env["platform"] == "windows" and not is_msvc:
+        c_flags += " -D__USE_MINGW_ANSI_STDIO=0"  # See https://github.com/Mbed-TLS/mbedtls/issues/10161
+
+    mbedtls_config = {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo" if env["debug_symbols"] else "Release",
+        "ENABLE_TESTING": 0,
+        "ENABLE_PROGRAMS": 0,
+        "CMAKE_INSTALL_PREFIX": env.Dir(mbedtls_bin).abspath,
+        "CMAKE_INSTALL_LIBDIR": "lib",
+        "CMAKE_C_FLAGS": c_flags,
+        "MBEDTLS_FATAL_WARNINGS": 0,
+    }
+    lib_ext = ".lib" if is_msvc else ".a"
+    lib_prefix = "" if is_msvc else "lib"
+    mbedtls_libs = [
+        "/install/lib/{}mbedtls{}".format(lib_prefix, lib_ext),
+        "/install/lib/{}mbedx509{}".format(lib_prefix, lib_ext),
+        "/install/lib/{}mbedcrypto{}".format(lib_prefix, lib_ext),
+    ]
+
+    mbedtls_cmake_config = [
+        "/install/lib/cmake/MbedTLS/MbedTLSConfig.cmake",
+        "/install/lib/cmake/MbedTLS/MbedTLSConfigVersion.cmake",
+        "/install/lib/cmake/MbedTLS/MbedTLSTargets.cmake",
+    ]
+
+    # Build libdatachannel
+    mbedtls = env.CMakeBuild(
+        env.Dir("bin/thirdparty/mbedtls/"),
+        env.Dir("thirdparty/mbedtls"),
+        cmake_options=mbedtls_config,
+        cmake_outputs=mbedtls_libs + mbedtls_cmake_config,
+        install=True,
+    )
+
+    # Configure env.
+    if env["platform"] == "windows":
+        env.PrependUnique(LIBS=["bcrypt", "ws2_32", "iphlpapi"])
+    if env["platform"] == "linux":
+        env.PrependUnique(LIBS=["pthread"])
+    env.Prepend(LIBS=list(filter(lambda f: str(f).endswith(lib_ext), mbedtls)))
+    env.Append(CPPPATH=[env.Dir("thirdparty/mbedtls/include")])
+
+    return mbedtls
+
+
+def exists(env):
+    return "CMake" in env
+
+
+def generate(env):
+    mbedtls_install_dir = "bin/thirdparty/mbedtls/{}/{}/install".format(env["platform"], env["arch"])
+    lib_ext = ".lib" if env.get("is_msvc", False) else ".a"
+    mbedtls = env.File(mbedtls_install_dir + "/lib/libmbedtls" + lib_ext)
+    crypto = env.File(mbedtls_install_dir + "/lib/libmbedcrypto" + lib_ext)
+    x509 = env.File(mbedtls_install_dir + "/lib/libmbedx509" + lib_ext)
+    includes = env.Dir("thirdparty/mbedtls/include")
+    env.AddMethod(build_library, "BuildMbedTLS")
+    env["MBEDTLS_LIBRARY"] = mbedtls.abspath
+    env["MBEDTLS_CRYPTO_LIBRARY"] = crypto.abspath
+    env["MBEDTLS_X509_LIBRARY"] = x509.abspath
+    env["MBEDTLS_INCLUDE"] = includes.abspath
--- a/tools/openssl.py
+++ b/tools/openssl.py
@@ -1,286 +0,0 @@
-import os, sys
-import SCons.Util
-import SCons.Builder
-import SCons.Action
-from SCons.Defaults import Mkdir
-from SCons.Variables import PathVariable, BoolVariable
-
-
-def ssl_platform_target(env):
-    targets = {}
-    platform = env["platform"]
-    if platform == "linux":
-        targets = {
-            "x86_32": "linux-x86",
-            "x86_64": "linux-x86_64",
-            "arm64": "linux-aarch64",
-            "arm32": "linux-armv4",
-            "rv64": "linux64-riscv64",
-        }
-    elif platform == "android":
-        targets = {
-            "arm64": "android-arm64",
-            "arm32": "android-arm",
-            "x86_32": "android-x86",
-            "x86_64": "android-x86_64",
-        }
-    elif platform == "macos":
-        targets = {
-            "x86_64": "darwin64-x86_64",
-            "arm64": "darwin64-arm64",
-        }
-    elif platform == "ios":
-        if env["ios_simulator"]:
-            targets = {
-                "x86_64": "iossimulator-xcrun",
-                "arm64": "iossimulator-xcrun",
-            }
-        else:
-            targets = {
-                "arm64": "ios64-xcrun",
-                "arm32": "ios-xcrun",
-            }
-    elif platform == "windows":
-        if env.get("is_msvc", False):
-            targets = {
-                "x86_32": "VC-WIN32",
-                "x86_64": "VC-WIN64A",
-            }
-        else:
-            targets = {
-                "x86_32": "mingw",
-                "x86_64": "mingw64",
-            }
-
-    arch = env["arch"]
-    target = targets.get(arch, "")
-    if target == "":
-        raise ValueError("Architecture '%s' not supported for platform: '%s'" % (arch, platform))
-    return target
-
-
-def ssl_platform_options(env):
-    ssl_config_options = [
-        "no-ssl2",
-        "no-ssl3",
-        "no-weak-ssl-ciphers",
-        "no-legacy",
-        "no-shared",
-        "no-tests",
-    ]
-    if env["platform"] == "windows":
-        ssl_config_options.append("enable-capieng")
-    return ssl_config_options
-
-
-def ssl_platform_flags(env):
-    args = []
-    if env["platform"] == "android":
-        if env.get("android_api_level", ""):
-            api = int(env["android_api_level"])
-            args.append("-D__ANDROID_API__=%s" % api)
-    elif env["platform"] == "macos":
-        # OSXCross toolchain setup.
-        if sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
-            for k in ["CC", "CXX", "AR", "AS", "RANLIB"]:
-                args.append("%s=%s" % (k, env[k]))
-    elif env["platform"] == "windows":
-        is_win_host = sys.platform in ["win32", "msys", "cygwin"]
-        if not (is_win_host or env.get("is_msvc", False)):
-            mingw_prefixes = {
-                "x86_32": "--cross-compile-prefix=i686-w64-mingw32-",
-                "x86_64": "--cross-compile-prefix=x86_64-w64-mingw32-",
-            }
-            args.append(mingw_prefixes[env["arch"]])
-    return args
-
-
-def ssl_configure_args(env):
-    if env.get("openssl_configure_options", ""):
-        opts = SCons.Util.CLVar(env["openssl_configure_options"])
-    else:
-        opts = ssl_platform_options(env)
-
-    if env.get("openssl_configure_target", ""):
-        target = [env["openssl_configure_target"]]
-    else:
-        target = [ssl_platform_target(env)]
-
-    if env.get("openssl_configure_flags", ""):
-        flags = SCons.Util.CLVar(env["openssl_configure_flags"])
-    else:
-        flags = ssl_platform_flags(env)
-
-    return opts + target + flags
-
-
-def ssl_emitter(target, source, env):
-    return env["SSL_LIBS"], [env.File(env["SSL_SOURCE"] + "/Configure"), env.File(env["SSL_SOURCE"] + "/VERSION.dat")]
-
-
-def build_openssl(env, jobs=None):
-    if env["SSL_EXTERNAL"]:
-        # Setup the env to use the provided libraries, and return them without building.
-        env.Prepend(CPPPATH=[env["SSL_INCLUDE"]])
-        env.Prepend(LIBPATH=[env["SSL_BUILD"]])
-        if env["platform"] == "windows":
-            env.PrependUnique(LIBS=["crypt32", "ws2_32", "advapi32", "user32"])
-        env.Prepend(LIBS=env["SSL_LIBS"])
-        return [env["SSL_CRYPTO_LIBRARY"], env["SSL_LIBRARY"]]
-
-    if jobs is None:
-        jobs = int(env.GetOption("num_jobs"))
-
-    # Since the OpenSSL build system does not support macOS universal binaries, we first need to build the two libraries
-    # separately, then we join them together using lipo.
-    if env["platform"] == "macos" and env["arch"] == "universal":
-        build_envs = {
-            "x86_64": env.Clone(),
-            "arm64": env.Clone(),
-        }
-        arch_ssl = []
-        for arch in build_envs:
-            benv = build_envs[arch]
-            benv["arch"] = arch
-            generate(benv)
-            benv["SSLBUILDJOBS"] = max([1, int(jobs / len(build_envs))])
-            ssl = benv.OpenSSLBuilder()
-            arch_ssl.extend(ssl)
-            benv.NoCache(ssl)  # Needs refactoring to properly cache generated headers.
-
-        # x86_64 and arm64 includes are equivalent.
-        env["SSL_INCLUDE"] = build_envs["arm64"]["SSL_INCLUDE"]
-
-        # Join libraries using lipo.
-        lipo_action = "lipo $SOURCES -create -output $TARGET"
-        ssl_libs = list(map(lambda arch: build_envs[arch]["SSL_LIBRARY"], build_envs))
-        ssl_crypto_libs = list(map(lambda arch: build_envs[arch]["SSL_CRYPTO_LIBRARY"], build_envs))
-        ssl = env.Command(env["SSL_LIBRARY"], ssl_libs, lipo_action)
-        ssl += env.Command(env["SSL_CRYPTO_LIBRARY"], ssl_crypto_libs, lipo_action)
-        env.Depends(ssl, arch_ssl)
-    else:
-        benv = env.Clone()
-        benv["SSLBUILDJOBS"] = jobs
-        ssl = benv.OpenSSLBuilder()
-        benv.NoCache(ssl)  # Needs refactoring to properly cache generated headers.
-
-    # Setup the environment to use the freshly built openssl.
-    env.Prepend(CPPPATH=[env["SSL_INCLUDE"]])
-    env.Prepend(LIBPATH=[env["SSL_BUILD"]])
-    if env["platform"] == "windows":
-        env.PrependUnique(LIBS=["crypt32", "ws2_32", "advapi32", "user32"])
-    env.Prepend(LIBS=env["SSL_LIBS"])
-
-    return ssl
-
-
-def ssl_generator(target, source, env, for_signature):
-    # Strip the -j option for signature to avoid rebuilding when num_jobs changes.
-    build = env["SSLBUILDCOM"].replace("-j$SSLBUILDJOBS", "") if for_signature else env["SSLBUILDCOM"]
-    return [
-        Mkdir("$SSL_BUILD"),
-        Mkdir("$SSL_INSTALL"),
-        SCons.Action.Action("$SSLCONFIGCOM", "$SSLCONFIGCOMSTR"),
-        SCons.Action.Action(build, "$SSLBUILDCOMSTR"),
-    ]
-
-
-def options(opts):
-    opts.Add(PathVariable("openssl_source", "Path to the openssl sources.", "thirdparty/openssl"))
-    opts.Add("openssl_build", "Destination path of the openssl build.", "bin/thirdparty/openssl")
-    opts.Add(
-        "openssl_configure_options",
-        "OpenSSL configure options override. Will use a reasonable default if not specified.",
-        "",
-    )
-    opts.Add(
-        "openssl_configure_target", "OpenSSL configure target override, will be autodetected if not specified.", ""
-    )
-    opts.Add(
-        "openssl_configure_flags",
-        "OpenSSL configure compiler flags override. Will be autodetected if not specified.",
-        "",
-    )
-    opts.Add(
-        "openssl_external_crypto",
-        'An external libcrypto static library (e.g. "/usr/lib/x86_64-linux-gnu/libcrypto.a"). If not provided, OpenSSL will be built from source.',
-        "",
-    )
-    opts.Add(
-        "openssl_external_ssl",
-        'An external libssl static library (e.g. "/usr/lib/x86_64-linux-gnu/libssl.a"). If not provided, OpenSSL will be built from source.',
-        "",
-    )
-    opts.Add(
-        "openssl_external_include",
-        'An external OpenSSL "include" folder (e.g. "/usr/include/openssl").',
-        "",
-    )
-
-
-def exists(env):
-    return True
-
-
-def generate(env):
-    env.AddMethod(build_openssl, "OpenSSL")
-
-    # Check if the user specified infos about external OpenSSL files.
-    external_opts = ["openssl_external_crypto", "openssl_external_ssl", "openssl_external_include"]
-    is_set = lambda k: env.get(k, "") != ""
-    if any(map(is_set, external_opts)):
-        # Need provide the whole (crypto, ssl, include) triple to proceed.
-        if not all(map(is_set, external_opts)):
-            print('Error: The options "%s" must all be set to use a external library.' % '", "'.join(external_opts))
-            sys.exit(255)
-
-        env["SSL_CRYPTO_LIBRARY"] = env.File("${openssl_external_crypto}")
-        env["SSL_LIBRARY"] = env.File("${openssl_external_ssl}")
-        env["SSL_BUILD"] = env.Dir("${SSL_LIBRARY.dir}").abspath
-        env["SSL_INSTALL"] = env.Dir("${SSL_LIBRARY.dir}").abspath
-        env["SSL_INCLUDE"] = env.Dir("${openssl_external_include}").abspath
-        env["SSL_LIBS"] = [env["SSL_LIBRARY"], env["SSL_CRYPTO_LIBRARY"]]
-        env["SSL_EXTERNAL"] = True
-        return
-
-    # We will need to build our own OpenSSL library.
-    env["SSL_EXTERNAL"] = False
-
-    # Android needs the NDK in ENV, and proper PATH setup.
-    if env["platform"] == "android" and env["ENV"].get("ANDROID_NDK_ROOT", "") == "":
-        cc_path = os.path.dirname(env["CC"])
-        if cc_path and cc_path not in env["ENV"]:
-            env.PrependENVPath("PATH", cc_path)
-        if "ANDROID_NDK_ROOT" not in env["ENV"]:
-            env["ENV"]["ANDROID_NDK_ROOT"] = env.get("ANDROID_NDK_ROOT", os.environ.get("ANDROID_NDK_ROOT", ""))
-
-    env["SSL_SOURCE"] = env.Dir(env["openssl_source"]).abspath
-    env["SSL_BUILD"] = env.Dir(env["openssl_build"] + "/{}/{}".format(env["platform"], env["arch"])).abspath
-    env["SSL_INSTALL"] = env.Dir(env["SSL_BUILD"] + "/dest").abspath
-    env["SSL_INCLUDE"] = env.Dir(env["SSL_INSTALL"] + "/include").abspath
-    lib_ext = ".lib" if env.get("is_msvc", False) else ".a"
-    env["SSL_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libssl" + lib_ext)
-    env["SSL_CRYPTO_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libcrypto" + lib_ext)
-    env["SSL_LIBS"] = [env["SSL_LIBRARY"], env["SSL_CRYPTO_LIBRARY"]]
-
-    # Configure action
-    env["PERL"] = env.get("PERL", "perl")
-    env["_ssl_configure_args"] = ssl_configure_args
-    env["SSLPLATFORMCONFIG"] = "${_ssl_configure_args(__env__)}"
-    env["SSLCONFFLAGS"] = SCons.Util.CLVar("")
-    # fmt: off
-    env["SSLCONFIGCOM"] = 'cd ${TARGET.dir} && $PERL -- ${SOURCE.abspath} --prefix="${SSL_INSTALL}" --openssldir="${SSL_INSTALL}" $SSLPLATFORMCONFIG $SSLCONFFLAGS'
-    # fmt: on
-
-    # Build action
-    env["SSLBUILDJOBS"] = "${__env__.GetOption('num_jobs')}"
-    # fmt: off
-    env["SSLBUILDCOM"] = "make -j$SSLBUILDJOBS -C ${TARGET.dir} && make -j$SSLBUILDJOBS -C ${TARGET.dir} install_sw install_ssldirs"
-    # fmt: on
-
-    # Windows MSVC needs to build using NMake
-    if env["platform"] == "windows" and env.get("is_msvc", False):
-        env["SSLBUILDCOM"] = "cd ${TARGET.dir} && nmake install_sw install_ssldirs"
-
-    env["BUILDERS"]["OpenSSLBuilder"] = SCons.Builder.Builder(generator=ssl_generator, emitter=ssl_emitter)
-    env.AddMethod(build_openssl, "OpenSSL")
--- a/tools/rtc.py
+++ b/tools/rtc.py
@@ -1,19 +1,17 @@
-import os
-
-
-def build_library(env, ssl):
+def build_library(env, mbedtls):
    rtc_config = {
        "CMAKE_BUILD_TYPE": "RelWithDebInfo" if env["debug_symbols"] else "Release",
+        "CMAKE_CXX_FLAGS": "-DMBEDTLS_SSL_DTLS_SRTP",
        "USE_NICE": 0,
        "NO_WEBSOCKET": 1,
        "NO_EXAMPLES": 1,
        "NO_TESTS": 1,
        "BUILD_WITH_WARNINGS": "0",  # Disables werror in libsrtp.
-        "OPENSSL_USE_STATIC_LIBS": 1,
-        "OPENSSL_INCLUDE_DIR": env["SSL_INCLUDE"],
-        "OPENSSL_SSL_LIBRARY": env["SSL_LIBRARY"],
-        "OPENSSL_CRYPTO_LIBRARY": env["SSL_CRYPTO_LIBRARY"],
-        "OPENSSL_ROOT_DIR": env["SSL_INSTALL"],
+        "USE_MBEDTLS": 1,
+        "MbedTLS_LIBRARY": env["MBEDTLS_LIBRARY"],
+        "MbedCrypto_LIBRARY": env["MBEDTLS_CRYPTO_LIBRARY"],
+        "MbedX509_LIBRARY": env["MBEDTLS_X509_LIBRARY"],
+        "MbedTLS_INCLUDE_DIR": env["MBEDTLS_INCLUDE"],
    }
    is_msvc = env.get("is_msvc", False)
    lib_ext = ".lib" if is_msvc else ".a"
@@ -24,21 +22,25 @@ def build_library(env, ssl):
        "deps/libsrtp/{}srtp2{}".format(lib_prefix, lib_ext),
        "deps/usrsctp/usrsctplib/{}usrsctp{}".format(lib_prefix, lib_ext),
    ]
+
    # Build libdatachannel
    rtc = env.CMakeBuild(
-        "#bin/thirdparty/libdatachannel/",
-        "#thirdparty/libdatachannel",
+        env.Dir("bin/thirdparty/libdatachannel/"),
+        env.Dir("thirdparty/libdatachannel"),
        cmake_options=rtc_config,
        cmake_outputs=rtc_libs,
        cmake_targets=["datachannel-static"],
-        dependencies=ssl,
+        dependencies=mbedtls,
    )

    # Configure env.
    if env["platform"] == "windows":
-        env.PrependUnique(LIBS=["iphlpapi", "bcrypt"])
+        env.PrependUnique(LIBS=["iphlpapi", "ws2_32", "bcrypt"])
+    if env["platform"] == "linux":
+        env.PrependUnique(LIBS=["pthread"])
    env.Prepend(LIBS=list(filter(lambda f: str(f).endswith(lib_ext), rtc)))
-    env.Append(CPPPATH=["#thirdparty/libdatachannel/include"])
+    env.Append(CPPPATH=[env.Dir("thirdparty/libdatachannel/include")])
+    env.Append(CPPDEFINES=["RTC_STATIC"])  # For Windows MSVC

    return rtc
Author	SHA1	Message	Date
Fabio Alessandrelli	f3ca94ae0e	Merge pull request #175 from Faless/fix/mbedtls_install_dir mbedTLS: Fix install dir on Linux	2025-05-28 18:42:01 +02:00
Fabio Alessandrelli	40e5c0c733	mbedTLS: Fix install dir on Linux Force cmake INSTALL_LIBDIR to avoid distro discrepancies Disable werror which can cause issues with newer GCC	2025-05-28 18:35:26 +02:00
Fabio Alessandrelli	b45d3a3f46	Merge pull request #164 from Faless/feat/mbedtls [TLS] Move from OpenSSL to mbedTLS	2025-05-21 20:59:16 +02:00
Fabio Alessandrelli	41648bbf60	Merge pull request #173 from Faless/fix/ios_link_min_version fix: Add iOS min SDK version link flag	2025-05-21 17:04:58 +02:00
Fabio Alessandrelli	a77bf9bdb0	fix: Add iOS min SDK version link flag	2025-05-21 16:32:00 +02:00
Fabio Alessandrelli	b1ee39e6c4	[TLS] Move from OpenSSL to mbedTLS Update libdatachannel to 0.22.6	2025-05-15 11:24:51 +02:00
Fabio Alessandrelli	29fc1bb84d	Merge pull request #172 from Faless/fix/ci_runners [CI] Update ubuntu runners to 22.04	2025-05-14 18:35:07 +02:00
Fabio Alessandrelli	4567fb22c1	[CI] Update ubuntu runners to 22.04	2025-05-14 18:20:19 +02:00
Fabio Alessandrelli	13a934298a	Merge pull request #165 from Faless/bump/godot-cpp_4.1.3 [godot-cpp] Update versions and patches	2025-01-08 12:45:59 +01:00
Fabio Alessandrelli	68338ed576	[godot-cpp] Update versions and patches Update godot-cpp to 4.1.3 Update build profile patches to latest iteration	2025-01-08 10:51:59 +01:00
Fabio Alessandrelli	f149f97815	Merge pull request #163 from Faless/fix/compat_min_version [Build] Fix gdextension file after dropping 4.0	2025-01-07 12:35:15 +01:00
Fabio Alessandrelli	cf038b2788	[Build] Fix gdextension file after dropping 4.0 Renaming the godot version to "4" resulted in the GDExtension file incorrectly setting "compatibility_minimum = 4" (instead of "4.1")	2025-01-07 11:13:44 +01:00
Fabio Alessandrelli	1992779387	Merge pull request #157 from Faless/bump/libdatachannel_0.22.3 Update to libdatachannel 0.22.3	2024-12-04 17:50:11 +01:00
Fabio Alessandrelli	25bb44730e	Update to libdatachannel 0.22.3	2024-12-04 15:19:14 +01:00
Fabio Alessandrelli	79bae8e0d5	Merge pull request #156 from Faless/fix/ci_toolchain_urls [CI] Update toolchain URLs to use github releases	2024-12-04 15:18:50 +01:00
Fabio Alessandrelli	355fdd9051	[CI] Update toolchain URLs to use github releases	2024-12-04 15:01:55 +01:00
Fabio Alessandrelli	49de259a08	Merge pull request #154 from Faless/drop_4.0 Drop Godot 4.0 support	2024-12-04 14:53:04 +01:00
Fabio Alessandrelli	9afa5c3a48	Drop Godot 4.0 support It's been unsupported by upstream for a while now, everyone should upgrade to a newer version (4.1/4.2/4.3).	2024-10-26 18:57:38 +02:00
Fabio Alessandrelli	93e11a7343	Merge pull request #155 from Faless/bump/libdatachannel_0.22.2 Update to libdatachannel 0.22.2	2024-10-26 16:07:22 +02:00
Fabio Alessandrelli	ba46b25c00	Update to libdatachannel 0.22.2	2024-10-26 12:57:45 +02:00
Fabio Alessandrelli	31fd88dbf5	Merge pull request #153 from Faless/build/ci_macos_latest [CI] Update macos runners to macos-latest	2024-10-25 17:25:31 +02:00
Fabio Alessandrelli	ea8b37fe29	[CI] Update macos runners to macos-latest	2024-10-25 17:03:29 +02:00
Fabio Alessandrelli	cb1ef2e59c	Merge pull request #152 from Faless/bump/libdatachannel_0.22.1_openssl_3.4.0 Update to libdatachannel 0.22.2 OpenSSL 3.4.0	2024-10-25 11:13:01 +02:00
Fabio Alessandrelli	038bac82d6	Update to libdatachannel 0.22.2 OpenSSL 3.4.0	2024-10-25 10:47:44 +02:00
Fabio Alessandrelli	effada6b45	Merge pull request #148 from Faless/build/better_macos_ios_targets [SCons] Improve CMake and OpenSSL macOS/iOS targets	2024-06-17 18:21:10 +02:00
Fabio Alessandrelli	26bc56f934	[SCons] Improve CMake and OpenSSL macOS/iOS targets Update CI to macos-12 (since macos-11 is not longer available.	2024-06-17 18:01:57 +02:00
Fabio Alessandrelli	44ee53715d	Merge pull request #147 from Faless/build/build_profile [CI] Add patches to use build profile and speed up builds	2024-06-17 17:55:38 +02:00
Fabio Alessandrelli	0b89ed885d	[CI] Add patches to use build profile and speed up builds	2024-06-15 18:37:40 +02:00
Fabio Alessandrelli	bf8f6e4581	Merge pull request #144 from Faless/build/custom_godotcpp Allow building using a custom godot-cpp verison	2024-04-13 15:06:56 +02:00
Fabio Alessandrelli	1443d02c8d	Allow building using a custom godot-cpp verison You can use it with: scons godot_cpp=/path/to/godot-cpp This commit also forces the new "disable_exceptions" godot cpp option to false since exceptions are needed by libdatachannel, and makes sure to always compile/link with dynamic runtime when using MSVC.	2024-04-13 13:36:22 +02:00
Fabio Alessandrelli	431df320c4	Merge pull request #142 from Faless/bump/libdatachannel_0.20.2 Update to libdatachannel 0.20.2	2024-04-12 19:36:37 +02:00
Fabio Alessandrelli	762f7cc5d2	Update to libdatachannel 0.20.2	2024-04-12 15:43:37 +02:00
Fabio Alessandrelli	66a9c6bab3	Merge pull request #141 from Ughuuu/logging-in-godot Use Godot primitives for logging, change default log level	2024-04-12 15:39:06 +02:00
Dragos Daian	e391109df2	Use Godot primitives for logging, change default log level	2024-04-12 15:09:32 +02:00
Fabio Alessandrelli	762365d20a	Merge pull request #138 from Faless/linux/arms [Linux] Add arm32/arm64 linux builds support	2024-02-16 00:24:31 +01:00
Fabio Alessandrelli	34ef1043ee	[Linux] Add arm32/arm64 linux builds support Fix arch detection in GDNative builds (3.x) and add a small patch to avoid warnings spam on ARM. Make CMake march flags explicit for Linux arm32/arm64. Add new platforms to CI.	2024-02-15 22:57:03 +01:00
Fabio Alessandrelli	7141bc487e	Merge pull request #137 from Faless/ci/bump_actions [CI] Update actions, use local copy of godot-cache	2024-02-10 04:57:31 +01:00
Fabio Alessandrelli	9520b23a4c	[CI] Update actions, use local copy of godot-cache	2024-02-10 02:01:48 +01:00
Fabio Alessandrelli	cdb4673f48	Merge pull request #135 from Faless/bump/deps Update to libdatachannel 0.20.1, OpenSSL 3.0.13	2024-02-01 17:01:31 +01:00
Fabio Alessandrelli	5b4221462b	Update to libdatachannel 0.20.1, OpenSSL 3.0.13 Replace deprecated options with the (new) standard ones.	2024-01-30 16:33:25 +01:00
Fabio Alessandrelli	86d080b328	Merge pull request #134 from Faless/fix/mingw_only_export_init_symbol [Windows/MinGW] Only export extension init symbol	2023-12-22 12:47:24 +01:00
Fabio Alessandrelli	1831677f63	[Windows/MinGW] Only export extension init symbol When building for Windows using MinGW GCC we need to apply the same workaround we use on Linux to only export the necessary symbols so we can safely statically link libstdc++	2023-12-22 12:12:01 +01:00
Fabio Alessandrelli	fa28efa51d	Merge pull request #133 from Faless/bump/openssl_3.0.12_libdatachannel_0.19.4 Update to OpenSSL 3.0.12, libdatachannel 0.19.4	2023-12-22 02:43:24 +01:00
Fabio Alessandrelli	6e33e43f36	Update to OpenSSL 3.0.12, libdatachannel 0.19.4	2023-12-22 02:13:41 +01:00
Fabio Alessandrelli	81239d820d	Merge pull request #131 from Faless/fix/linux_only_export_init_symbol [Linux] Only export extension init symbol	2023-12-22 02:10:20 +01:00
Fabio Alessandrelli	b0efc17d3b	[Linux] Only export extension init symbol Since we link with static libstdc++ we need to tell gcc to only export the necessary symbols. Using "-fvisibility=hidden" will not work, since libstdc++ explicitly exports its symbols.	2023-12-22 01:30:01 +01:00
Fabio Alessandrelli	ec0ededcde	Merge pull request #132 from Faless/fix/force_cleanup_on_unload Call rtc::Cleanup when unloading the library	2023-12-22 01:14:07 +01:00
Fabio Alessandrelli	308db19120	Call rtc::Cleanup when unloading the library Avoid potential crash at exit.	2023-12-21 21:39:53 +01:00
Fabio Alessandrelli	724910c734	Merge pull request #130 from Faless/spike/macos_framework [MacOS] Use framekwork to package GDExtension	2023-12-21 18:48:23 +01:00
Fabio Alessandrelli	7a4e27e5f0	[MacOS] Use framekwork to package GDExtension This allows it to be code-signed as a bundle so gatekeeper won't complain when loaded by the editor.	2023-12-20 12:55:43 +01:00
Fabio Alessandrelli	d768508435	Merge pull request #129 from Faless/spike/to_string Add _to_string method to extension classes.	2023-12-19 19:43:42 +01:00
Fabio Alessandrelli	fb2c9c3687	Add _to_string method to extension classes. So printing them in Godot shows the proper class name instead of "Wrapped".	2023-12-19 12:01:54 +01:00
Fabio Alessandrelli	cf23e5e740	Merge pull request #123 from Faless/bump/libdatachannel_0.19.3 Update libdatachannel to version 0.19.3	2023-10-22 11:51:14 +02:00
Fabio Alessandrelli	668d0250a7	Bump libdatachannel to version 0.19.3	2023-10-22 11:02:04 +02:00
Fabio Alessandrelli	121ed5664d	Merge pull request #122 from Faless/bump/openssl_3.0.11 Update to OpenSSL 3.0.11	2023-10-22 10:46:21 +02:00
Fabio Alessandrelli	67a378a667	Bump OpenSSL to version 3.0.11	2023-10-22 10:21:31 +02:00
Fabio Alessandrelli	023c42d3b3	Merge pull request #121 from Faless/fix/use_relative_paths Use relative paths in webrtc.gdextension	2023-10-21 20:25:17 +02:00
Fabio Alessandrelli	6d96092f88	Use relative paths in webrtc.gdextension Allows renaming the extension folder.	2023-10-21 18:14:09 +02:00