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
2026-01-01 05:48:15 +03:00 · 2024-10-25 11:13:01 +02:00 · 2024-10-25 10:47:44 +02:00 · 2024-06-17 18:21:10 +02:00 · 2024-06-17 18:01:57 +02:00 · 2024-06-17 17:55:38 +02:00
42 changed files with 2077 additions and 777 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,31 +1,40 @@
-# Commented out parameters are those with the same value as base LLVM style
+# Commented out parameters are those with the same value as base LLVM style.
 # We can uncomment them if we want to change their value, or enforce the
-# chosen value in case the base style changes (last sync: Clang 6.0.1).
+# chosen value in case the base style changes (last sync: Clang 14.0).
 ---
 ### General config, applies to all languages ###
 BasedOnStyle:  LLVM
 AccessModifierOffset: -4
 AlignAfterOpenBracket: DontAlign
-# AlignConsecutiveAssignments: false
-# AlignConsecutiveDeclarations: false
+# AlignArrayOfStructures: None
+# AlignConsecutiveMacros: None
+# AlignConsecutiveAssignments: None
+# AlignConsecutiveBitFields: None
+# AlignConsecutiveDeclarations: None
 # AlignEscapedNewlines: Right
-# AlignOperands:   true
+AlignOperands:   DontAlign
 AlignTrailingComments: false
+# AllowAllArgumentsOnNextLine: true
 AllowAllParametersOfDeclarationOnNextLine: false
-# AllowShortBlocksOnASingleLine: false
+# AllowShortEnumsOnASingleLine: true
+# AllowShortBlocksOnASingleLine: Never
 # AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Inline
-# AllowShortIfStatementsOnASingleLine: false
+# AllowShortFunctionsOnASingleLine: All
+# AllowShortLambdasOnASingleLine: All
+# AllowShortIfStatementsOnASingleLine: Never
 # AllowShortLoopsOnASingleLine: false
 # AlwaysBreakAfterDefinitionReturnType: None
 # AlwaysBreakAfterReturnType: None
 # AlwaysBreakBeforeMultilineStrings: false
-# AlwaysBreakTemplateDeclarations: false
+# AlwaysBreakTemplateDeclarations: MultiLine
+# AttributeMacros:
+#   - __capability
 # BinPackArguments: true
 # BinPackParameters: true
 # BraceWrapping:
+#   AfterCaseLabel:  false
 #   AfterClass:      false
-#   AfterControlStatement: false
+#   AfterControlStatement: Never
 #   AfterEnum:       false
 #   AfterFunction:   false
 #   AfterNamespace:  false
@@ -35,32 +44,44 @@ AllowShortFunctionsOnASingleLine: Inline
 #   AfterExternBlock: false
 #   BeforeCatch:     false
 #   BeforeElse:      false
+#   BeforeLambdaBody: false
+#   BeforeWhile:     false
 #   IndentBraces:    false
 #   SplitEmptyFunction: true
 #   SplitEmptyRecord: true
 #   SplitEmptyNamespace: true
 # BreakBeforeBinaryOperators: None
+# BreakBeforeConceptDeclarations: true
 # BreakBeforeBraces: Attach
 # BreakBeforeInheritanceComma: false
-BreakBeforeTernaryOperators: false
+# BreakInheritanceList: BeforeColon
+# BreakBeforeTernaryOperators: true
 # BreakConstructorInitializersBeforeComma: false
 BreakConstructorInitializers: AfterColon
 # BreakStringLiterals: true
 ColumnLimit:     0
 # CommentPragmas:  '^ IWYU pragma:'
+# QualifierAlignment: Leave
 # CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 8
 ContinuationIndentWidth: 8
 Cpp11BracedListStyle: false
+# DeriveLineEnding: true
 # DerivePointerAlignment: false
 # DisableFormat:   false
+# EmptyLineAfterAccessModifier: Never
+# EmptyLineBeforeAccessModifier: LogicalBlock
 # ExperimentalAutoDetectBinPacking: false
+# PackConstructorInitializers: BinPack
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+# AllowAllConstructorInitializersOnNextLine: true
 # FixNamespaceComments: true
 # ForEachMacros:
 #   - foreach
 #   - Q_FOREACH
 #   - BOOST_FOREACH
+# IfMacros:
+#   - KJ_IF_MAYBE
 # IncludeBlocks:   Preserve
 IncludeCategories:
  - Regex:           '".*"'
@@ -70,13 +91,21 @@ IncludeCategories:
  - Regex:           '^<.*'
    Priority:        3
 # IncludeIsMainRegex: '(Test)?$'
+# IncludeIsMainSourceRegex: ''
+# IndentAccessModifiers: false
 IndentCaseLabels: true
+# IndentCaseBlocks: false
+# IndentGotoLabels: true
 # IndentPPDirectives: None
+# IndentExternBlock: AfterExternBlock
+# IndentRequires:  false
 IndentWidth:     4
 # IndentWrappedFunctionNames: false
+# InsertTrailingCommas: None
 # JavaScriptQuotes: Leave
 # JavaScriptWrapImports: true
 KeepEmptyLinesAtTheStartOfBlocks: false
+# LambdaBodyIndentation: Signature
 # MacroBlockBegin: ''
 # MacroBlockEnd:   ''
 # MaxEmptyLinesToKeep: 1
@@ -85,39 +114,81 @@ KeepEmptyLinesAtTheStartOfBlocks: false
 # PenaltyBreakBeforeFirstCallParameter: 19
 # PenaltyBreakComment: 300
 # PenaltyBreakFirstLessLess: 120
+# PenaltyBreakOpenParenthesis: 0
 # PenaltyBreakString: 1000
+# PenaltyBreakTemplateDeclaration: 10
 # PenaltyExcessCharacter: 1000000
 # PenaltyReturnTypeOnItsOwnLine: 60
+# PenaltyIndentedWhitespace: 0
 # PointerAlignment: Right
-# RawStringFormats:
-#   - Delimiter:       pb
-#     Language:        TextProto
-#     BasedOnStyle:    google
+# PPIndentWidth:   -1
+# ReferenceAlignment: Pointer
 # ReflowComments:  true
-# SortIncludes:    true
+# RemoveBracesLLVM: false
+# SeparateDefinitionBlocks: Leave
+# ShortNamespaceLines: 1
+# SortIncludes:    CaseSensitive
+# SortJavaStaticImport: Before
 # SortUsingDeclarations: true
 # SpaceAfterCStyleCast: false
+# SpaceAfterLogicalNot: false
 # SpaceAfterTemplateKeyword: true
 # SpaceBeforeAssignmentOperators: true
+# SpaceBeforeCaseColon: false
+# SpaceBeforeCpp11BracedList: false
+# SpaceBeforeCtorInitializerColon: true
+# SpaceBeforeInheritanceColon: true
 # SpaceBeforeParens: ControlStatements
+# SpaceBeforeParensOptions:
+#   AfterControlStatements: true
+#   AfterForeachMacros: true
+#   AfterFunctionDefinitionName: false
+#   AfterFunctionDeclarationName: false
+#   AfterIfMacros:   true
+#   AfterOverloadedOperator: false
+#   BeforeNonEmptyParentheses: false
+# SpaceAroundPointerQualifiers: Default
+# SpaceBeforeRangeBasedForLoopColon: true
+# SpaceInEmptyBlock: false
 # SpaceInEmptyParentheses: false
 # SpacesBeforeTrailingComments: 1
-# SpacesInAngles:  false
+# SpacesInAngles:  Never
+# SpacesInConditionalStatement: false
 # SpacesInContainerLiterals: true
 # SpacesInCStyleCastParentheses: false
+## Godot TODO: We'll want to use a min of 1, but we need to see how to fix
+## our comment capitalization at the same time.
+SpacesInLineCommentPrefix:
+  Minimum:         0
+  Maximum:         -1
 # SpacesInParentheses: false
 # SpacesInSquareBrackets: false
+# SpaceBeforeSquareBrackets: false
+# BitFieldColonSpacing: Both
+# StatementAttributeLikeMacros:
+#   - Q_EMIT
+# StatementMacros:
+#   - Q_UNUSED
+#   - QT_REQUIRE_VERSION
 TabWidth:        4
+# UseCRLF:         false
 UseTab:          Always
+# WhitespaceSensitiveMacros:
+#   - STRINGIZE
+#   - PP_STRINGIZE
+#   - BOOST_PP_STRINGIZE
+#   - NS_SWIFT_NAME
+#   - CF_SWIFT_NAME
 ---
 ### C++ specific config ###
 Language:        Cpp
-Standard:        Cpp11
+Standard:        c++17
 ---
 ### ObjC specific config ###
 Language:        ObjC
-Standard:        Cpp11
+# ObjCBinPackProtocolList: Auto
 ObjCBlockIndentWidth: 4
+# ObjCBreakBeforeNestedBlockParam: true
 # ObjCSpaceAfterProperty: false
 # ObjCSpaceBeforeProtocolList: true
 ---
--- 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
@@ -11,14 +11,19 @@ jobs:
    runs-on: ubuntu-20.04
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4

      - name: Install dependencies
        run: |
-          sudo apt-get install -qq dos2unix recode clang-format-11
+          # Add clang repository (so we have clang-format-14)
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+          sudo apt-add-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"
+          sudo apt-get update
+          # Install required deps
+          sudo apt-get install -qq dos2unix moreutils recode clang-format-14
          sudo update-alternatives --remove-all clang-format
-          sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-11 100
-          sudo pip3 install black==20.8b1 pygments
+          sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-14 100
+          sudo pip3 install black==22.3.0 pygments

      - name: File formatting checks (file_format.sh)
        run: |
@@ -59,35 +64,51 @@ jobs:
            arch: 'x86_64'
            gdnative_flags: 'ios_arch=x86_64'
            sconsflags: 'ios_simulator=true'
-            os: 'macos-11'
+            os: 'macos-12'
            cache-name: ios-x86_64-simulator
          - platform: ios
            arch: 'arm64'
            gdnative_flags: 'ios_arch=arm64'
            sconsflags: ''
-            os: 'macos-11'
+            os: 'macos-12'
            cache-name: ios-arm64

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

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

          # Windows
@@ -108,19 +129,19 @@ jobs:

    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
@@ -140,10 +161,19 @@ jobs:
      - name: Install Linux build dependencies
        if: ${{ matrix.platform == 'linux' }}
        run: |
-          sudo apt-get install build-essential gcc-multilib g++-multilib
+          sudo apt-get update
+          sudo apt-get install build-essential gcc-multilib g++-multilib wget
+
+      - 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'
@@ -152,23 +182,53 @@ 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://downloads.tuxfamily.org/godotengine/toolchains/linux/${{ matrix.buildroot }}.tar.bz2
+          fi
+          tar -xjf ${{ matrix.buildroot }}.tar.bz2
+          ${{ matrix.buildroot }}/relocate-sdk.sh
+          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: Patch godot-cpp to support build profile.
+        run: |
+          patch -p1 < misc/patches/build_profile.diff
+          patch -p1 < misc/patches/build_profile_4.0.diff
+          patch -p1 < misc/patches/build_profile_3.x.diff
+
+      - name: Print tools versions
+        run: |
          python --version
          scons --version
          cmake --version

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

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

-      - name: Compile GDNative - release ${{ matrix.platform }} - ${{ matrix.arch }}
+      - 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
+
+      - 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: |
@@ -180,11 +240,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

@@ -205,17 +265,23 @@ jobs:
        run: |
          mkdir release

-          VERSION="extension" TYPE="webrtc" ./misc/scripts/package_release.sh
+          VERSION="extension-4.1" TYPE="webrtc" ./misc/scripts/package_release.sh
+          VERSION="extension-4.0" 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
-          path: release/*-extension-*.zip
+          name: godot-webrtc-extension-4.1
+          path: release/*-extension-4.1-*.zip

-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
+        with:
+          name: godot-webrtc-extension-4.0
+          path: release/*-extension-4.0-*.zip
+
+      - uses: actions/upload-artifact@v4
        with:
          name: godot-webrtc-gdnative
          path: release/*-gdnative-*.zip
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,9 +1,12 @@
-[submodule "godot-cpp-3.x"]
-	path = godot-cpp-3.x
-	url = https://github.com/godotengine/godot-cpp.git
 [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
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ $ git submodule update --init --recursive

 ### Compiling the extension.

-To build the GDExtension version of the plugin (Godot 4.0) run the following command from the `webrtc-native` folder:
+To build the GDExtension version of the plugin (Godot 4.1+) run the following command from the `webrtc-native` folder:

 ```
 $ scons platform=<your platform>
@@ -29,6 +29,12 @@ $ scons platform=<your platform>

 This will build all the required dependencies into a single shared library.

+To build the "legacy" GDExtension version of the plugin (Godot 4.0) run the following command instead:
+
+```
+$ scons platform=<your platform> godot_version=4.0
+```
+
 To build the GDNative version of the plugin (Godot 3.x) run the following command instead:

 ```
--- a/214
+++ b/214
@@ -12,30 +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", ["3", "4"]))
+opts.Add(EnumVariable("godot_version", "The Godot target version", "4.1", ["3", "4.0", "4.1"]))
+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"
+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"], {
-        "-mios-simulator-version-min=10.0": "-mios-simulator-version-min=11.0",
-        "-miphoneos-version-min=10.0": "-miphoneos-version-min=11.0",
-        "/std:c++14": "/std:c++17",
-        "-std=c++14": "-std=c++17",
-    })
+    replace_flags(
+        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",
+            "/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"])
@@ -46,10 +79,14 @@ if env["godot_version"] == "3":
    if env["platform"] == "osx":
        env["platform"] = "macos"  # compatibility with old osx name
        ARGUMENTS["platform"] = "macos"
+        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"

    # 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"]
@@ -70,16 +107,34 @@ if env["godot_version"] == "3":
    env["suffix"] = ".{}.{}.{}".format(env["platform"], target_compat, env["arch_suffix"])
    env["debug_symbols"] = False

-    # Set missing CC for MinGW from upstream build module.
-    if env["platform"] == "windows" and sys.platform != "win32" and sys.platform != "msys":
-        # Cross-compilation using MinGW
-        if env["bits"] == "64":
-            env["CC"] = "x86_64-w64-mingw32-gcc"
-        elif env["bits"] == "32":
-            env["CC"] = "i686-w64-mingw32-gcc"
+    # Some windows specific hacks.
+    if env["platform"] == "windows":
+        if sys.platform not in ["win32", "msys"]:
+            # Set missing CC for MinGW from upstream build module.
+            if env["bits"] == "64":
+                env["CC"] = "x86_64-w64-mingw32-gcc"
+            elif env["bits"] == "32":
+                env["CC"] = "i686-w64-mingw32-gcc"
+        elif not env["use_mingw"]:
+            # Mark as MSVC build (would have failed to build the library otherwise).
+            env["is_msvc"] = True
+    # 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})
+elif env["godot_version"] == "4.0":
+    sconstruct = env.get("godot_cpp", "godot-cpp-4.0") + "/SConstruct"
+    cpp_env = SConscript(sconstruct)
+    env = cpp_env.Clone()
 else:
-    ARGUMENTS["ios_min_version"] = "11.0"
-    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"})

 # Should probably go to upstream godot-cpp.
 # We let SCons build its default ENV as it includes OS-specific things which we don't
@@ -87,20 +142,28 @@ else:
 # Then we prepend PATH to make it take precedence, while preserving SCons' own entries.
 env.PrependENVPath("PATH", os.getenv("PATH"))
 env.PrependENVPath("PKG_CONFIG_PATH", os.getenv("PKG_CONFIG_PATH"))
-if "TERM" in os.environ: # Used for colored output.
+if "TERM" in os.environ:  # Used for colored output.
    env["ENV"]["TERM"] = os.environ["TERM"]

 # Patch mingw SHLIBSUFFIX.
 if env["platform"] == "windows" and env["use_mingw"]:
    env["SHLIBSUFFIX"] = ".dll"

+# Patch OSXCross config.
+if env["platform"] == "macos" and os.environ.get("OSXCROSS_ROOT", ""):
+    env["SHLIBSUFFIX"] = ".dylib"
+    if env["macos_deployment_target"] != "default":
+        env["ENV"]["MACOSX_DEPLOYMENT_TARGET"] = env["macos_deployment_target"]
+
 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", "webrtc")
+    result_path = os.path.join("bin", "extension-4.1", "webrtc")

 # Our includes and sources
 env.Append(CPPPATH=["src/"])
@@ -112,65 +175,84 @@ sources.append(
        "src/WebRTCLibPeerConnection.cpp",
    ]
 )
-if env["godot_version"] == "4":
-    sources.append("src/init_gdextension.cpp")
-else:
+if env["godot_version"] == "3":
    env.Append(CPPDEFINES=["GDNATIVE_WEBRTC"])
    sources.append("src/init_gdnative.cpp")
    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"])

-# 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.
-mac_universal = env["platform"] == "macos" and env["arch"] == "universal"
-build_targets = []
-build_envs = [env]
+# Add our build tools
+for tool in ["openssl", "cmake", "rtc"]:
+    env.Tool(tool, toolpath=["tools"])

-# For macOS universal builds, setup one build environment per architecture.
-if mac_universal:
-    build_envs = []
-    for arch in ["x86_64", "arm64"]:
-        benv = env.Clone()
-        benv["arch"] = arch
-        benv["CCFLAGS"] = SCons.Util.CLVar(str(benv["CCFLAGS"]).replace("-arch x86_64 -arch arm64", "-arch " + arch))
-        benv["LINKFLAGS"] = SCons.Util.CLVar(str(benv["LINKFLAGS"]).replace("-arch x86_64 -arch arm64", "-arch " + arch))
-        benv["suffix"] = benv["suffix"].replace("universal", arch)
-        benv["SHOBJSUFFIX"] = benv["suffix"] + benv["SHOBJSUFFIX"]
-        build_envs.append(benv)
+ssl = env.OpenSSL()

-# Build our library and its dependencies.
-for benv in build_envs:
-    # Dependencies
-    for tool in ["cmake", "common", "ssl", "rtc"]:
-        benv.Tool(tool, toolpath=["tools"])
+rtc = env.BuildLibDataChannel(ssl)

-    ssl = benv.BuildOpenSSL()
-    benv.NoCache(ssl) # Needs refactoring to properly cache generated headers.
-    rtc = benv.BuildLibDataChannel()
+# 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)

-    benv.Depends(sources, [ssl, rtc])
+# 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 = "webrtc_native{}{}".format(benv["suffix"], benv["SHLIBSUFFIX"])
-    library = benv.SharedLibrary(target=os.path.join(result_path, "lib", result_name), source=sources)
-    build_targets.append(library)
+# Make the shared library
+result_name = "libwebrtc_native{}{}".format(env["suffix"], env["SHLIBSUFFIX"])
+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(build_targets)
-
-# For macOS universal builds, join the libraries using lipo.
-if mac_universal:
-    result_name = "libwebrtc_native{}{}".format(env["suffix"], env["SHLIBSUFFIX"])
-    universal_target = env.Command(os.path.join(result_path, "lib", result_name), build_targets, "lipo $SOURCES -output $TARGETS -create")
-    Default(universal_target)
+Default(library)

 # GDNativeLibrary
 if env["godot_version"] == "3":
    gdnlib = "webrtc" if target != "debug" else "webrtc_debug"
    ext = ".tres"
-    extfile = env.Substfile(os.path.join(result_path, gdnlib + ext), "misc/webrtc" + ext, SUBST_DICT={
-        "{GDNATIVE_PATH}": gdnlib,
-        "{TARGET}": "template_" + env["target"],
-    })
+    extfile = env.Substfile(
+        os.path.join(result_path, gdnlib + ext),
+        "misc/webrtc" + ext,
+        SUBST_DICT={
+            "{GDNATIVE_PATH}": gdnlib,
+            "{TARGET}": "template_" + env["target"],
+        },
+    )
 else:
-    extfile = env.InstallAs(os.path.join(result_path, "webrtc.gdextension"), "misc/webrtc.gdextension")
+    extfile = env.Substfile(
+        os.path.join(result_path, "webrtc.gdextension"),
+        "misc/webrtc.gdextension",
+        SUBST_DICT={"{GODOT_VERSION}": env["godot_version"]},
+    )

 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,238 @@
+diff --git a/godot-cpp/SConstruct b/godot-cpp/SConstruct
+index 42f8fc0..9d59d1f 100644
+--- a/godot-cpp/SConstruct
+++ b/godot-cpp/SConstruct
+@@ -121,6 +121,14 @@ opts.Add(
+     BoolVariable("generate_bindings", "Force GDExtension API bindings generation. Auto-detected by default.", False)
+ )
+ opts.Add(BoolVariable("generate_template_get_node", "Generate a template version of the Node class's get_node.", 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))
+ opts.Add(EnumVariable("precision", "Set the floating-point precision level", "single", ("single", "double")))
+diff --git a/godot-cpp/binding_generator.py b/godot-cpp/binding_generator.py
+index d04c698..41cf29b 100644
+--- a/godot-cpp/binding_generator.py
+++ b/godot-cpp/binding_generator.py
+@@ -70,12 +70,14 @@ def generate_wrappers(target):
+         f.write(txt)
+ 
+ 
+-def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+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)
+ 
+    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"
+     source_gen_folder = Path(output_dir) / "gen" / "src"
+@@ -104,7 +106,7 @@ def get_file_list(api_filepath, 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"]:
+@@ -134,14 +136,107 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+     return files
+ 
+ 
+-def print_file_list(api_filepath, output_dir, headers=False, sources=False):
+def print_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
+     end = ";"
+-    for f in get_file_list(api_filepath, output_dir, headers, sources):
+    for f in get_file_list(api_filepath, output_dir, headers, sources, profile_filepath):
+         print(f, end=end)
+ 
+ 
+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):
+-    files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)]
+    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
+@@ -154,11 +249,12 @@ def scons_generate_bindings(target, source, env):
+         "32" if "32" in env["arch"] else "64",
+         env["precision"],
+         env["godot_cpp_gen_dir"],
+        env.get("build_profile", ""),
+     )
+     return None
+ 
+ 
+-def generate_bindings(api_filepath, use_template_get_node, bits="64", precision="single", output_dir="."):
+def generate_bindings(api_filepath, use_template_get_node, bits="64", precision="single", output_dir=".", profile_filepath=""):
+     api = None
+ 
+     target_dir = Path(output_dir) / "gen"
+@@ -175,7 +271,7 @@ def generate_bindings(api_filepath, use_template_get_node, bits="64", precision=
+     generate_global_constants(api, target_dir)
+     generate_global_constant_binds(api, target_dir)
+     generate_builtin_bindings(api, target_dir, real_t + "_" + bits)
+-    generate_engine_classes_bindings(api, target_dir, use_template_get_node)
+    generate_engine_classes_bindings(api, target_dir, use_template_get_node, profile_filepath)
+     generate_utility_functions(api, target_dir)
+ 
+ 
+@@ -1023,7 +1119,7 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl
+     return "\n".join(result)
+ 
+ 
+-def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
+def generate_engine_classes_bindings(api, output_dir, use_template_get_node, profile_filepath=""):
+     global engine_classes
+     global singletons
+     global native_structures
+@@ -1161,7 +1257,7 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
+ 
+     register_engine_classes_filename = Path(output_dir) / "src" / "register_engine_classes.cpp"
+     with register_engine_classes_filename.open("w+", encoding="utf-8") as source_file:
+-        source_file.write(generate_register_engine_classes_source(api))
+        source_file.write(generate_register_engine_classes_source(api, profile_filepath))
+ 
+     for native_struct in api["native_structures"]:
+         struct_name = native_struct["name"]
+@@ -1585,12 +1681,14 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
+     return "\n".join(result)
+ 
+ 
+-def generate_register_engine_classes_source(api):
+def generate_register_engine_classes_source(api, profile_filepath=""):
+     includes = []
+     registrations = []
+ 
+    build_profile = parse_build_profile(profile_filepath, api)
+
+     for class_api in api["classes"]:
+-        if class_api["name"] == "ClassDB":
+        if class_api["name"] == "ClassDB" or not is_class_included(class_api["name"], build_profile):
+             continue
+ 
+         class_name = class_api["name"]
+@@ -2066,6 +2164,20 @@ def is_pod_type(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(type_name):
+     # Types which we already have implemented.
+     return is_included_struct_type(type_name) or type_name in ["ObjectID"]
--- a/misc/patches/build_profile_3.x.diff
+++ b/misc/patches/build_profile_3.x.diff
@@ -0,0 +1,196 @@
+diff --git a/godot-cpp-3.x/SConstruct b/godot-cpp-3.x/SConstruct
+index f653d54..44f66a5 100644
+--- a/godot-cpp-3.x/SConstruct
+++ b/godot-cpp-3.x/SConstruct
+@@ -170,6 +170,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: val if os.path.isabs(val) else os.path.join(env.Dir("#").abspath, 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..e5bd040 100644
+--- a/godot-cpp-3.x/binding_generator.py
+++ b/godot-cpp-3.x/binding_generator.py
+@@ -12,14 +12,115 @@ def correct_method_name(method_list):
+             method["name"] = "get_node_internal"
+ 
+ 
+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 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:
+        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)
+
+    # 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)
+            for arg in args:
+                if arg in api_dict:
+                    ref_cls.add(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("ConfigFile")
+        front.append("ClassDB")
+    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,
+    }
+
+
+ classes = []
+ 
+ 
+-def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+def get_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
+     global classes
+
+     files = []
+     with open(api_filepath) as api_file:
+         classes = json.load(api_file)
+        build_profile = parse_build_profile(profile_filepath, classes)
+
+     include_gen_folder = Path(output_dir) / "include" / "gen"
+     source_gen_folder = Path(output_dir) / "src" / "gen"
+     for _class in classes:
+@@ -27,7 +128,7 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+         source_filename = source_gen_folder / (strip_name(_class["name"]) + ".cpp")
+         if headers:
+             files.append(str(header_filename.as_posix()))
+-        if sources:
+        if sources and is_class_included(_class["name"], build_profile):
+             files.append(str(source_filename.as_posix()))
+     icall_header_filename = include_gen_folder / "__icalls.hpp"
+     register_types_filename = source_gen_folder / "__register_types.cpp"
+@@ -40,27 +141,32 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+     return files
+ 
+ 
+-def print_file_list(api_filepath, output_dir, headers=False, sources=False):
+-    for f in get_file_list(api_filepath, output_dir, headers, sources):
+def print_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
+    for f in get_file_list(api_filepath, output_dir, headers, sources, profile_filepath):
+         print(f, end=";")
+ 
+ 
+ def scons_emit_files(target, source, env):
+-    files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)]
+    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"], env["godot_cpp_gen_dir"])
+    generate_bindings(str(source[0]), env["generate_template_get_node"], env["godot_cpp_gen_dir"], env["build_profile"])
+     return None
+ 
+ 
+-def generate_bindings(api_filepath, use_template_get_node, output_dir="."):
+def generate_bindings(api_filepath, use_template_get_node, output_dir=".", profile_filepath=""):
+     global classes
+     with open(api_filepath) as api_file:
+         classes = json.load(api_file)
+        build_profile = parse_build_profile(profile_filepath, classes)
+ 
+     icalls = set()
+     include_gen_folder = Path(output_dir) / "include" / "gen"
+@@ -97,7 +203,7 @@ def generate_bindings(api_filepath, use_template_get_node, output_dir="."):
+ 
+     init_method_bindings_filename = source_gen_folder / "__init_method_bindings.cpp"
+     with init_method_bindings_filename.open("w+") as init_method_bindings_file:
+-        init_method_bindings_file.write(generate_init_method_bindings(classes))
+        init_method_bindings_file.write(generate_init_method_bindings(list(filter(lambda x: is_class_included(x["name"], build_profile), classes))))
+ 
+ 
+ def is_reference_type(t):
--- a/misc/patches/build_profile_4.0.diff
+++ b/misc/patches/build_profile_4.0.diff
@@ -0,0 +1,180 @@
+diff --git a/godot-cpp-4.0/SConstruct b/godot-cpp-4.0/SConstruct
+index 27ee137..ec2af72 100644
+--- a/godot-cpp-4.0/SConstruct
+++ b/godot-cpp-4.0/SConstruct
+@@ -119,6 +119,14 @@ opts.Add(
+ opts.Add(
+     BoolVariable("generate_bindings", "Force GDExtension API bindings generation. Auto-detected by default.", False)
+ )
+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("generate_template_get_node", "Generate a template version of the Node class's get_node.", True))
+ 
+ opts.Add(BoolVariable("build_library", "Build the godot-cpp library.", True))
+diff --git a/godot-cpp-4.0/binding_generator.py b/godot-cpp-4.0/binding_generator.py
+index 7634942..7ab51a5 100644
+--- a/godot-cpp-4.0/binding_generator.py
+++ b/godot-cpp-4.0/binding_generator.py
+@@ -70,12 +70,14 @@ def generate_wrappers(target):
+         f.write(txt)
+ 
+ 
+-def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+def get_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
+     api = {}
+     files = []
+     with open(api_filepath) as api_file:
+         api = json.load(api_file)
+ 
+    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"
+     source_gen_folder = Path(output_dir) / "gen" / "src"
+@@ -104,7 +106,7 @@ def get_file_list(api_filepath, 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"]:
+@@ -132,14 +134,107 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
+     return files
+ 
+ 
+-def print_file_list(api_filepath, output_dir, headers=False, sources=False):
+def print_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
+     end = ";"
+-    for f in get_file_list(api_filepath, output_dir, headers, sources):
+    for f in get_file_list(api_filepath, output_dir, headers, sources, profile_filepath):
+         print(f, end=end)
+ 
+ 
+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):
+-    files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)]
+    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
+@@ -1997,6 +2092,20 @@ def is_pod_type(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(type_name):
+     # Types which we already have implemented.
+     return is_included_struct_type(type_name) or type_name in ["ObjectID"]
--- 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
@@ -0,0 +1,29 @@
+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
+++ b/godot-cpp-3.x/SConstruct
+@@ -194,6 +194,9 @@ if host_platform == "windows" and env["platform"] != "android":
+
+     opts.Update(env)
+
+# Allows us to use Godot buildroot toolchain
+env.PrependENVPath("PATH", os.getenv("PATH"))
+
+ # Require C++14
+ if host_platform == "windows" and env["platform"] == "windows" and not env["use_mingw"]:
+     # MSVC
+
--- a/misc/scripts/black_format.sh
+++ b/misc/scripts/black_format.sh
@@ -6,29 +6,21 @@ set -uo pipefail

 # Apply black.
 echo -e "Formatting Python files..."
-PY_FILES=$(find \( -path "./.git" \
-                -o -path "./webrtc" \
-                -o -path "./godot-cpp" \
-                \) -prune \
-                -o \( -name "SConstruct" \
-                -o -name "SCsub" \
-                -o -name "*.py" \
-                \) -print)
+PY_FILES=$(git ls-files -- '*SConstruct' '*SCsub' '*.py' ':!:.git/*' ':!:thirdparty/*')
 black -l 120 $PY_FILES

-git diff > patch.patch
+diff=$(git diff --color)

-# If no patch has been generated all is OK, clean up, and exit.
-if [ ! -s patch.patch ] ; then
-    printf "Files in this commit comply with the black style rules.\n"
-    rm -f patch.patch
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "\e[1;32m*** Files in this commit comply with the black style rules.\e[0m\n"
    exit 0
 fi

-# A patch has been created, notify the user, clean up, and exit.
-printf "\n*** The following differences were found between the code "
-printf "and the formatting rules:\n\n"
-cat patch.patch
-printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
-rm -f patch.patch
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+# Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
 exit 1
--- a/misc/scripts/clang_format.sh
+++ b/misc/scripts/clang_format.sh
@@ -4,55 +4,50 @@
 # This is the primary script responsible for fixing style violations.

 set -uo pipefail
-IFS=$'\n\t'

-CLANG_FORMAT_FILE_EXTS=(".c" ".h" ".cpp" ".hpp" ".cc" ".hh" ".cxx" ".m" ".mm" ".inc" ".java" ".glsl")
+if [ $# -eq 0 ]; then
+    # Loop through all code files tracked by Git.
+    files=$(git ls-files -- '*.c' '*.h' '*.cpp' '*.hpp' '*.cc' '*.hh' '*.cxx' '*.m' '*.mm' '*.inc' '*.java' '*.glsl' \
+                ':!:.git/*' ':!:thirdparty/*' ':!:*/thirdparty/*' ':!:platform/android/java/lib/src/com/google/*' \
+                ':!:*-so_wrap.*' ':!:tests/python_build/*')
+else
+    # $1 should be a file listing file paths to process. Used in CI.
+    files=$(cat "$1" | grep -v "thirdparty/" | grep -E "\.(c|h|cpp|hpp|cc|hh|cxx|m|mm|inc|java|glsl)$" | grep -v "platform/android/java/lib/src/com/google/" | grep -v "\-so_wrap\." | grep -v "tests/python_build/")
+fi

-# Loops through all text files tracked by Git.
-git grep -zIl '' |
-while IFS= read -rd '' f; do
-    # Exclude some files.
-    if [[ "$f" == "thirdparty"* ]]; then
+if [ ! -z "$files" ]; then
+    clang-format --Wno-error=unknown -i $files
+fi
+
+# Fix copyright headers, but not all files get them.
+for f in $files; do
+    if [[ "$f" == *"inc" ]]; then
        continue
-    elif [[ "$f" == "platform/android/java/lib/src/com/google"* ]]; then
+    elif [[ "$f" == *"glsl" ]]; then
        continue
-    elif [[ "$f" == *"-so_wrap."* ]]; then
+    elif [[ "$f" == "platform/android/java/lib/src/org/godotengine/godot/gl/GLSurfaceView"* ]]; then
+        continue
+    elif [[ "$f" == "platform/android/java/lib/src/org/godotengine/godot/gl/EGLLogWrapper"* ]]; then
+        continue
+    elif [[ "$f" == "platform/android/java/lib/src/org/godotengine/godot/utils/ProcessPhoenix"* ]]; then
        continue
    fi

-    for extension in ${CLANG_FORMAT_FILE_EXTS[@]}; do
-        if [[ "$f" == *"$extension" ]]; then
-            # Run clang-format.
-            clang-format -i "$f"
-            # Fix copyright headers, but not all files get them.
-            if [[ "$f" == *"inc" ]]; then
-                continue 2
-            elif [[ "$f" == *"glsl" ]]; then
-                continue 2
-            elif [[ "$f" == *"theme_data.h" ]]; then
-                continue 2
-            elif [[ "$f" == "platform/android/java/lib/src/org/godotengine/godot/input/InputManager"* ]]; then
-                continue 2
-            fi
-            python misc/scripts/copyright_headers.py "$f"
-            continue 2
-        fi
-    done
+    python misc/scripts/copyright_headers.py "$f"
 done

-git diff > patch.patch
+diff=$(git diff --color)

-# If no patch has been generated all is OK, clean up, and exit.
-if [ ! -s patch.patch ] ; then
-    printf "Files in this commit comply with the clang-format style rules.\n"
-    rm -f patch.patch
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "\e[1;32m*** Files in this commit comply with the clang-format style rules.\e[0m\n"
    exit 0
 fi

-# A patch has been created, notify the user, clean up, and exit.
-printf "\n*** The following differences were found between the code "
-printf "and the formatting rules:\n\n"
-cat patch.patch
-printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
-rm -f patch.patch
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+# Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
 exit 1
--- a/misc/scripts/copyright_headers.py
+++ b/misc/scripts/copyright_headers.py
@@ -4,35 +4,35 @@
 import sys

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

 fname = sys.argv[1]
--- a/misc/scripts/file_format.sh
+++ b/misc/scripts/file_format.sh
@@ -4,27 +4,54 @@
 # This is supplementary to clang_format.sh and black_format.sh, but should be
 # run before them.

-# We need dos2unix and recode.
-if [ ! -x "$(command -v dos2unix)" -o ! -x "$(command -v recode)" ]; then
-    printf "Install 'dos2unix' and 'recode' to use this script.\n"
+# We need dos2unix and isutf8.
+if [ ! -x "$(command -v dos2unix)" -o ! -x "$(command -v isutf8)" ]; then
+    printf "Install 'dos2unix' and 'isutf8' (moreutils package) to use this script.\n"
+    exit 1
 fi

 set -uo pipefail
-IFS=$'\n\t'

-# Loops through all text files tracked by Git.
-git grep -zIl '' |
-while IFS= read -rd '' f; do
+if [ $# -eq 0 ]; then
+    # Loop through all code files tracked by Git.
+    mapfile -d '' files < <(git grep -zIl '')
+else
+    # $1 should be a file listing file paths to process. Used in CI.
+    mapfile -d ' ' < <(cat "$1")
+fi
+
+for f in "${files[@]}"; do
    # Exclude some types of files.
-    if [[ "$f" == "webrtc"* ]]; then
+    if [[ "$f" == *"csproj" ]]; then
        continue
-    elif [[ "$f" == "godot-cpp"* ]]; then
+    elif [[ "$f" == *"sln" ]]; then
        continue
-    elif [[ "$f" == "misc/patches"* ]]; then
+    elif [[ "$f" == *".bat" ]]; then
+        continue
+    elif [[ "$f" == *".out" ]]; then
+        # GDScript integration testing files.
+        continue
+    elif [[ "$f" == *"patch" ]]; then
+        continue
+    elif [[ "$f" == *"pot" ]]; then
+        continue
+    elif [[ "$f" == *"po" ]]; then
+        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
+        continue
+    elif [[ "$f" == *"-so_wrap."* ]]; then
+        continue
+    elif [[ "$f" == *".test.txt" ]]; then
        continue
    fi
    # Ensure that files are UTF-8 formatted.
-    recode UTF-8 "$f" 2> /dev/null
+    isutf8 "$f" >> utf8-validation.txt 2>&1
    # Ensure that files have LF line endings and do not contain a BOM.
    dos2unix "$f" 2> /dev/null
    # Remove trailing space characters and ensures that files end
@@ -32,19 +59,33 @@ while IFS= read -rd '' f; do
    perl -i -ple 's/\s*$//g' "$f"
 done

-git diff > patch.patch
+diff=$(git diff --color)

-# If no patch has been generated all is OK, clean up, and exit.
-if [ ! -s patch.patch ] ; then
-    printf "Files in this commit comply with the formatting rules.\n"
-    rm -f patch.patch
+if [ ! -s utf8-validation.txt ] && [ -z "$diff" ] ; then
+    # If no UTF-8 violations were collected (the file is empty) and
+    # no diff has been generated all is OK, clean up, and exit.
+    printf "\e[1;32m*** Files in this commit comply with the file formatting rules.\e[0m\n"
+    rm -f utf8-validation.txt
    exit 0
 fi

-# A patch has been created, notify the user, clean up, and exit.
-printf "\n*** The following differences were found between the code "
-printf "and the formatting rules:\n\n"
-cat patch.patch
-printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
-rm -f patch.patch
+if [ -s utf8-validation.txt ]
+then
+    # If the file has content and is not empty, violations
+    # detected, notify the user, clean up, and exit.
+    printf "\n\e[1;33m*** The following files contain invalid UTF-8 character sequences:\e[0m\n\n"
+    cat utf8-validation.txt
+fi
+
+rm -f utf8-validation.txt
+
+if [ ! -z "$diff" ]
+then
+    # A diff has been created, notify the user, clean up, and exit.
+    printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+    # Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+    printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+fi
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
 exit 1
--- a/misc/scripts/package_release.sh
+++ b/misc/scripts/package_release.sh
@@ -10,18 +10,19 @@ TYPE=${TYPE:-"webrtc"}

 mkdir -p ${DESTINATION}
 ls -R ${DESTINATION}
+ls -R ${ARTIFACTS}

 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 = "extension" ]; then
-    find "${ARTIFACTS}" -wholename "*/${VERSION}/${TYPE}/${TYPE}.gdextension" | head -n 1 | xargs cp -t "${DESTDIR}/"
-else
+if [ $VERSION = "gdnative" ]; then
    find "${ARTIFACTS}" -wholename "*/${VERSION}/${TYPE}/${TYPE}.tres" | head -n 1 | xargs cp -t "${DESTDIR}/"
+else
+    find "${ARTIFACTS}" -wholename "*/${VERSION}/${TYPE}/${TYPE}.gdextension" | head -n 1 | xargs cp -t "${DESTDIR}/"
 fi

 CURDIR=$(pwd)
--- a/misc/webrtc.gdextension
+++ b/misc/webrtc.gdextension
@@ -1,25 +1,30 @@
 [configuration]

 entry_symbol = "webrtc_extension_init"
+compatibility_minimum = {GODOT_VERSION}

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

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

+#if defined(GDNATIVE_WEBRTC) || defined(GDEXTENSION_WEBRTC_40)
 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 {
+#endif
 	ERR_FAIL_COND_V(!peer_connection, nullptr);

 	// Read config from dictionary
@@ -230,7 +253,7 @@ Error WebRTCLibPeerConnection::_set_local_description(const String &p_type, cons
 	ERR_FAIL_COND_V(!peer_connection, ERR_UNCONFIGURED);
 	// XXX Library quirk. It doesn't seem possible to create offers/answers without setting the local description.
 	// Ignore this call for now to avoid crash (it's already set automatically!).
-	//peer_connection->setLocalDescription(p_type == String("offer") ? rtc::Description::Type::Offer : rtc::Description::Type::Answer);
+	// peer_connection->setLocalDescription(p_type == String("offer") ? rtc::Description::Type::Offer : rtc::Description::Type::Answer);
 	return OK;
 }

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

 	godot::Error _initialize(const godot::Dictionary &p_config) override;
+#if defined(GDNATIVE_WEBRTC) || defined(GDEXTENSION_WEBRTC_40)
 	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;
+#endif
 	godot::Error _create_offer() override;
 	godot::Error _set_remote_description(const godot::String &type, const godot::String &sdp) override;
 	godot::Error _set_local_description(const godot::String &type, const godot::String &sdp) override;
--- a/src/init_gdextension.cpp
+++ b/src/init_gdextension.cpp
@@ -1,32 +1,32 @@
-/*************************************************************************/
-/*  init_gdextension.cpp                                                 */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
+/**************************************************************************/
+/*  init_gdextension.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 <gdextension_interface.h>

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

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

 - Upstream: https://github.com/nlohmann/json
- Version: 3.10.5 (4f8fba14066156b73f1189a2b8bd568bde5284c5, 2022)
+- Version: 3.11.3 (9cca280a4d0ccf0c08f47a99aa71d1b0e52f8d03, 2023)
 - License: MIT

 Module location:
@@ -19,7 +19,7 @@ Module location:
 ## libdatachannel

 - Upstream: https://github.com/paullouisageneau/libdatachannel
- Version: 0.18.4 (4dd6c2117684c3d7d13c0d02b5aee8d4c2b661b0, 2023)
+- Version: 0.22.1 (f8ffbe37e6c06e4838b41c2c018ccc3a8028a1c8, 2024)
 - License: MPL 2.0

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

 - Upstream: https://github.com/paullouisageneau/libjuice
- Version: 1.2.3 (8c23cc88c6d41e5ccbc44ea0ad3d79b22cf02361, 2023)
+- Version: 1.5.7 (70ba50cce33350b64404557ea63658e925758ce6, 2024)
 - License: MPL 2.0

 Module location:
@@ -52,7 +52,7 @@ Module location:
 ## openssl

 - Upstream: git://git.openssl.org/openssl.git
- Version: 3.0.8 (31157bc0b46e04227b8468d3e6915e4d0332777c, 2023)
+- Version: 3.4.0 (98acb6b02839c609ef5b837794e08d906d965335, 2024)
 - License: Apache 2.0

 Module location:
@@ -63,8 +63,8 @@ Module location:
 ## 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 +74,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/openssl
+++ b/thirdparty/openssl
--- a/tools/cmake.py
+++ b/tools/cmake.py
@@ -1,27 +1,136 @@
+import os, sys
+
+import SCons.Util
+import SCons.Builder
+import SCons.Action
+
+
+def cmake_default_flags(env):
+    if env.get("cmake_default_flags", ""):
+        return SCons.Util.CLVar(env["cmake_default_flags"])
+
+    config = {}
+
+    if "CC" in env:
+        config["CMAKE_C_COMPILER"] = env["CC"]
+    if "CXX" in env:
+        config["CMAKE_CXX_COMPILER"] = env["CXX"]
+
+    if env["platform"] == "android":
+        api = env["android_api_level"]
+        abi = {
+            "arm64": "arm64-v8a",
+            "arm32": "armeabi-v7a",
+            "x86_32": "x86",
+            "x86_64": "x86_64",
+        }[env["arch"]]
+        config["CMAKE_SYSTEM_NAME"] = "Android"
+        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", "")
+        )
+        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
+            config["CMAKE_CXX_FLAGS"] = linux_flags
+
+    elif env["platform"] == "macos":
+        if env["arch"] == "universal":
+            config["CMAKE_OSX_ARCHITECTURES"] = '"x86_64;arm64"'
+        else:
+            config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
+        if env.get("macos_deployment_target", "default") != "default":
+            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["macos_deployment_target"]
+        if sys.platform != "darwin" and "OSXCROSS_ROOT" in os.environ:
+            config["CMAKE_AR"] = env["AR"]
+            config["CMAKE_RANLIB"] = env["RANLIB"]
+            if env["arch"] == "universal":
+                flags = "-arch x86_64 -arch arm64"
+            else:
+                flags = "-arch " + env["arch"]
+            if env["macos_deployment_target"] != "default":
+                flags += " -mmacosx-version-min=" + env["macos_deployment_target"]
+            config["CMAKE_C_FLAGS"] = flags
+            config["CMAKE_CXX_FLAGS"] = flags
+
+    elif env["platform"] == "ios":
+        if env["arch"] == "universal":
+            raise ValueError("iOS architecture not supported: %s" % env["arch"])
+        config["CMAKE_SYSTEM_NAME"] = "iOS"
+        config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
+        if env.get("ios_min_version", "default") != "default":
+            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["ios_min_version"]
+        if env["ios_simulator"]:
+            config["CMAKE_OSX_SYSROOT"] = "iphonesimulator"
+
+    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
+
+
+def cmake_emitter(target, source, env):
+    return [str(target[0]) + "/CMakeCache.txt"] + target[1:], [str(source[0]) + "/CMakeLists.txt"] + source[1:]
+
+
+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 [
+        SCons.Action.Action("$CMAKECONFCOM", "$CMAKECONFCOMSTR"),
+        SCons.Action.Action(build, "$CMAKEBUILDCOMSTR"),
+    ]
+
+
+def cmake_build(env, target_dir, source_dir, cmake_outputs=[], cmake_targets=[], cmake_options=[], dependencies=[]):
+    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()])
+    if len(cmake_targets) > 0:
+        cmake_env.Append(CMAKEBUILDFLAGS=["-t"] + [t for t in cmake_targets])
+    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.", "")
+

 def exists(env):
    return True


 def generate(env):
-    env.AddMethod(cmake_configure, "CMakeConfigure")
+    env["CMAKE"] = "cmake"
+    env["_cmake_default_flags"] = cmake_default_flags
+    env["CMAKEDEFAULTFLAGS"] = "${_cmake_default_flags(__env__)}"
+    env["CMAKEGENERATOR"] = ""
+    env["CMAKECONFFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKECONFCOM"] = "$CMAKE -B ${TARGET.dir} $CMAKEDEFAULTFLAGS $CMAKECONFFLAGS ${SOURCE.dir}"
+    env["CMAKEBUILDJOBS"] = "${__env__.GetOption('num_jobs')}"
+    env["CMAKEBUILDFLAGS"] = SCons.Util.CLVar("")
+    env["CMAKEBUILDCOM"] = "$CMAKE --build ${TARGET.dir} $CMAKEBUILDFLAGS -j$CMAKEBUILDJOBS"
+    env["BUILDERS"]["CMake"] = SCons.Builder.Builder(generator=cmake_generator, emitter=cmake_emitter)
    env.AddMethod(cmake_build, "CMakeBuild")
-
-
-def cmake_configure(env, source, target, opt_args):
-    args = [
-        "-B",
-        target,
-    ]
-    if env["platform"] == "windows" and env["use_mingw"]:
-        args.extend(["-G", "Unix Makefiles"])
-    for arg in opt_args:
-        args.append(arg)
-    args.append(source)
-    return env.Execute("cmake " + " ".join(['"%s"' % a for a in args]))
-
-
-def cmake_build(env, source, target=""):
-    jobs = env.GetOption("num_jobs")
-    env = env.Clone()
-    return env.Execute("cmake --build %s %s -j%s" % (source, "-t %s" % target if target else "", jobs))
--- a/tools/common.py
+++ b/tools/common.py
@@ -1,8 +0,0 @@
-
-def exists(env):
-    return True
-
-
-def generate(env):
-    env["DEPS_SOURCE"] = env.Dir("#thirdparty").abspath
-    env["DEPS_BUILD"] = env.Dir("#bin/thirdparty").abspath + "/{}.{}.dir".format(env["suffix"][1:], "RelWithDebInfo" if env["debug_symbols"] else "Release")
--- a/tools/openssl.py
+++ b/tools/openssl.py
@@ -0,0 +1,298 @@
+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"] == "ios":
+        if env.get("ios_min_version", "default") != "default":
+            if env.get("ios_simulator", False):
+                args.append("-mios-simulator-version-min=%s" % env["ios_min_version"])
+            else:
+                args.append("-miphoneos-version-min=%s" % env["ios_min_version"])
+    elif env["platform"] == "macos":
+        if env.get("macos_deployment_target", "default") != "default":
+            args.append("-mmacosx-version-min=%s" % env["macos_deployment_target"])
+        # 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"])
+        if env["platform"] == "linux":
+            env.PrependUnique(LIBS=["pthread", "dl"])
+        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"])
+    if env["platform"] == "linux":
+        env.PrependUnique(LIBS=["pthread", "dl"])
+    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,96 +1,53 @@
 import os

-def rtc_cmake_config(env):
-    config = {
+
+def build_library(env, ssl):
+    rtc_config = {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo" if env["debug_symbols"] else "Release",
        "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_BUILD"],
-        "CMAKE_BUILD_TYPE": "%s" % ("RelWithDebInfo" if env["debug_symbols"] else "Release"),
+        "OPENSSL_ROOT_DIR": env["SSL_INSTALL"],
    }
-    if "CC" in env:
-        config["CMAKE_C_COMPILER"] = env["CC"]
-    if "CXX" in env:
-        config["CMAKE_CXX_COMPILER"] = env["CXX"]
+    is_msvc = env.get("is_msvc", False)
+    lib_ext = ".lib" if is_msvc else ".a"
+    lib_prefix = "" if is_msvc else "lib"
+    rtc_libs = [
+        "{}datachannel-static{}".format(lib_prefix, lib_ext),
+        "deps/libjuice/{}juice-static{}".format(lib_prefix, lib_ext),
+        "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",
+        cmake_options=rtc_config,
+        cmake_outputs=rtc_libs,
+        cmake_targets=["datachannel-static"],
+        dependencies=ssl,
+    )

-    if env["platform"] == "android":
-        api = env["android_api_level"] if int(env["android_api_level"]) > 28 else "28"
-        abi = {
-            "arm64": "arm64-v8a",
-            "arm32": "armeabi-v7a",
-            "x86_32": "x86",
-            "x86_64": "x86_64",
-        }[env["arch"]]
-        config["CMAKE_SYSTEM_NAME"] = "Android"
-        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" % os.environ.get("ANDROID_NDK_ROOT", "")
-        config["CMAKE_ANDROID_STL_TYPE"] = "c++_static"
-    elif env["platform"] == "linux":
-        march = "-m32" if env["arch"] == "x86_32" else "-m64"
-        config["CMAKE_C_FLAGS"] = march
-        config["CMAKE_CXX_FLAGS"] = march
-    elif env["platform"] == "macos":
-        if env["arch"] == "universal":
-            raise ValueError("OSX architecture not supported: %s" % env["arch"])
-        config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
-        if env["macos_deployment_target"] != "default":
-            config["CMAKE_OSX_DEPLOYMENT_TARGET"] = env["macos_deployment_target"]
-    elif env["platform"] == "ios":
-        if env["arch"] == "universal":
-            raise ValueError("iOS architecture not supported: %s" % env["arch"])
-        config["CMAKE_SYSTEM_NAME"] = "iOS"
-        config["CMAKE_OSX_DEPLOYMENT_TARGET"] = "11.0"
-        config["CMAKE_OSX_ARCHITECTURES"] = env["arch"]
-        if env["ios_simulator"]:
-                config["CMAKE_OSX_SYSROOT"] = "iphonesimulator"
-    elif env["platform"] == "windows":
-        config["CMAKE_SYSTEM_NAME"] = "Windows"
-        config["BUILD_WITH_WARNINGS"] = "0"  # Disables werror in libsrtp.
-    return config
+    # Configure env.
+    if env["platform"] == "windows":
+        env.PrependUnique(LIBS=["iphlpapi", "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"])

-
-def rtc_emitter(target, source, env):
-    env.Depends(env["RTC_LIBS"], env["SSL_LIBS"])
-    env.Depends(env["RTC_LIBS"], [env.File(__file__), env.Dir(env["RTC_SOURCE"]), env.File(env["RTC_SOURCE"] + "/CMakeLists.txt")])
-    return env["RTC_LIBS"], env.Dir(env["RTC_SOURCE"])
-
-
-def rtc_action(target, source, env):
-    rtc_env = env.Clone()
-    build_dir = env["RTC_BUILD"]
-    source_dir = env["RTC_SOURCE"]
-    opts = rtc_cmake_config(rtc_env)
-    rtc_env.CMakeConfigure(source_dir, build_dir, ["-D%s=%s" % it for it in opts.items()])
-    rtc_env.CMakeBuild(build_dir, "datachannel-static")
-    return None
+    return rtc


 def exists(env):
-    return "CMakeConfigure" in env and "CMakeBuild" in env
+    return "CMake" in env


 def generate(env):
-    env["RTC_SOURCE"] = env["DEPS_SOURCE"] + "/libdatachannel"
-    env["RTC_BUILD"] = env["DEPS_BUILD"] + "/libdatachannel"
-    env["RTC_INCLUDE"] = env["RTC_SOURCE"] + "/include"
-    env["RTC_LIBS"] = [env.File(env["RTC_BUILD"] + "/" + lib) for lib in [
-        "libdatachannel-static.a",
-        "deps/libjuice/libjuice-static.a",
-        "deps/libsrtp/libsrtp2.a",
-        "deps/usrsctp/usrsctplib/libusrsctp.a"
-    ]]
-    env.Append(BUILDERS={
-        "BuildLibDataChannel": env.Builder(action=rtc_action, emitter=rtc_emitter)
-    })
-    env.Append(LIBPATH=[env["RTC_BUILD"]])
-    env.Append(CPPPATH=[env["RTC_INCLUDE"]])
-    env.Prepend(LIBS=env["RTC_LIBS"])
-    if env["platform"] == "windows":
-        env.AppendUnique(LIBS=["iphlpapi", "bcrypt"])
+    env.AddMethod(build_library, "BuildLibDataChannel")
--- a/tools/ssl.py
+++ b/tools/ssl.py
@@ -1,115 +0,0 @@
-import os
-from SCons.Defaults import Mkdir
-
-def ssl_emitter(target, source, env):
-    env.Depends(env["SSL_LIBS"], env.File(__file__))
-    return env["SSL_LIBS"], [env.Dir(env["SSL_SOURCE"]), env.File(env["SSL_SOURCE"] + "/VERSION.dat")]
-
-
-def ssl_action(target, source, env):
-    build_dir = env["SSL_BUILD"]
-    source_dir = env["SSL_SOURCE"]
-    install_dir = env["SSL_INSTALL"]
-
-    ssl_env = env.Clone()
-    args = [
-        "no-ssl2",
-        "no-ssl3",
-        "no-weak-ssl-ciphers",
-        "no-legacy",
-        "no-shared",
-        "no-tests",
-        "--prefix=%s" % install_dir,
-        "--openssldir=%s" % install_dir,
-    ]
-    if env["debug_symbols"]:
-        args.append("-d")
-
-    if env["platform"] == "linux":
-        if env["arch"] == "x86_32":
-            args.extend(["linux-x86"])
-        else:
-            args.extend(["linux-x86_64"])
-
-    elif env["platform"] == "android":
-        api = env["android_api_level"] if int(env["android_api_level"]) > 28 else "28"
-        args.extend([
-            {
-                "arm64": "android-arm64",
-                "arm32": "android-arm",
-                "x86_32": "android-x86",
-                "x86_64": "android-x86_64",
-            }[env["arch"]],
-            "-D__ANDROID_API__=%s" % api,
-        ])
-        # Setup toolchain path.
-        ssl_env.PrependENVPath("PATH", os.path.dirname(env["CC"]))
-        ssl_env["ENV"]["ANDROID_NDK_ROOT"] = os.environ.get("ANDROID_NDK_ROOT", "")
-
-    elif env["platform"] == "macos":
-        if env["arch"] == "x86_64":
-            args.extend(["darwin64-x86_64"])
-        elif env["arch"] == "arm64":
-            args.extend(["darwin64-arm64"])
-        else:
-            raise ValueError("macOS architecture not supported: %s" % env["arch"])
-
-    elif env["platform"] == "ios":
-        if env["ios_simulator"]:
-                args.extend(["iossimulator-xcrun"])
-        elif env["arch"] == "arm32":
-            args.extend(["ios-xcrun"])
-        elif env["arch"] == "arm64":
-            args.extend(["ios64-xcrun"])
-        else:
-            raise ValueError("iOS architecture not supported: %s" % env["arch"])
-
-    elif env["platform"] == "windows":
-        if env["arch"] == "x86_32":
-            if env["use_mingw"]:
-                args.extend([
-                    "mingw",
-                    "--cross-compile-prefix=i686-w64-mingw32-",
-                ])
-            else:
-                args.extend(["VC-WIN32"])
-        else:
-            if env["use_mingw"]:
-                args.extend([
-                    "mingw64",
-                    "--cross-compile-prefix=x86_64-w64-mingw32-",
-                ])
-            else:
-                args.extend(["VC-WIN64A"])
-
-    jobs = env.GetOption("num_jobs")
-    ssl_env.Execute([
-            Mkdir(build_dir),
-            "cd %s && perl %s/Configure %s" % (build_dir, source_dir, " ".join(['"%s"' % a for a in args])),
-            "make -C %s -j%s" % (build_dir, jobs),
-            "make -C %s install_sw install_ssldirs -j%s" % (build_dir, jobs),
-        ]
-    )
-    return None
-
-
-def exists(env):
-    return True
-
-
-def generate(env):
-    env["SSL_SOURCE"] = env["DEPS_SOURCE"] + "/openssl"
-    env["SSL_BUILD"] = env["DEPS_BUILD"] + "/openssl"
-    env["SSL_INSTALL"] = env["SSL_BUILD"] + "/dest"
-    env["SSL_INCLUDE"] = env["SSL_INSTALL"] + "/include"
-    env["SSL_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libssl.a")
-    env["SSL_CRYPTO_LIBRARY"] = env.File(env["SSL_BUILD"] + "/libcrypto.a")
-    env["SSL_LIBS"] = [env["SSL_LIBRARY"], env["SSL_CRYPTO_LIBRARY"]]
-    env.Append(BUILDERS={
-        "BuildOpenSSL": env.Builder(action=ssl_action, emitter=ssl_emitter)
-    })
-    env.Prepend(CPPPATH=[env["SSL_INCLUDE"]])
-    env.Prepend(LIBPATH=[env["SSL_BUILD"]])
-    env.Append(LIBS=env["SSL_LIBS"])
-    if env["platform"] == "windows":
-        env.AppendUnique(LIBS=["ws2_32", "gdi32", "advapi32", "crypt32", "user32"])
Author	SHA1	Message	Date
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
Fabio Alessandrelli	77969f68d9	Merge pull request #115 from Faless/bump/openssl_3.0.10_libdatachannel_0.18.6 Bump dependencies	2023-09-10 16:22:15 +02:00
Fabio Alessandrelli	a9d8ea2a1c	Bump dependencies OpenSSL 3.0.10 libdatachannel 0.18.6 godot-cpp 4.1-stable (used to be 4.1-rc2, this normalizes it) Includes a small Linux CI fix to run apt update before apt install.	2023-09-04 19:58:33 +02:00
Fabio Alessandrelli	6e2262b6c3	Merge pull request #113 from Faless/spike/4.1 Support building for Godot 4.1 (new default).	2023-07-01 19:43:42 +02:00
Fabio Alessandrelli	cb2be8723a	Support building for Godot 4.1 (new default).	2023-06-30 16:52:36 +02:00
Fabio Alessandrelli	d278661d76	Merge pull request #112 from Faless/spike/buildroot Build Linux binaries using the Godot toolchian.	2023-06-30 16:46:58 +02:00
Fabio Alessandrelli	552d696e0a	Build Linux binaries using the Godot toolchian. So we link to very old glibc and support ancient distros.	2023-06-30 10:06:06 +02:00
Fabio Alessandrelli	6f4d8f5238	Merge pull request #111 from Faless/bump/openssl_3.0.9 [OpenSSL] Update to version 3.0.9	2023-06-30 09:00:55 +02:00
Fabio Alessandrelli	8040565b0e	[OpenSSL] Update to version 3.0.9	2023-06-30 08:25:32 +02:00
Fabio Alessandrelli	38c83f667d	Merge pull request #109 from Faless/fix/linux_static_gcc_cpp Statically link libgcc and libstdc++ on linux	2023-06-30 07:56:59 +02:00
Fabio Alessandrelli	1de32aa9ea	Statically link libgcc and libstdc++ on Linux. More compatibility at the cost of bigger binaries.	2023-06-29 14:57:55 +02:00
Fabio Alessandrelli	ed3771ced0	Merge pull request #108 from Faless/fix/normalize_ios_min_version Better normalize the GDNative build environment.	2023-06-29 14:51:47 +02:00
Fabio Alessandrelli	ac3bdb3613	Better normalize the GDNative build environment. The "ios_min_version" is missing from godot-cpp-3.x, and the macos CC variable is not explicitely set to "clang". Since the values are passed to cmake, they used to cause unnecessary rebuilds of libdatchannel when compiling both version 3 and 4.	2023-06-29 14:15:48 +02:00
Fabio Alessandrelli	931a7551f5	Merge pull request #107 from Faless/build/cmake_helper [SCons] Simplify building cmake libraries.	2023-06-29 14:04:53 +02:00
Fabio Alessandrelli	0771084b54	[SCons] Simplify building cmake libraries. Add an extra "CMakeBuild" method to reduce configuration needed by each library.	2023-06-29 13:37:09 +02:00
Fabio Alessandrelli	ae0dd0626a	Merge pull request #106 from Faless/build/openssl_external [OpenSSL] Allow using external (static) libraries.	2023-06-23 17:12:25 +02:00
Fabio Alessandrelli	0be6b671e5	[OpenSSL] Allow using external (static) libraries. In case one wants to handle openssl builds manually (or use static libraries provided by third parties like those in Linux distros). Note that they still must be static libraries, adding support for linking against shared libraries needs more work (and testing).	2023-06-23 16:08:04 +02:00
Fabio Alessandrelli	d96b43b7ee	Merge pull request #104 from Faless/bump/libdatachannel_0.18.5 [libdatachannel] Update to v0.18.5	2023-06-21 06:08:27 +02:00
Fabio Alessandrelli	ec8cd5c0e4	[libdatachannel] Update to v0.18.5	2023-06-21 04:36:40 +02:00
Fabio Alessandrelli	b03099f7b4	Merge pull request #105 from Faless/build/tool_options Linux ARM32/ARM64, better toolchains support.	2023-06-21 04:34:38 +02:00
Fabio Alessandrelli	85efdfd6ce	Linux ARM32/ARM64, better toolchains support. Needs updated godot-cpp to build library with custom toolchains. Make the OpenSSL and CMake tools more customizable letting the user override the default platform flags via build options. Improve dependency handling.	2023-06-21 03:54:39 +02:00
Fabio Alessandrelli	32ae1d1195	Merge pull request #103 from Faless/build/less_rebuilds [SCons] Fix regression causing unnecessary rebuilds.	2023-06-20 18:53:08 +02:00
Fabio Alessandrelli	54c8586235	[SCons] Fix regression causing unnecessary rebuilds. The num_jobs (-j flag) was being tracked as part of the cmake and openssl build actions, thus causing a rebuild when compiling with different concurrently. This commit strip the -j flag from the signature of the actions so scons won't rebuild openssl/libdatachannel when changing the parallelism option.	2023-06-20 17:45:23 +02:00
Fabio Alessandrelli	f19011f2fb	Merge pull request #102 from Faless/build/builders [SCons] Refactor CMake and OpenSSL tools to use actions.	2023-06-20 16:24:45 +02:00
Fabio Alessandrelli	86c27ec7ef	[SCons] Refactor CMake and OpenSSL tools to use actions. Improve build reliability, allow for more customization.	2023-06-20 13:22:07 +02:00
Fabio Alessandrelli	f2ee596bd9	Merge pull request #100 from Faless/build/openssl_universal [SCons] Refactor build system.	2023-06-17 20:19:10 +02:00
Fabio Alessandrelli	61299ca4b7	[SCons] Refactor build system. Update ssl tool (now renamed openssl). Move universal library "lipo" action to openssl tool, and add universal builds support to cmake tool. Add support for MSVC builds (requires nasm and perl in PATH, tested with Strawberry Perl, VS 2019 and VS 2022). Add support for building "macos" via OSXCross.	2023-06-17 19:46:54 +02:00
Fabio Alessandrelli	df643250f5	Merge pull request #98 from Faless/build/cmake_platform [SCons] Move platform configuration to cmake tool.	2023-05-25 07:29:57 +02:00
Fabio Alessandrelli	45549e020f	[SCons] Move platform configuration to cmake tool.	2023-05-25 06:07:03 +02:00
Fabio Alessandrelli	ee40730c20	Merge pull request #97 from Faless/fix/ci_scripts [CI] Update static checks, copyright headers.	2023-05-25 05:31:07 +02:00
Fabio Alessandrelli	8f7cb77f34	[CI] Update static checks, copyright headers.	2023-05-25 04:34:31 +02:00
Fabio Alessandrelli	eb65d88cd4	Merge pull request #96 from Faless/fix/black [CI] Fix python black formatting.	2023-05-25 03:15:43 +02:00
Fabio Alessandrelli	e8de07dbb1	[CI] Fix python black formatting.	2023-05-25 02:42:26 +02:00