Merge pull request #77 from Faless/bump/beta10

Update to Godot 4.0-beta10.
2026-01-01 05:48:15 +03:00 · 2022-12-29 17:30:51 +01:00 · 2022-12-29 15:38:48 +01:00 · 2022-12-19 22:11:33 +01:00 · 2022-12-19 20:42:56 +01:00 · 2022-12-10 18:26:25 +01:00
42 changed files with 2785 additions and 703 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -0,0 +1,128 @@
+# 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).
+---
+### General config, applies to all languages ###
+BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: DontAlign
+# AlignConsecutiveAssignments: false
+# AlignConsecutiveDeclarations: false
+# AlignEscapedNewlines: Right
+# AlignOperands:   true
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+# AllowShortBlocksOnASingleLine: false
+# AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+# AllowShortIfStatementsOnASingleLine: false
+# AllowShortLoopsOnASingleLine: false
+# AlwaysBreakAfterDefinitionReturnType: None
+# AlwaysBreakAfterReturnType: None
+# AlwaysBreakBeforeMultilineStrings: false
+# AlwaysBreakTemplateDeclarations: false
+# BinPackArguments: true
+# BinPackParameters: true
+# BraceWrapping:
+#   AfterClass:      false
+#   AfterControlStatement: false
+#   AfterEnum:       false
+#   AfterFunction:   false
+#   AfterNamespace:  false
+#   AfterObjCDeclaration: false
+#   AfterStruct:     false
+#   AfterUnion:      false
+#   AfterExternBlock: false
+#   BeforeCatch:     false
+#   BeforeElse:      false
+#   IndentBraces:    false
+#   SplitEmptyFunction: true
+#   SplitEmptyRecord: true
+#   SplitEmptyNamespace: true
+# BreakBeforeBinaryOperators: None
+# BreakBeforeBraces: Attach
+# BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: false
+# BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: AfterColon
+# BreakStringLiterals: true
+ColumnLimit:     0
+# CommentPragmas:  '^ IWYU pragma:'
+# CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: false
+# DerivePointerAlignment: false
+# DisableFormat:   false
+# ExperimentalAutoDetectBinPacking: false
+# FixNamespaceComments: true
+# ForEachMacros:
+#   - foreach
+#   - Q_FOREACH
+#   - BOOST_FOREACH
+# IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '".*"'
+    Priority:        1
+  - Regex:           '^<.*\.h>'
+    Priority:        2
+  - Regex:           '^<.*'
+    Priority:        3
+# IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: true
+# IndentPPDirectives: None
+IndentWidth:     4
+# IndentWrappedFunctionNames: false
+# JavaScriptQuotes: Leave
+# JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+# MacroBlockBegin: ''
+# MacroBlockEnd:   ''
+# MaxEmptyLinesToKeep: 1
+# NamespaceIndentation: None
+# PenaltyBreakAssignment: 2
+# PenaltyBreakBeforeFirstCallParameter: 19
+# PenaltyBreakComment: 300
+# PenaltyBreakFirstLessLess: 120
+# PenaltyBreakString: 1000
+# PenaltyExcessCharacter: 1000000
+# PenaltyReturnTypeOnItsOwnLine: 60
+# PointerAlignment: Right
+# RawStringFormats:
+#   - Delimiter:       pb
+#     Language:        TextProto
+#     BasedOnStyle:    google
+# ReflowComments:  true
+# SortIncludes:    true
+# SortUsingDeclarations: true
+# SpaceAfterCStyleCast: false
+# SpaceAfterTemplateKeyword: true
+# SpaceBeforeAssignmentOperators: true
+# SpaceBeforeParens: ControlStatements
+# SpaceInEmptyParentheses: false
+# SpacesBeforeTrailingComments: 1
+# SpacesInAngles:  false
+# SpacesInContainerLiterals: true
+# SpacesInCStyleCastParentheses: false
+# SpacesInParentheses: false
+# SpacesInSquareBrackets: false
+TabWidth:        4
+UseTab:          Always
+---
+### C++ specific config ###
+Language:        Cpp
+Standard:        Cpp11
+---
+### ObjC specific config ###
+Language:        ObjC
+Standard:        Cpp11
+ObjCBlockIndentWidth: 4
+# ObjCSpaceAfterProperty: false
+# ObjCSpaceBeforeProtocolList: true
+---
+### Java specific config ###
+Language:        Java
+# BreakAfterJavaFieldAnnotations: false
+JavaImportGroups: ['org.godotengine', 'android', 'androidx', 'com.android', 'com.google', 'java', 'javax']
+...
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,64 @@
+name: Bug report
+description: Report a bug in the WebRTC native plugin.
+body:
+
+- type: markdown
+  attributes:
+    value: |
+      - Write a descriptive issue title above.
+      - Search [open](https://github.com/godotengine/webrtc-native/issues) and [closed](https://github.com/godotengine/webrtc-native/issues?q=is%3Aissue+is%3Aclosed) issues to ensure it has not already been reported.
+      - Verify that you are using a [supported Godot version](https://docs.godotengine.org/en/stable/about/release_policy.html).
+
+- type: input
+  attributes:
+    label: Godot version
+    description: >
+      Specify the Git commit hash if using a development or non-official build.
+      If you use a custom build, please test if your issue is reproducible in official builds too.
+    placeholder: 3.3.stable, 4.0.dev (3041becc6)
+  validations:
+    required: true
+
+- type: input
+  attributes:
+    label: Plugin version
+    description: >
+      Specify the Git commit hash if using a development or non-official build.
+      If you use a custom build, please test if your issue is reproducible in official builds too.
+    placeholder: 0.3, 0.5, 0.6.dev (072ba5c)
+  validations:
+    required: true
+
+- type: input
+  attributes:
+    label: System information
+    description: |
+      Specify the OS version, and when relevant hardware information.
+    placeholder: Android 10, Fairphone 3+.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Issue description
+    description: |
+      Describe your issue briefly. What doesn't work, and how do you expect it to work instead?
+      You can include images or videos with drag and drop, and format code blocks or logs with <code>```</code> tags.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Steps to reproduce
+    description: |
+      List of steps or sample code that reproduces the issue. Having reproducible issues is a prerequisite for contributors to be able to solve them.
+      If you include a minimal reproduction project below, you can detail how to use it here.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Minimal reproduction project
+    description: |
+      A small Godot project which reproduces the issue. Highly recommended to speed up troubleshooting.
+      Drag and drop a ZIP archive to upload it.
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,6 @@
+blank_issues_enabled: false
+
+contact_links:
+  - name: Godot proposals
+    url: https://github.com/godotengine/godot-proposals
+    about: Please submit feature proposals about the WebRTC exposed API on the Godot proposals repository, not here.
--- a/.github/workflows/build_release.yml
+++ b/.github/workflows/build_release.yml
@@ -0,0 +1,227 @@
+name: 🔧 Build -> Package 📦
+on: [push, pull_request]
+
+env:
+  # Only used for the cache key. Increment version to force clean build.
+  GODOT_BASE_BRANCH: master
+
+jobs:
+  static-checks:
+    name: 📊 Static Checks (clang-format, black format, file format)
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get install -qq dos2unix recode clang-format-11
+          sudo update-alternatives --remove-all clang-format
+          sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-11 100
+          sudo pip3 install black==20.8b1 pygments
+
+      - name: File formatting checks (file_format.sh)
+        run: |
+          bash ./misc/scripts/file_format.sh
+
+      - name: Style checks via clang-format (clang_format.sh)
+        run: |
+          bash ./misc/scripts/clang_format.sh
+
+      - name: Python style checks via black (black_format.sh)
+        run: |
+          bash ./misc/scripts/black_format.sh
+
+  build:
+    runs-on: ${{ matrix.os }}
+    name: 🔧 Build
+    needs: static-checks
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Android
+          - platform: android
+            arch: 'x86_64'
+            gdnative_flags: 'android_arch=x86_64'
+            sconsflags: ''
+            os: 'ubuntu-20.04'
+            cache-name: android-x86_64
+          - platform: android
+            arch: 'arm64'
+            gdnative_flags: 'android_arch=arm64v8'
+            sconsflags: ''
+            os: 'ubuntu-20.04'
+            cache-name: android-arm64
+
+          # iOS
+          - platform: ios
+            arch: 'x86_64'
+            gdnative_flags: 'ios_arch=x86_64'
+            sconsflags: 'ios_simulator=true'
+            os: 'macos-11'
+            cache-name: ios-x86_64-simulator
+          - platform: ios
+            arch: 'arm64'
+            gdnative_flags: 'ios_arch=arm64'
+            sconsflags: ''
+            os: 'macos-11'
+            cache-name: ios-arm64
+
+          # Linux
+          - platform: linux
+            arch: 'x86_32'
+            gdnative_flags: 'bits=32'
+            sconsflags: ''
+            os: 'ubuntu-20.04'
+            cache-name: linux-x86_32
+          - platform: linux
+            arch: 'x86_64'
+            gdnative_flags: 'bits=64'
+            sconsflags: ''
+            os: 'ubuntu-20.04'
+            cache-name: linux-x86_64
+
+          # macOS
+          - platform: macos
+            arch: 'x86_64'
+            gdnative_flags: 'macos_arch=x86_64 bits=64'
+            sconsflags: ''
+            os: 'macos-11'
+            cache-name: macos-x86_64
+          - platform: macos
+            gdnative_flags: 'macos_arch=arm64 bits=64'
+            arch: 'arm64'
+            sconsflags: ''
+            os: 'macos-11'
+            cache-name: macos-arm64
+
+          # Windows
+          - platform: windows
+            arch: 'x86_32'
+            gdnative_flags: 'bits=32'
+            sconsflags: 'use_mingw=yes'
+            os: 'ubuntu-20.04'
+            msvc_arch: amd64_x86
+            cache-name: win-x86_32
+          - platform: windows
+            arch: 'x86_64'
+            gdnative_flags: 'bits=64'
+            sconsflags: 'use_mingw=yes'
+            os: 'ubuntu-20.04'
+            msvc_arch: amd64
+            cache-name: win-x86_64
+
+    env:
+      SCONS_CACHE: ${{ github.workspace }}/.scons-cache/
+      SCONSFLAGS: ${{ matrix.sconsflags }} platform=${{ matrix.platform }} arch=${{ matrix.arch }} --jobs=2
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Setup Godot build cache
+        uses: ./godot-cpp/.github/actions/godot-cache
+        with:
+          cache-name: ${{ matrix.cache-name }}
+        continue-on-error: true
+
+      - name: Install Windows build dependencies
+        if: ${{ matrix.platform == 'windows' }}
+        run: |
+          sudo apt-get update
+          sudo apt-get install build-essential mingw-w64
+          sudo update-alternatives --set i686-w64-mingw32-gcc /usr/bin/i686-w64-mingw32-gcc-posix
+          sudo update-alternatives --set i686-w64-mingw32-g++ /usr/bin/i686-w64-mingw32-g++-posix
+          sudo update-alternatives --set x86_64-w64-mingw32-gcc /usr/bin/x86_64-w64-mingw32-gcc-posix
+          sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix
+          dpkg -l | grep ii | grep mingw
+          update-alternatives --get-selections | grep mingw
+
+      - name: Install Linux build dependencies
+        if: ${{ matrix.platform == 'linux' }}
+        run: |
+          sudo apt-get install build-essential gcc-multilib g++-multilib
+
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+          architecture: 'x64'
+
+      - name: Configuring Python packages
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons
+          python --version
+          scons --version
+          cmake --version
+
+      - name: Compile Extension - template_debug - ${{ matrix.platform }} - ${{ matrix.arch }}
+        run: |
+          scons target=template_debug generate_bindings=yes
+
+      - name: Compile Extension - template_release - ${{ matrix.platform }} - ${{ matrix.arch }}
+        run: |
+          scons target=template_release
+
+      - name: Compile GDNative - release ${{ matrix.platform }} - ${{ matrix.arch }}
+        run: |
+          scons target=release generate_bindings=yes ${{ matrix.gdnative_flags }} godot_version=3
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: ${{ github.job }}-${{ matrix.platform }}-${{ matrix.arch }}
+          path: |
+            bin/
+            !bin/thirdparty/
+
+  package:
+    name: 📦 Package
+    needs: build
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - uses: actions/download-artifact@v3
+        with:
+          path: artifacts
+
+      - name: Bundle licenses.
+        run: |
+          cp LICENSE artifacts/LICENSE.webrtc-native
+          cp thirdparty/libdatachannel/LICENSE artifacts/LICENSE.libdatachannel
+          cp thirdparty/openssl/LICENSE.txt artifacts/LICENSE.openssl
+          cp thirdparty/libdatachannel/deps/libjuice/LICENSE artifacts/LICENSE.libjuice
+          cp thirdparty/libdatachannel/deps/usrsctp/LICENSE.md artifacts/LICENSE.usrsctp
+          cp thirdparty/libdatachannel/deps/libsrtp/LICENSE artifacts/LICENSE.libsrtp
+          cp thirdparty/libdatachannel/deps/json/LICENSE.MIT artifacts/LICENSE.json
+          cp thirdparty/libdatachannel/deps/plog/LICENSE artifacts/LICENSE.plog
+
+      - name: Package artifacts for release
+        env:
+          DESTINATION: "release"
+        run: |
+          mkdir release
+
+          VERSION="extension" TYPE="webrtc" ./misc/scripts/package_release.sh
+          VERSION="gdnative" TYPE="webrtc" ./misc/scripts/package_release.sh
+
+          ls -R release
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: godot-webrtc-extension
+          path: release/*-extension-*.zip
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: godot-webrtc-gdnative
+          path: release/*-gdnative-*.zip
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@ bin/*
 *.lib
 .sconsign.dblite
 *.obj
+*.swp
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +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 "libdatachannel"]
+	path = thirdparty/libdatachannel
+	url = https://github.com/paullouisageneau/libdatachannel.git
+[submodule "openssl"]
+	path = thirdparty/openssl
+	url = https://github.com/openssl/openssl.git
--- a/README.md
+++ b/README.md
@@ -0,0 +1,48 @@
+# GDNative WebRTC plugin for Godot
+
+## Getting Started
+
+| **Download latest binary version** | [**GitHub**](https://github.com/godotengine/webrtc-native/releases) |
+| --- | --- |
+
+### Compiling
+
+Clone this repository with the following command to checkout all the dependencies: [godot-cpp](https://github.com/godotengine/godot-cpp), [openssl](https://www.openssl.org/) and [libdatachannel](https://github.com/paullouisageneau/libdatachannel) (and sub-dependencies).
+
+```
+$ git clone --recurse-submodules https://github.com/godotengine/webrtc-native.git
+```
+
+If you already checked out the branch use the following commands to update the dependencies:
+
+```
+$ 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:
+
+```
+$ scons platform=<your platform>
+```
+
+This will build all the required dependencies into a single shared library.
+
+To build the GDNative version of the plugin (Godot 3.x) run the following command instead:
+
+```
+$ scons platform=<your platform> godot_version=3
+```
+
+> Replace `<your platform>` with either `windows`, `linux`, `osx`, `android`, or `ios`.
+
+> Include `target=release` or `target=debug` for release or debug build (default is `debug`).
+
+The resulting library and associated `tres` or `gdextension` will be created in `bin/[extension|gdnative]/webrtc[_debug]` depending on the `target` and `godot_version`.
+
+You simply need to copy that folder to the root folder of your project. Note that you will have to build the library for all the desired export platforms.
+
+### License
+
+The `webrtc-native` plugin is licensed under the MIT license (see [LICENSE](https://github.com/godotengine/webrtc-native/blob/master/LICENSE)), while `libdatachannel` and its dependencies are licensed under other permissive open source licences. Please see [`thirdparty/README.md`](thirdparty/README.md) for more informations.
--- a/238
+++ b/238
@@ -1,143 +1,165 @@
 #!python

-import os, sys, platform, json
+import os, sys, platform, json, subprocess
+
+import builders


 def add_sources(sources, dirpath, extension):
-  for f in os.listdir(dirpath):
-      if f.endswith('.' + extension):
-          sources.append(dirpath + '/' + f)
+    for f in os.listdir(dirpath):
+        if f.endswith("." + extension):
+            sources.append(dirpath + "/" + f)
+
+
+def replace_flags(flags, replaces):
+    for k, v in replaces.items():
+        if k in flags:
+            flags[flags.index(k)] = v


 env = Environment()
-host_platform = platform.system()
-target_platform = ARGUMENTS.get('p', ARGUMENTS.get('platform', 'linux'))
-target_arch = ARGUMENTS.get('a', ARGUMENTS.get('arch', '64'))
-# default to debug build, must be same setting as used for cpp_bindings
-target = ARGUMENTS.get('target', 'debug')
-# Local dependency paths, adapt them to your setup
-godot_headers = ARGUMENTS.get('headers', '../godot_headers')
-godot_cpp = ARGUMENTS.get('godot-cpp', '../godot-cpp')
-result_path = 'bin'
-result_name = 'webrtc_native'
+opts = Variables(["customs.py"], ARGUMENTS)
+opts.Add(EnumVariable("godot_version", "The Godot target version", "4", ["3", "4"]))
+opts.Update(env)

-if target_platform == 'linux':
-    result_name += '.linux.' + target + '.' + target_arch
+if env["godot_version"] == "3":
+    if "platform" in ARGUMENTS and ARGUMENTS["platform"] == "macos":
+        ARGUMENTS["platform"] = "osx"  # compatibility with old osx name

-    env['CXX']='g++'
-    if ARGUMENTS.get('use_llvm', 'no') == 'yes':
-        env['CXX'] = 'clang++'
+    scons_cache_path = os.environ.get("SCONS_CACHE")
+    if scons_cache_path is not None:
+        CacheDir(scons_cache_path)
+        Decider("MD5")

-    env.Append(CCFLAGS = [ '-fPIC', '-g', '-O3', '-std=c++14', '-Wwrite-strings' ])
+    env = SConscript("godot-cpp-3.x/SConstruct")

-    if target_arch == '32':
-        env.Append(CCFLAGS = [ '-m32' ])
-        env.Append(LINKFLAGS = [ '-m32' ])
-    elif target_arch == '64':
-        env.Append(CCFLAGS = [ '-m64' ])
-        env.Append(LINKFLAGS = [ '-m64' ])
+    # 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",
+    })

-elif target_platform == 'windows':
-    # This makes sure to keep the session environment variables on windows,
-    # that way you can run scons in a vs 2017 prompt and it will find all the required tools
-    if (target_arch == '64'):
-        env = Environment(ENV = os.environ, TARGET_ARCH='amd64')
-    else:
-        env = Environment(ENV = os.environ, TARGET_ARCH='x86')
+    env = env.Clone()

-    result_name += '.windows.' + target + '.' + target_arch
+    if env["target"] == "debug":
+        env.Append(CPPDEFINES=["DEBUG_ENABLED"])

-    if host_platform == 'Windows':
-        #result_name += '.lib'
+    if env["platform"] == "windows" and env["use_mingw"]:
+        env.Append(LINKFLAGS=["-static-libgcc"])

-        env.Append(LINKFLAGS = [ '/WX' ])
-        if target == 'debug':
-            env.Append(CCFLAGS = ['/EHsc', '/D_DEBUG', '/MDd' ])
-        else:
-            env.Append(CCFLAGS = ['/O2', '/EHsc', '/DNDEBUG', '/MD' ])
-    else:
-        if target_arch == '32':
-            env['CXX']='i686-w64-mingw32-g++'
-        elif target_arch == '64':
-            env['CXX']='x86_64-w64-mingw32-g++'
+    if env["platform"] == "osx":
+        env["platform"] = "macos"  # compatibility with old osx name
+        ARGUMENTS["platform"] = "macos"

-        env.Append(CCFLAGS = [ '-g', '-O3', '-std=c++14', '-Wwrite-strings' ])
-        env.Append(LINKFLAGS = [ '--static', '-Wl,--no-undefined', '-static-libgcc', '-static-libstdc++' ])
-
-elif target_platform == 'osx':
-    if ARGUMENTS.get('use_llvm', 'no') == 'yes':
-        env['CXX'] = 'clang++'
-
-    # Only 64-bits is supported for OS X
-    target_arch = '64'
-    result_name += '.osx.' + target + '.' + target_arch
-
-    env.Append(CCFLAGS = [ '-g','-O3', '-std=c++14', '-arch', 'x86_64' ])
-    env.Append(LINKFLAGS = [ '-arch', 'x86_64', '-framework', 'Cocoa', '-Wl,-undefined,dynamic_lookup' ])
+    # Normalize suffix
+    if env["platform"] in ["windows", "linux"]:
+        env["arch"] = "x86_32" if env["bits"] == "32" else "x86_64"
+        env["arch_suffix"] = env["arch"]
+    elif env["platform"] == "macos":
+        env["arch"] = env["macos_arch"]
+        env["arch_suffix"] = env["arch"]
+    elif env["platform"] == "ios":
+        env["arch"] = "arm32" if env["ios_arch"] == "armv7" else env["ios_arch"]
+        env["arch_suffix"] = env["ios_arch"] + (".simulator" if env["ios_simulator"] else "")
+    elif env["platform"] == "android":
+        env["arch"] = {
+            "armv7": "arm32",
+            "arm64v8": "arm64",
+            "x86": "x86_32",
+            "x86_64": "x86_64",
+        }[env["android_arch"]]
+        env["arch_suffix"] = env["arch"]

+    target_compat = "template_" + env["target"]
+    env["suffix"] = ".{}.{}.{}".format(env["platform"], target_compat, env["arch_suffix"])
+    env["debug_symbols"] = False
 else:
-    print("No valid target platform selected.")
-    sys.exit(1)
+    ARGUMENTS["ios_min_version"] = "11.0"
+    env = SConscript("godot-cpp/SConstruct").Clone()

-# Godot CPP bindings
-env.Append(CPPPATH=[godot_headers])
-env.Append(CPPPATH=[godot_cpp + '/include', godot_cpp + '/include/core', godot_cpp + '/include/gen'])
-env.Append(LIBPATH=[godot_cpp + '/bin'])
-env.Append(LIBS=['godot-cpp'])
+# Should probably go to upstream godot-cpp.
+# We let SCons build its default ENV as it includes OS-specific things which we don't
+# want to have to pull in manually.
+# 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.
+    env["ENV"]["TERM"] = os.environ["TERM"]

-# WebRTC stuff
-webrtc_dir = "webrtc"
-lib_name = 'libwebrtc_full'
-lib_path = webrtc_dir + '/lib'
+# Patch mingw SHLIBSUFFIX.
+if env["platform"] == "windows" and env["use_mingw"]:
+    env["SHLIBSUFFIX"] = ".dll"

-if target_arch == '64':
-    lib_path += '/x64'
-elif target_arch == '32':
-    lib_path += '/x86'
+opts.Update(env)

-if target == 'debug':
-    lib_path += '/Debug'
+target = env["target"]
+if env["godot_version"] == "3":
+    result_path = os.path.join("bin", "gdnative", "webrtc" if env["target"] == "release" else "webrtc_debug")
 else:
-    lib_path += '/Release'
+    result_path = os.path.join("bin", "extension", "webrtc")

-env.Append(CPPPATH=[webrtc_dir + "/include"])
-#env.Append(CPPPATH=[lib_path])
+# Dependencies
+env.Append(BUILDERS={
+    "BuildOpenSSL": env.Builder(action=builders.ssl_action, emitter=builders.ssl_emitter),
+    "BuildLibDataChannel": env.Builder(action=builders.rtc_action, emitter=builders.rtc_emitter),
+})

-if target_platform == "linux":
-    env.Append(LIBS=[lib_name])
-    env.Append(LIBPATH=[lib_path])
-    #env.Append(CCFLAGS=["-std=c++11"])
-    env.Append(CCFLAGS=["-DWEBRTC_POSIX", "-DWEBRTC_LINUX"])
-    env.Append(CCFLAGS=["-DRTC_UNUSED=''", "-DNO_RETURN=''"])
+# SSL
+ssl = env.BuildOpenSSL(env.Dir(builders.get_ssl_build_dir(env)), env.Dir(builders.get_ssl_source_dir(env)))
+env.Depends(ssl, [env.File("builders.py"), env.File(builders.get_ssl_source_dir(env) + "/VERSION.dat")])
+env.NoCache(ssl) # Needs refactoring to properly cache generated headers.

-elif target_platform == "windows":
-    # Mostly VisualStudio
-    if env["CC"] == "cl":
-        env.Append(CCFLAGS=["/DWEBRTC_WIN", "/DWIN32_LEAN_AND_MEAN", "/DNOMINMAX", "/DRTC_UNUSED=", "/DNO_RETURN="])
-        env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in ["secur32", "advapi32", "winmm", lib_name]])
-        env.Append(LIBPATH=[lib_path])
-    # Mostly "gcc"
-    else:
-        env.Append(CCFLAGS=["-DWINVER=0x0603", "-D_WIN32_WINNT=0x0603", "-DWEBRTC_WIN", "-DWIN32_LEAN_AND_MEAN", "-DNOMINMAX", "-DRTC_UNUSED=", "-DNO_RETURN="])
-        env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in ["secur32", "advapi32", "winmm", lib_name]])
-        env.Append(LIBPATH=[lib_path])
+env.Prepend(CPPPATH=[builders.get_ssl_include_dir(env)])
+env.Prepend(LIBPATH=[builders.get_ssl_build_dir(env)])
+env.Append(LIBS=[builders.get_ssl_libs(env)])

-elif target_platform == "osx":
-    env.Append(LIBS=[lib_name])
-    env.Append(LIBPATH=[lib_path])
+# RTC
+rtc = env.BuildLibDataChannel(env.Dir(builders.get_rtc_build_dir(env)), [env.Dir(builders.get_rtc_source_dir(env))] + ssl)
+env.Depends(rtc, [env.File("builders.py"), env.File(builders.get_rtc_source_dir(env) + "/CMakeLists.txt")])

-# Godot CPP bindings
-env.Append(CPPPATH=[godot_headers])
-env.Append(CPPPATH=[godot_cpp + '/include', godot_cpp + '/include/core', godot_cpp + '/include/gen'])
-env.Append(LIBPATH=[godot_cpp + '/bin'])
-env.Append(LIBS=['godot-cpp'])
+env.Append(LIBPATH=[builders.get_rtc_build_dir(env)])
+env.Append(CPPPATH=[builders.get_rtc_include_dir(env)])
+env.Prepend(LIBS=[builders.get_rtc_libs(env)])

 # Our includes and sources
-env.Append(CPPPATH=['src/'])
+env.Append(CPPPATH=["src/"])
+env.Append(CPPDEFINES=["RTC_STATIC"])
 sources = []
-add_sources(sources, 'src/', 'cpp')
-add_sources(sources, 'src/net/', 'cpp')
+sources.append(
+    [
+        "src/WebRTCLibDataChannel.cpp",
+        "src/WebRTCLibPeerConnection.cpp",
+    ]
+)
+if env["godot_version"] == "4":
+    sources.append("src/init_gdextension.cpp")
+else:
+    env.Append(CPPDEFINES=["GDNATIVE_WEBRTC"])
+    sources.append("src/init_gdnative.cpp")
+    add_sources(sources, "src/net/", "cpp")
+
+env.Depends(sources, [builders.get_ssl_libs(env), builders.get_rtc_libs(env)])

 # Make the shared library
-library = env.SharedLibrary(target=os.path.join(result_path, result_name), source=sources)
+result_name = "webrtc_native{}{}".format(env["suffix"], env["SHLIBSUFFIX"])
+env.Depends(sources, ssl)
+
+if env["platform"] == "windows" and env["use_mingw"]:
+    env.Append(LIBS=["iphlpapi", "ws2_32", "bcrypt"])
+
+library = env.SharedLibrary(target=os.path.join(result_path, "lib", result_name), source=sources)
 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"],
+    })
+else:
+    extfile = env.InstallAs(os.path.join(result_path, "webrtc.gdextension"), "misc/webrtc.gdextension")
+Default(extfile)
--- a/bin/thirdparty/.gitignore
+++ b/bin/thirdparty/.gitignore
--- a/builders.py
+++ b/builders.py
@@ -0,0 +1,247 @@
+import os
+from SCons.Defaults import Mkdir
+from SCons.Script import Environment
+
+
+def get_android_api(env):
+    return env["android_api_level"] if int(env["android_api_level"]) > 28 else "28"
+
+
+def get_deps_dir(env):
+    return env.Dir("#thirdparty").abspath
+
+
+def get_deps_build_dir(env):
+    return env.Dir("#bin/thirdparty").abspath + "/{}.{}.dir".format(env["suffix"][1:], "RelWithDebInfo" if env["debug_symbols"] else "Release")
+
+
+def get_rtc_source_dir(env):
+    return get_deps_dir(env) + "/libdatachannel"
+
+
+def get_rtc_build_dir(env):
+    return get_deps_build_dir(env) + "/libdatachannel"
+
+
+def get_rtc_include_dir(env):
+    return get_rtc_source_dir(env) + "/include"
+
+
+def get_rtc_libs(env):
+    bdir = get_rtc_build_dir(env)
+    libs = [
+        "libdatachannel-static.a",
+        "deps/libjuice/libjuice-static.a",
+        "deps/libsrtp/libsrtp2.a",
+        "deps/usrsctp/usrsctplib/libusrsctp.a"
+    ]
+    return [env.File(bdir + "/" + lib) for lib in libs]
+
+
+def get_ssl_source_dir(env):
+    return get_deps_dir(env) + "/openssl"
+
+
+def get_ssl_build_dir(env):
+    return get_deps_build_dir(env) + "/openssl"
+
+
+def get_ssl_install_dir(env):
+    return get_ssl_build_dir(env) + "/dest"
+
+
+def get_ssl_include_dir(env):
+    return get_ssl_install_dir(env) + "/include"
+
+
+def get_ssl_libs(env):
+    bdir = get_ssl_build_dir(env)
+    return [env.File(bdir + "/" + lib) for lib in ["libssl.a", "libcrypto.a"]]
+
+
+def ssl_emitter(target, source, env):
+    return get_ssl_libs(env), source
+
+
+def ssl_action(target, source, env):
+    build_dir = get_ssl_build_dir(env)
+    source_dir = source[0].abspath
+
+    ssl_env = env.Clone()
+    install_dir = get_ssl_install_dir(env)
+    args = [
+        "no-ssl3",
+        "no-weak-ssl-ciphers",
+        "no-legacy",
+        "--prefix=%s" % install_dir,
+        "--openssldir=%s" % install_dir,
+    ]
+    if env["debug_symbols"]:
+        args.append("-d")
+
+    if env["platform"] != "windows":
+        args.append("no-shared")  # Windows "app" doesn't like static-only builds.
+    if env["platform"] == "linux":
+        if env["arch"] == "x86_32":
+            args.extend(["linux-x86"])
+        else:
+            args.extend(["linux-x86_64"])
+
+    elif env["platform"] == "android":
+        args.extend([
+            {
+                "arm64": "android-arm64",
+                "arm32": "android-arm",
+                "x86_32": "android-x86",
+                "x86_64": "android-x86_64",
+            }[env["arch"]],
+            "-D__ANDROID_API__=%s" % get_android_api(env),
+        ])
+        # 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 rtc_emitter(target, source, env):
+    return get_rtc_libs(env), source
+
+
+def rtc_action(target, source, env):
+    build_dir = get_rtc_build_dir(env)
+    source_dir = source[0].abspath
+    args = [
+        "cmake",
+        "-B",
+        build_dir,
+        "-DUSE_NICE=0",
+        "-DNO_WEBSOCKET=1",
+        #"-DNO_MEDIA=1", # Windows builds fail without it.
+        "-DNO_EXAMPLES=1",
+        "-DNO_TESTS=1",
+        "-DOPENSSL_USE_STATIC_LIBS=1",
+        "-DOPENSSL_INCLUDE_DIR=%s" % get_ssl_include_dir(env),
+        "-DOPENSSL_SSL_LIBRARY=%s/libssl.a" % get_ssl_build_dir(env),
+        "-DOPENSSL_CRYPTO_LIBRARY=%s/libcrypto.a" % get_ssl_build_dir(env),
+        "-DCMAKE_BUILD_TYPE=%s" % ("RelWithDebInfo" if env["debug_symbols"] else "Release"),
+    ]
+    if env["platform"] == "android":
+        abi = {
+            "arm64": "arm64-v8a",
+            "arm32": "armeabi-v7a",
+            "x86_32": "x86",
+            "x86_64": "x86_64",
+        }[env["arch"]]
+        args.extend([
+            "-DCMAKE_SYSTEM_NAME=Android",
+            "-DCMAKE_SYSTEM_VERSION=%s" % get_android_api(env),
+            "-DCMAKE_ANDROID_ARCH_ABI=%s" % abi,
+            "-DANDROID_ABI=%s" % abi,
+            "-DCMAKE_TOOLCHAIN_FILE=%s/build/cmake/android.toolchain.cmake" % os.environ.get("ANDROID_NDK_ROOT", ""),
+            "-DCMAKE_ANDROID_STL_TYPE=c++_static",
+        ])
+    elif env["platform"] == "linux":
+        if env["arch"] == "x86_32":
+            args.extend([
+                "-DCMAKE_C_FLAGS=-m32",
+                "-DCMAKE_CXX_FLAGS=-m32"
+            ])
+        else:
+            args.extend([
+                "-DCMAKE_C_FLAGS=-m64",
+                "-DCMAKE_CXX_FLAGS=-m64"
+            ])
+    elif env["platform"] == "macos":
+        if env["macos_deployment_target"] != "default":
+            args.extend(["-DCMAKE_OSX_DEPLOYMENT_TARGET=%s" % env["macos_deployment_target"]])
+        if env["arch"] == "x86_64":
+            args.extend(["-DCMAKE_OSX_ARCHITECTURES=x86_64"])
+        elif env["arch"] == "arm64":
+            args.extend(["-DCMAKE_OSX_ARCHITECTURES=arm64"])
+        else:
+            raise ValueError("OSX architecture not supported: %s" % env["arch"])
+    elif env["platform"] == "ios":
+        if env["arch"] == "universal":
+            raise ValueError("iOS architecture not supported: %s" % env["arch"])
+        args.extend([
+            "-DCMAKE_SYSTEM_NAME=iOS",
+            "-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0",
+            "-DCMAKE_OSX_ARCHITECTURES=%s" % env["arch"],
+        ])
+        if env["ios_simulator"]:
+                args.extend(["-DCMAKE_OSX_SYSROOT=iphonesimulator"])
+    elif env["platform"] == "windows":
+        args.extend(["-DOPENSSL_ROOT_DIR=%s" % get_ssl_build_dir(env)])
+        if env["arch"] == "x86_32":
+            if env["use_mingw"]:
+                args.extend([
+                    "-G",
+                    "Unix Makefiles",
+                    "-DCMAKE_C_COMPILER=i686-w64-mingw32-gcc",
+                    "-DCMAKE_CXX_COMPILER=i686-w64-mingw32-g++",
+                    "-DCMAKE_SYSTEM_NAME=Windows",
+                ])
+        else:
+            if env["use_mingw"]:
+                args.extend([
+                    "-G",
+                    "Unix Makefiles",
+                    "-DCMAKE_C_COMPILER=x86_64-w64-mingw32-gcc",
+                    "-DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-g++",
+                    "-DCMAKE_SYSTEM_NAME=Windows"
+                ])
+
+    args.append(source_dir)
+    jobs = env.GetOption("num_jobs")
+    rtc_env = env.Clone()
+    rtc_env.Execute([
+            " ".join(['"%s"' % a for a in args]),
+            "cmake --build %s -t datachannel-static -j%s" % (build_dir, jobs)
+        ]
+    )
+    return None
--- a/1
+++ b/1
--- a/godot-cpp-3.x
+++ b/godot-cpp-3.x
--- a/misc/scripts/black_format.sh
+++ b/misc/scripts/black_format.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+
+# This script runs black on all Python files in the repo.
+
+set -uo pipefail
+
+# Apply black.
+echo -e "Formatting Python files..."
+PY_FILES=$(find \( -path "./.git" \
+                -o -path "./webrtc" \
+                -o -path "./godot-cpp" \
+                \) -prune \
+                -o \( -name "SConstruct" \
+                -o -name "SCsub" \
+                -o -name "*.py" \
+                \) -print)
+black -l 120 $PY_FILES
+
+git diff > patch.patch
+
+# If no patch has been generated all is OK, clean up, and exit.
+if [ ! -s patch.patch ] ; then
+    printf "Files in this commit comply with the black style rules.\n"
+    rm -f patch.patch
+    exit 0
+fi
+
+# A patch has been created, notify the user, clean up, and exit.
+printf "\n*** The following differences were found between the code "
+printf "and the formatting rules:\n\n"
+cat patch.patch
+printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+rm -f patch.patch
+exit 1
--- a/misc/scripts/clang_format.sh
+++ b/misc/scripts/clang_format.sh
@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+
+# This script runs clang-format and fixes copyright headers on all relevant files in the repo.
+# This is the primary script responsible for fixing style violations.
+
+set -uo pipefail
+IFS=$'\n\t'
+
+CLANG_FORMAT_FILE_EXTS=(".c" ".h" ".cpp" ".hpp" ".cc" ".hh" ".cxx" ".m" ".mm" ".inc" ".java" ".glsl")
+
+# Loops through all text files tracked by Git.
+git grep -zIl '' |
+while IFS= read -rd '' f; do
+    # Exclude some files.
+    if [[ "$f" == "thirdparty"* ]]; then
+        continue
+    elif [[ "$f" == "platform/android/java/lib/src/com/google"* ]]; then
+        continue
+    elif [[ "$f" == *"-so_wrap."* ]]; 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
+done
+
+git diff > patch.patch
+
+# If no patch has been generated all is OK, clean up, and exit.
+if [ ! -s patch.patch ] ; then
+    printf "Files in this commit comply with the clang-format style rules.\n"
+    rm -f patch.patch
+    exit 0
+fi
+
+# A patch has been created, notify the user, clean up, and exit.
+printf "\n*** The following differences were found between the code "
+printf "and the formatting rules:\n\n"
+cat patch.patch
+printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+rm -f patch.patch
+exit 1
--- a/misc/scripts/copyright_headers.py
+++ b/misc/scripts/copyright_headers.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+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.                */
+/*************************************************************************/
+"""
+
+fname = sys.argv[1]
+
+# Handle replacing $filename with actual filename and keep alignment
+fsingle = fname.strip()
+if fsingle.find("/") != -1:
+    fsingle = fsingle[fsingle.rfind("/") + 1 :]
+rep_fl = "$filename"
+rep_fi = fsingle
+len_fl = len(rep_fl)
+len_fi = len(rep_fi)
+# Pad with spaces to keep alignment
+if len_fi < len_fl:
+    for x in range(len_fl - len_fi):
+        rep_fi += " "
+elif len_fl < len_fi:
+    for x in range(len_fi - len_fl):
+        rep_fl += " "
+if header.find(rep_fl) != -1:
+    text = header.replace(rep_fl, rep_fi)
+else:
+    text = header.replace("$filename", fsingle)
+text += "\n"
+
+# We now have the proper header, so we want to ignore the one in the original file
+# and potentially empty lines and badly formatted lines, while keeping comments that
+# come after the header, and then keep everything non-header unchanged.
+# To do so, we skip empty lines that may be at the top in a first pass.
+# In a second pass, we skip all consecutive comment lines starting with "/*",
+# then we can append the rest (step 2).
+
+fileread = open(fname.strip(), "r")
+line = fileread.readline()
+header_done = False
+
+while line.strip() == "":  # Skip empty lines at the top
+    line = fileread.readline()
+
+if line.find("/**********") == -1:  # Godot header starts this way
+    # Maybe starting with a non-Godot comment, abort header magic
+    header_done = True
+
+while not header_done:  # Handle header now
+    if line.find("/*") != 0:  # No more starting with a comment
+        header_done = True
+        if line.strip() != "":
+            text += line
+    line = fileread.readline()
+
+while line != "":  # Dump everything until EOF
+    text += line
+    line = fileread.readline()
+
+fileread.close()
+
+# Write
+filewrite = open(fname.strip(), "w")
+filewrite.write(text)
+filewrite.close()
--- a/misc/scripts/file_format.sh
+++ b/misc/scripts/file_format.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+
+# This script ensures proper POSIX text file formatting and a few other things.
+# This is supplementary to clang_format.sh and black_format.sh, but should be
+# run before them.
+
+# We need dos2unix and recode.
+if [ ! -x "$(command -v dos2unix)" -o ! -x "$(command -v recode)" ]; then
+    printf "Install 'dos2unix' and 'recode' to use this script.\n"
+fi
+
+set -uo pipefail
+IFS=$'\n\t'
+
+# Loops through all text files tracked by Git.
+git grep -zIl '' |
+while IFS= read -rd '' f; do
+    # Exclude some types of files.
+    if [[ "$f" == "webrtc"* ]]; then
+        continue
+    elif [[ "$f" == "godot-cpp"* ]]; then
+        continue
+    elif [[ "$f" == "misc/patches"* ]]; then
+        continue
+    fi
+    # Ensure that files are UTF-8 formatted.
+    recode UTF-8 "$f" 2> /dev/null
+    # Ensure that files have LF line endings and do not contain a BOM.
+    dos2unix "$f" 2> /dev/null
+    # Remove trailing space characters and ensures that files end
+    # with newline characters. -l option handles newlines conveniently.
+    perl -i -ple 's/\s*$//g' "$f"
+done
+
+git diff > patch.patch
+
+# If no patch has been generated all is OK, clean up, and exit.
+if [ ! -s patch.patch ] ; then
+    printf "Files in this commit comply with the formatting rules.\n"
+    rm -f patch.patch
+    exit 0
+fi
+
+# A patch has been created, notify the user, clean up, and exit.
+printf "\n*** The following differences were found between the code "
+printf "and the formatting rules:\n\n"
+cat patch.patch
+printf "\n*** Aborting, please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\n"
+rm -f patch.patch
+exit 1
--- a/misc/scripts/package_release.sh
+++ b/misc/scripts/package_release.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -e
+set -x
+
+ARTIFACTS=${ARTIFACTS:-"artifacts"}
+DESTINATION=${DESTIONATION:-"release"}
+VERSION=${VERSION:-"extension"}
+TYPE=${TYPE:-"webrtc"}
+
+mkdir -p ${DESTINATION}
+ls -R ${DESTINATION}
+
+DESTDIR="${DESTINATION}/${VERSION}/${TYPE}"
+
+mkdir -p ${DESTDIR}/lib
+
+find "${ARTIFACTS}" -wholename "*/${VERSION}/${TYPE}/lib/*" | xargs cp -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
+    find "${ARTIFACTS}" -wholename "*/${VERSION}/${TYPE}/${TYPE}.tres" | head -n 1 | xargs cp -t "${DESTDIR}/"
+fi
+
+CURDIR=$(pwd)
+cd "${DESTINATION}/${VERSION}"
+zip -r ../godot-${VERSION}-${TYPE}.zip ${TYPE}
+cd "$CURDIR"
+
+ls -R ${DESTINATION}
--- a/misc/webrtc.gdextension
+++ b/misc/webrtc.gdextension
@@ -0,0 +1,27 @@
+[configuration]
+
+entry_symbol = "webrtc_extension_init"
+
+[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.x86_64 = "res://webrtc/lib/libwebrtc_native.macos.template_debug.x86_64.dylib"
+macos.debug.arm64 = "res://webrtc/lib/libwebrtc_native.macos.template_debug.arm64.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.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.x86_64 = "res://webrtc/lib/libwebrtc_native.macos.template_release.x86_64.dylib"
+macos.release.arm64 = "res://webrtc/lib/libwebrtc_native.macos.template_release.arm64.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"
--- a/misc/webrtc.tres
+++ b/misc/webrtc.tres
@@ -0,0 +1,26 @@
+[gd_resource type="GDNativeLibrary" format=2]
+
+[resource]
+singleton = true
+reloadable = false
+entry/OSX.64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.osx.{TARGET}.x86_64.dylib"
+entry/OSX.arm64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.osx.{TARGET}.arm64.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/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"
+entry/iOS.arm64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.ios.{TARGET}.arm64.dylib"
+entry/iOS.x86_64 = "res://{GDNATIVE_PATH}/lib/libwebrtc_native.ios.{TARGET}.x86_64.simulator.dylib"
+dependency/Windows.64 = [  ]
+dependency/Windows.32 = [  ]
+dependency/X11.64 = [  ]
+dependency/X11.32 = [  ]
+dependency/Server.64 = [  ]
+dependency/Server.32 = [  ]
+dependency/Android.armeabi-v7a = [  ]
+dependency/Android.arm64-v8a = [  ]
--- a/src/GodotCreateSessionDescriptionObserver.cpp
+++ b/src/GodotCreateSessionDescriptionObserver.cpp
@@ -1,16 +0,0 @@
-#include "WebRTCLibPeer.hpp"
-
-using namespace godot_webrtc;
-
-WebRTCLibPeer::GodotCSDO::GodotCSDO(WebRTCLibPeer *parent) {
-	this->parent = parent;
-}
-
-void WebRTCLibPeer::GodotCSDO::OnSuccess(webrtc::SessionDescriptionInterface *desc) {
-	// serialize this offer and send it to the remote peer:
-	std::string sdp; // sdp = session description protocol
-	desc->ToString(&sdp);
-	parent->queue_signal("offer_created", 2, desc->type().c_str(), sdp.c_str());
-};
-
-void WebRTCLibPeer::GodotCSDO::OnFailure(const std::string &error){};
--- a/src/GodotDataChannelObserver.cpp
+++ b/src/GodotDataChannelObserver.cpp
@@ -1,19 +0,0 @@
-#include "WebRTCLibPeer.hpp"
-
-using namespace godot_webrtc;
-
-WebRTCLibPeer::GodotDCO::GodotDCO(WebRTCLibPeer *parent) {
-	this->parent = parent;
-}
-
-void WebRTCLibPeer::GodotDCO::OnMessage(const webrtc::DataBuffer &buffer) {
-	const uint8_t *data = buffer.data.data<uint8_t>();
-	uint8_t *memory_controlled_buffer = new uint8_t[buffer.data.size()];
-
-	std::copy(data, data + buffer.data.size(), memory_controlled_buffer);
-	parent->queue_packet(memory_controlled_buffer, buffer.data.size());
-};
-
-void WebRTCLibPeer::GodotDCO::OnStateChange(){};
-
-void WebRTCLibPeer::GodotDCO::OnBufferedAmountChange(uint64_t previous_amount){};
--- a/src/GodotPeerConnectionObserver.cpp
+++ b/src/GodotPeerConnectionObserver.cpp
@@ -1,46 +0,0 @@
-#include "WebRTCLibPeer.hpp"
-
-using namespace godot_webrtc;
-
-WebRTCLibPeer::GodotPCO::GodotPCO(WebRTCLibPeer *parent) {
-	this->parent = parent;
-}
-
-void WebRTCLibPeer::GodotPCO::OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) {
-}
-
-void WebRTCLibPeer::GodotPCO::OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
-}
-
-void WebRTCLibPeer::GodotPCO::OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
-}
-
-void WebRTCLibPeer::GodotPCO::OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
-}
-
-void WebRTCLibPeer::GodotPCO::OnRenegotiationNeeded() {
-}
-
-void WebRTCLibPeer::GodotPCO::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) {
-}
-
-void WebRTCLibPeer::GodotPCO::OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) {
-}
-
-void WebRTCLibPeer::GodotPCO::OnIceCandidate(const webrtc::IceCandidateInterface *candidate) {
-	// Serialize the candidate and send it to the remote peer:
-
-	godot::Dictionary candidateSDP;
-
-	godot::String candidateSdpMidName = candidate->sdp_mid().c_str();
-	int candidateSdpMlineIndexName = candidate->sdp_mline_index();
-	std::string sdp;
-	candidate->ToString(&sdp);
-	godot::String candidateSdpName = sdp.c_str();
-
-	parent->queue_signal("new_ice_candidate",
-			3,
-			candidateSdpMidName,
-			candidateSdpMlineIndexName,
-			candidateSdpName);
-}
--- a/src/GodotSetSessionDescriptionObserver.cpp
+++ b/src/GodotSetSessionDescriptionObserver.cpp
@@ -1,11 +0,0 @@
-#include "WebRTCLibPeer.hpp"
-
-using namespace godot_webrtc;
-
-WebRTCLibPeer::GodotSSDO::GodotSSDO(WebRTCLibPeer *parent) {
-	this->parent = parent;
-}
-
-void WebRTCLibPeer::GodotSSDO::OnSuccess(){};
-
-void WebRTCLibPeer::GodotSSDO::OnFailure(const std::string &error){};
--- a/src/WebRTCLibDataChannel.cpp
+++ b/src/WebRTCLibDataChannel.cpp
@@ -0,0 +1,231 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#include "WebRTCLibDataChannel.hpp"
+
+#ifdef GDNATIVE_WEBRTC
+#include "GDNativeLibrary.hpp"
+#include "NativeScript.hpp"
+#define ERR_UNAVAILABLE Error::ERR_UNAVAILABLE
+#define FAILED Error::FAILED
+#define ERR_INVALID_PARAMETER Error::ERR_INVALID_PARAMETER
+#define OK Error::OK
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <cstring>
+
+using namespace godot;
+using namespace godot_webrtc;
+
+// DataChannel
+WebRTCLibDataChannel *WebRTCLibDataChannel::new_data_channel(std::shared_ptr<rtc::DataChannel> p_channel, bool p_negotiated) {
+	// Invalid channel result in NULL return
+	ERR_FAIL_COND_V(!p_channel, nullptr);
+
+#ifdef GDNATIVE_WEBRTC
+	// Instance a WebRTCDataChannelGDNative object
+	WebRTCDataChannelGDNative *native = WebRTCDataChannelGDNative::_new();
+	// Set our implementation as its script
+	NativeScript *script = NativeScript::_new();
+	script->set_library(detail::get_wrapper<GDNativeLibrary>((godot_object *)gdnlib));
+	script->set_class_name("WebRTCLibDataChannel");
+	native->set_script(script);
+	WebRTCLibDataChannel *out = native->cast_to<WebRTCLibDataChannel>(native);
+#else
+	WebRTCLibDataChannel *out = memnew(WebRTCLibDataChannel);
+#endif
+	// Bind the library data channel to our object.
+	out->bind_channel(p_channel, p_negotiated);
+	return out;
+}
+
+void WebRTCLibDataChannel::bind_channel(std::shared_ptr<rtc::DataChannel> p_channel, bool p_negotiated) {
+	ERR_FAIL_COND(!p_channel);
+
+	channel = p_channel;
+	negotiated = p_negotiated;
+
+	// Binding this should be fine as long as we call close when going out of scope.
+	p_channel->onMessage([this](auto message) {
+		if (std::holds_alternative<rtc::string>(message)) {
+			rtc::string str = std::get<rtc::string>(message);
+			queue_packet(reinterpret_cast<const uint8_t *>(str.c_str()), str.size(), true);
+		} else if (std::holds_alternative<rtc::binary>(message)) {
+			rtc::binary bin = std::get<rtc::binary>(message);
+			queue_packet(reinterpret_cast<const uint8_t *>(&bin[0]), bin.size(), false);
+		} else {
+			ERR_PRINT("Message parsing bug. Unknown message type.");
+		}
+	});
+	p_channel->onOpen([this]() {
+		channel_state = STATE_OPEN;
+	});
+	p_channel->onClosed([this]() {
+		channel_state = STATE_CLOSED;
+	});
+	p_channel->onError([](auto error) {
+		ERR_PRINT("Channel Error: " + String(std::string(error).c_str()));
+	});
+}
+
+void WebRTCLibDataChannel::queue_packet(const uint8_t *data, uint32_t size, bool p_is_string) {
+	mutex->lock();
+
+	std::vector<uint8_t> packet;
+	packet.resize(size);
+	memcpy(&packet[0], data, size);
+	packet_queue.push(QueuedPacket(packet, p_is_string));
+
+	mutex->unlock();
+}
+
+void WebRTCLibDataChannel::_set_write_mode(WriteMode p_mode) {
+	ERR_FAIL_COND(p_mode != WRITE_MODE_TEXT && p_mode != WRITE_MODE_BINARY);
+	write_mode = p_mode;
+}
+
+WebRTCDataChannel::WriteMode WebRTCLibDataChannel::_get_write_mode() const {
+	return write_mode;
+}
+
+bool WebRTCLibDataChannel::_was_string_packet() const {
+	return current_packet.second;
+}
+
+WebRTCDataChannel::ChannelState WebRTCLibDataChannel::_get_ready_state() const {
+	ERR_FAIL_COND_V(!channel, STATE_CLOSED);
+	return channel_state;
+}
+
+String WebRTCLibDataChannel::_get_label() const {
+	ERR_FAIL_COND_V(!channel, "");
+	return channel->label().c_str();
+}
+
+bool WebRTCLibDataChannel::_is_ordered() const {
+	ERR_FAIL_COND_V(!channel, false);
+	return channel->reliability().unordered == false;
+}
+
+int64_t WebRTCLibDataChannel::_get_id() const {
+	ERR_FAIL_COND_V(!channel, -1);
+	return channel->id().value_or(-1);
+}
+
+int64_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;
+}
+
+int64_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;
+}
+
+String WebRTCLibDataChannel::_get_protocol() const {
+	ERR_FAIL_COND_V(!channel, "");
+	return channel->protocol().c_str();
+}
+
+bool WebRTCLibDataChannel::_is_negotiated() const {
+	ERR_FAIL_COND_V(!channel, false);
+	return negotiated;
+}
+
+int64_t WebRTCLibDataChannel::_get_buffered_amount() const {
+	ERR_FAIL_COND_V(!channel, 0);
+	return channel->bufferedAmount();
+}
+
+Error WebRTCLibDataChannel::_poll() {
+	return OK;
+}
+
+void WebRTCLibDataChannel::_close() try {
+	if (channel) {
+		channel->close();
+	}
+} catch (...) {
+}
+
+Error WebRTCLibDataChannel::_get_packet(const uint8_t **r_buffer, int32_t *r_len) {
+	ERR_FAIL_COND_V(packet_queue.empty(), ERR_UNAVAILABLE);
+
+	mutex->lock();
+
+	// Update current packet and pop queue
+	current_packet = packet_queue.front();
+	packet_queue.pop();
+	// Set out buffer and size (buffer will be gone at next get_packet or close)
+	*r_buffer = &current_packet.first[0];
+	*r_len = current_packet.first.size();
+
+	mutex->unlock();
+
+	return OK;
+}
+
+Error WebRTCLibDataChannel::_put_packet(const uint8_t *p_buffer, int64_t p_len) try {
+	ERR_FAIL_COND_V(!channel, FAILED);
+	ERR_FAIL_COND_V(channel->isClosed(), FAILED);
+	if (write_mode == WRITE_MODE_TEXT) {
+		std::string str(p_len, '\x00');
+		std::strncpy(str.data(), (const char *)p_buffer, p_len);
+		channel->send(str);
+	} else if (write_mode == WRITE_MODE_BINARY) {
+		channel->send(reinterpret_cast<const std::byte *>(p_buffer), p_len);
+	} else {
+		ERR_FAIL_V(ERR_INVALID_PARAMETER);
+	}
+	return OK;
+} catch (const std::exception &e) {
+	ERR_PRINT(e.what());
+	ERR_FAIL_V(FAILED);
+}
+
+int64_t WebRTCLibDataChannel::_get_available_packet_count() const {
+	return packet_queue.size();
+}
+
+int64_t WebRTCLibDataChannel::_get_max_packet_size() const {
+	return 16384; // See RFC-8831 section 6.6: https://datatracker.ietf.org/doc/rfc8831/
+}
+
+WebRTCLibDataChannel::WebRTCLibDataChannel() {
+	mutex = new std::mutex;
+}
+
+WebRTCLibDataChannel::~WebRTCLibDataChannel() {
+	_close();
+	channel = nullptr;
+	delete mutex;
+}
--- a/src/WebRTCLibDataChannel.hpp
+++ b/src/WebRTCLibDataChannel.hpp
@@ -0,0 +1,110 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#ifndef WEBRTC_DATA_CHANNEL_H
+#define WEBRTC_DATA_CHANNEL_H
+
+#ifdef GDNATIVE_WEBRTC
+#include <Godot.hpp> // Godot.hpp must go first, or windows builds breaks
+
+#include "net/WebRTCDataChannelNative.hpp"
+#define WebRTCDataChannelExtension WebRTCDataChannelNative
+#if !defined(GDCLASS)
+#define GDCLASS(arg1, arg2) GODOT_CLASS(arg1, arg2)
+#endif
+#else
+#include <godot_cpp/core/binder_common.hpp>
+
+#include <godot_cpp/classes/global_constants_binds.hpp>
+#include <godot_cpp/classes/web_rtc_data_channel_extension.hpp>
+#endif
+
+#include <mutex>
+#include <queue>
+#include <utility>
+
+#include "rtc/rtc.hpp"
+
+namespace godot_webrtc {
+
+class WebRTCLibDataChannel : public godot::WebRTCDataChannelExtension {
+	GDCLASS(WebRTCLibDataChannel, WebRTCDataChannelExtension);
+
+private:
+	using QueuedPacket = std::pair<std::vector<uint8_t>, bool>;
+	std::mutex *mutex;
+	std::queue<QueuedPacket> packet_queue;
+	QueuedPacket current_packet;
+	std::shared_ptr<rtc::DataChannel> channel = nullptr;
+
+	WriteMode write_mode = WRITE_MODE_BINARY;
+	ChannelState channel_state = STATE_CONNECTING;
+	bool negotiated = false;
+
+	void queue_packet(const uint8_t *data, uint32_t size, bool p_is_string);
+	void bind_channel(std::shared_ptr<rtc::DataChannel> p_channel, bool p_negotiated);
+
+protected:
+	static void _bind_methods() {}
+
+public:
+	static WebRTCLibDataChannel *new_data_channel(std::shared_ptr<rtc::DataChannel> p_channel, bool p_negotiated);
+
+	/* PacketPeer */
+	virtual godot::Error _get_packet(const uint8_t **r_buffer, int32_t *r_len) override;
+	virtual godot::Error _put_packet(const uint8_t *p_buffer, int64_t p_len) override;
+	virtual int64_t _get_available_packet_count() const override;
+	virtual int64_t _get_max_packet_size() const override;
+
+	/* WebRTCDataChannel */
+	godot::Error _poll() override;
+	void _close() override;
+
+	void _set_write_mode(WriteMode p_mode) override;
+	WriteMode _get_write_mode() const override;
+	bool _was_string_packet() const override;
+
+	ChannelState _get_ready_state() const override;
+	godot::String _get_label() const override;
+	bool _is_ordered() const override;
+	int64_t _get_id() const override;
+	int64_t _get_max_packet_life_time() const override;
+	int64_t _get_max_retransmits() const override;
+	godot::String _get_protocol() const override;
+	bool _is_negotiated() const override;
+	int64_t _get_buffered_amount() const override;
+
+	WebRTCLibDataChannel();
+	~WebRTCLibDataChannel();
+};
+
+} // namespace godot_webrtc
+
+#endif // WEBRTC_DATA_CHANNEL_H
--- a/src/WebRTCLibPeer.cpp
+++ b/src/WebRTCLibPeer.cpp
@@ -1,202 +0,0 @@
-#include "WebRTCLibPeer.hpp"
-
-using namespace godot_webrtc;
-
-void WebRTCLibPeer::set_write_mode(godot_int mode) {
-}
-
-godot_int WebRTCLibPeer::get_write_mode() const {
-	return 0;
-}
-
-bool WebRTCLibPeer::was_string_packet() const {
-	return false;
-}
-
-godot_int WebRTCLibPeer::get_connection_state() const {
-	return 0;
-}
-
-godot_error WebRTCLibPeer::create_offer() {
-	peer_connection->CreateOffer(
-			ptr_csdo, // CreateSessionDescriptionObserver* observer,
-			nullptr // webrtc::PeerConnectionInterface::RTCOfferAnswerOptions() // const MediaConstraintsInterface* constraints
-	);
-	return GODOT_OK;
-}
-
-godot_error WebRTCLibPeer::set_remote_description(const char *type, const char *sdp) {
-	godot_error err = set_description(type, sdp, false); //false meaning !isLocal because it is remote
-	peer_connection->CreateAnswer(ptr_csdo, webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
-	return err;
-}
-
-godot_error WebRTCLibPeer::set_local_description(const char *type, const char *sdp) {
-	return set_description(type, sdp, true); // isLocal == true
-}
-
-godot_error WebRTCLibPeer::add_ice_candidate(const char *sdpMidName, int sdpMlineIndexName, const char *sdpName) {
-	webrtc::SdpParseError *error = nullptr;
-	webrtc::IceCandidateInterface *candidate = webrtc::CreateIceCandidate(
-			sdpMidName,
-			sdpMlineIndexName,
-			sdpName,
-			error);
-
-	// @TODO do something if there's an error (if error, or if !candidate)
-	if (error || !candidate)
-		std::cout << "ERROR with creating ICE candidate (" << error << ")\n";
-
-	if (!peer_connection->AddIceCandidate(candidate))
-		ERR_PRINT("Error with adding ICE candidate");
-	return GODOT_OK;
-}
-
-godot_error WebRTCLibPeer::poll() {
-	std::function<void()> signal;
-	while (!signal_queue.empty()) {
-		mutex_signal_queue->lock();
-		signal = signal_queue.front();
-		signal_queue.pop();
-		mutex_signal_queue->unlock();
-
-		signal();
-	}
-	return GODOT_OK;
-}
-
-godot_error WebRTCLibPeer::get_packet(const uint8_t **r_buffer, int *r_len) {
-	if (packet_queue_size == 0)
-		return GODOT_ERR_UNAVAILABLE;
-	mutex_packet_queue->lock();
-	uint8_t *current_packet = packet_queue.front();
-	*r_buffer = current_packet;
-	*r_len = packet_sizes_queue.front();
-
-	packet_queue.pop();
-	packet_sizes_queue.pop();
-	mutex_packet_queue->unlock();
-
-	--packet_queue_size;
-	return GODOT_OK;
-}
-
-godot_error WebRTCLibPeer::put_packet(const uint8_t *p_buffer, int p_len) {
-	webrtc::DataBuffer webrtc_buffer(rtc::CopyOnWriteBuffer(p_buffer, p_len), true);
-	data_channel->Send(webrtc_buffer);
-	return GODOT_OK; // @TODO properly return any Error we may get.
-}
-
-godot_int WebRTCLibPeer::get_available_packet_count() const {
-	return packet_queue_size;
-}
-
-godot_int WebRTCLibPeer::get_max_packet_size() const {
-	return 1200;
-}
-
-void WebRTCLibPeer::_register_methods() {
-}
-
-void WebRTCLibPeer::_init() {
-	register_interface(&interface);
-
-	// initialize variables:
-	mutex_signal_queue = new std::mutex;
-	mutex_packet_queue = new std::mutex;
-	packet_queue_size = 0;
-
-	// create a PeerConnectionFactoryInterface:
-	signaling_thread = new rtc::Thread;
-	signaling_thread->Start();
-	pc_factory = webrtc::CreateModularPeerConnectionFactory(
-			nullptr, // rtc::Thread* network_thread,
-			nullptr, // rtc::Thread* worker_thread,
-			signaling_thread,
-			nullptr, // std::unique_ptr<cricket::MediaEngineInterface> media_engine,
-			nullptr, // std::unique_ptr<CallFactoryInterface> call_factory,
-			nullptr // std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory
-	);
-	if (pc_factory.get() == nullptr) { // PeerConnectionFactory couldn't be created. Fail the method call.
-		ERR_PRINT("PeerConnectionFactory could not be created");
-		// return GODOT_FAILED;
-	}
-
-	// create PeerConnection configuration and add the ice servers:
-	webrtc::PeerConnectionInterface::RTCConfiguration configuration;
-	//webrtc::PeerConnectionInterface::IceServer ice_server;
-
-	//ice_server.uri = "stun:stun.l.google.com:19302"; // @FIXME allow user to input ice servers
-	//configuration.servers.push_back(ice_server);
-
-	// create a PeerConnection object:
-	peer_connection = pc_factory->CreatePeerConnection(configuration, nullptr, nullptr, &pco);
-	if (peer_connection.get() == nullptr) { // PeerConnection couldn't be created. Fail the method call.
-		ERR_PRINT("PeerConnection could not be created");
-		// return GODOT_FAILED;
-	}
-
-	// create a DataChannel
-	webrtc::DataChannelInit data_channel_config;
-	data_channel_config.negotiated = true; // True if the channel has been externally negotiated
-	data_channel_config.id = 0;
-
-	data_channel = peer_connection->CreateDataChannel("channel", &data_channel_config);
-	// @TODO (NONESSENTIAL) create data_channel check. fail function call if data_channel isn't created
-	data_channel->RegisterObserver(&dco);
-}
-
-WebRTCLibPeer::WebRTCLibPeer() :
-		dco(this),
-		pco(this),
-		ptr_csdo(new rtc::RefCountedObject<GodotCSDO>(this)),
-		ptr_ssdo(new rtc::RefCountedObject<GodotSSDO>(this)) {
-}
-
-WebRTCLibPeer::~WebRTCLibPeer() {
-	if (_owner) {
-		register_interface(NULL);
-	}
-	delete mutex_signal_queue;
-	delete mutex_packet_queue;
-}
-
-void WebRTCLibPeer::queue_signal(godot::String p_name, int p_argc, const godot::Variant &p_arg1, const godot::Variant &p_arg2, const godot::Variant &p_arg3) {
-	mutex_signal_queue->lock();
-	signal_queue.push(
-			[this, p_name, p_argc, p_arg1, p_arg2, p_arg3] {
-				if (p_argc == 2)
-					emit_signal(p_name, p_arg1, p_arg2);
-				else
-					emit_signal(p_name, p_arg1, p_arg2, p_arg3);
-			});
-	mutex_signal_queue->unlock();
-}
-
-void WebRTCLibPeer::queue_packet(uint8_t *buffer, int buffer_size) {
-	mutex_packet_queue->lock();
-	packet_queue.push(buffer);
-	packet_sizes_queue.push(buffer_size);
-	++packet_queue_size;
-	mutex_packet_queue->unlock();
-}
-
-godot_error WebRTCLibPeer::set_description(const char *type, const char *sdp, bool isLocal) {
-	// webrtc::SdpType type = (isOffer) ? webrtc::SdpType::kOffer : webrtc::SdpType::kAnswer;
-	godot::String string_sdp = sdp;
-
-	webrtc::SdpType sdptype = (godot::String(type) == godot::String("offer")) ? webrtc::SdpType::kOffer : webrtc::SdpType::kAnswer;
-	std::unique_ptr<webrtc::SessionDescriptionInterface> desc =
-			webrtc::CreateSessionDescription(sdptype, sdp);
-
-	if (isLocal) {
-		peer_connection->SetLocalDescription(
-				ptr_ssdo, // @TODO (NONESSENTIAL, OPTIONAL) replace this with DummySetSessionDescriptionObserver::Create()
-				desc.release());
-	} else {
-		peer_connection->SetRemoteDescription(
-				ptr_ssdo, // @TODO (NONESSENTIAL, OPTIONAL) replace this with DummySetSessionDescriptionObserver::Create()
-				desc.release());
-	}
-	return GODOT_OK;
-}
--- a/src/WebRTCLibPeer.hpp
+++ b/src/WebRTCLibPeer.hpp
@@ -1,117 +0,0 @@
-#ifndef WEBRTC_PEER_H
-#define WEBRTC_PEER_H
-
-#include <Godot.hpp> // Godot.hpp must go first, or windows builds breaks
-
-#include "api/peerconnectioninterface.h" // interface for all things needed from WebRTC
-#include "media/base/mediaengine.h" // needed for CreateModularPeerConnectionFactory
-#include <functional> // std::function
-#include <mutex> // mutex @TODO replace std::mutex with Godot mutex
-
-#include "net/WebRTCPeerNative.hpp"
-
-namespace godot_webrtc {
-
-class WebRTCLibPeer : public WebRTCPeerNative {
-	GODOT_CLASS(WebRTCLibPeer, WebRTCPeerNative);
-
-public:
-	static void _register_methods();
-
-	void _init();
-
-	void set_write_mode(godot_int mode);
-	godot_int get_write_mode() const;
-	bool was_string_packet() const;
-	godot_int get_connection_state() const;
-
-	godot_error create_offer();
-	godot_error set_remote_description(const char *type, const char *sdp);
-	godot_error set_local_description(const char *type, const char *sdp);
-	godot_error add_ice_candidate(const char *sdpMidName, int sdpMlineIndexName, const char *sdpName);
-	godot_error poll();
-
-	/* WebRTCPeer */
-	virtual godot_error get_packet(const uint8_t **r_buffer, int *r_len);
-	virtual godot_error put_packet(const uint8_t *p_buffer, int p_len);
-	virtual godot_int get_available_packet_count() const;
-	virtual godot_int get_max_packet_size() const;
-
-	WebRTCLibPeer();
-	~WebRTCLibPeer();
-
-	/* helper functions */
-
-	void queue_signal(godot::String p_name, int p_argc, const godot::Variant &p_arg1 = godot::Variant(), const godot::Variant &p_arg2 = godot::Variant(), const godot::Variant &p_arg3 = godot::Variant());
-	// void queue_signal(godot::StringName p_name, Variant_ARG_LIST);
-	void queue_packet(uint8_t *, int);
-	godot_error set_description(const char *type, const char *sdp, bool isLocal);
-
-	/** DataChannelObserver callback functions **/
-	class GodotDCO : public webrtc::DataChannelObserver {
-	public:
-		WebRTCLibPeer *parent;
-
-		GodotDCO(WebRTCLibPeer *parent);
-		void OnMessage(const webrtc::DataBuffer &buffer) override;
-		void OnStateChange() override; // UNUSED
-		void OnBufferedAmountChange(uint64_t previous_amount) override; // UNUSED
-	};
-
-	/** PeerConnectionObserver callback functions **/
-	class GodotPCO : public webrtc::PeerConnectionObserver {
-	public:
-		WebRTCLibPeer *parent;
-
-		GodotPCO(WebRTCLibPeer *parent);
-		void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) override;
-		void OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
-		void OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
-		void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override;
-		void OnRenegotiationNeeded() override;
-		void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
-		void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) override;
-		void OnIceCandidate(const webrtc::IceCandidateInterface *candidate) override;
-	};
-
-	/** CreateSessionDescriptionObserver callback functions **/
-	class GodotCSDO : public webrtc::CreateSessionDescriptionObserver {
-	public:
-		WebRTCLibPeer *parent;
-
-		GodotCSDO(WebRTCLibPeer *parent);
-		void OnSuccess(webrtc::SessionDescriptionInterface *desc) override;
-		void OnFailure(const std::string &error) override;
-	};
-
-	/** SetSessionDescriptionObserver callback functions **/
-	class GodotSSDO : public webrtc::SetSessionDescriptionObserver {
-	public:
-		WebRTCLibPeer *parent;
-
-		GodotSSDO(WebRTCLibPeer *parent);
-		void OnSuccess() override;
-		void OnFailure(const std::string &error) override;
-	};
-
-	GodotDCO dco;
-	GodotPCO pco;
-	rtc::scoped_refptr<GodotSSDO> ptr_ssdo;
-	rtc::scoped_refptr<GodotCSDO> ptr_csdo;
-
-	std::mutex *mutex_signal_queue;
-	std::mutex *mutex_packet_queue;
-	int packet_queue_size;
-	std::queue<uint8_t *> packet_queue;
-	std::queue<int> packet_sizes_queue;
-	std::queue<std::function<void()> > signal_queue;
-
-	rtc::Thread *signaling_thread;
-	rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory;
-	rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection;
-	rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel;
-};
-
-} // namespace godot_webrtc
-
-#endif // WEBRTC_PEER_H
--- a/src/WebRTCLibPeerConnection.cpp
+++ b/src/WebRTCLibPeerConnection.cpp
@@ -0,0 +1,336 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#include "WebRTCLibPeerConnection.hpp"
+#include "WebRTCLibDataChannel.hpp"
+
+using namespace godot;
+using namespace godot_webrtc;
+
+#ifdef GDNATIVE_WEBRTC
+#define OK Error::OK
+#define FAILED Error::FAILED
+#define ERR_UNCONFIGURED Error::ERR_UNCONFIGURED
+#define ERR_INVALID_PARAMETER Error::ERR_INVALID_PARAMETER
+#endif
+
+void WebRTCLibPeerConnection::initialize_signaling() {
+#ifdef DEBUG_ENABLED
+	rtc::InitLogger(rtc::LogLevel::Debug);
+#endif
+}
+
+void WebRTCLibPeerConnection::deinitialize_signaling() {
+}
+
+Error WebRTCLibPeerConnection::_parse_ice_server(rtc::Configuration &r_config, Dictionary p_server) {
+	ERR_FAIL_COND_V(!p_server.has("urls"), ERR_INVALID_PARAMETER);
+
+	// Parse mandatory URL
+	Array urls;
+	Variant urls_var = p_server["urls"];
+	if (urls_var.get_type() == Variant::STRING) {
+		urls.push_back(urls_var);
+	} else if (urls_var.get_type() == Variant::ARRAY) {
+		urls = urls_var;
+	} else {
+		ERR_FAIL_V(ERR_INVALID_PARAMETER);
+	}
+	// Parse credentials (only meaningful for TURN, only support password)
+	String username;
+	String credential;
+	if (p_server.has("username") && p_server["username"].get_type() == Variant::STRING) {
+		username = p_server["username"];
+	}
+	if (p_server.has("credential") && p_server["credential"].get_type() == Variant::STRING) {
+		credential = p_server["credential"];
+	}
+	for (int i = 0; i < urls.size(); i++) {
+		rtc::IceServer srv(urls[i].operator String().utf8().get_data());
+		srv.username = username.utf8().get_data();
+		srv.password = credential.utf8().get_data();
+		r_config.iceServers.push_back(srv);
+	}
+	return OK;
+}
+
+Error WebRTCLibPeerConnection::_parse_channel_config(rtc::DataChannelInit &r_config, const Dictionary &p_dict) {
+	Variant nil;
+	Variant v;
+	if (p_dict.has("negotiated")) {
+		r_config.negotiated = p_dict["negotiated"].operator bool();
+	}
+	if (p_dict.has("id")) {
+		r_config.id = uint16_t(p_dict["id"].operator int32_t());
+	}
+	// If negotiated it must have an ID, and ID only makes sense when negotiated.
+	ERR_FAIL_COND_V(r_config.negotiated != r_config.id.has_value(), ERR_INVALID_PARAMETER);
+	// 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());
+	} else if (p_dict.has("maxRetransmits")) {
+		r_config.reliability.type = rtc::Reliability::Type::Rexmit;
+		r_config.reliability.rexmit = p_dict["maxRetransmits"].operator int32_t();
+	}
+	if (p_dict.has("ordered") && p_dict["ordered"].operator bool() == false) {
+		r_config.reliability.unordered = true;
+	}
+	if (p_dict.has("protocol")) {
+		r_config.protocol = p_dict["protocol"].operator String().utf8().get_data();
+	}
+	return OK;
+}
+
+WebRTCPeerConnection::ConnectionState WebRTCLibPeerConnection::_get_connection_state() const {
+	ERR_FAIL_COND_V(peer_connection == nullptr, STATE_CLOSED);
+
+	rtc::PeerConnection::State state = peer_connection->state();
+	switch (state) {
+		case rtc::PeerConnection::State::New:
+			return STATE_NEW;
+		case rtc::PeerConnection::State::Connecting:
+			return STATE_CONNECTING;
+		case rtc::PeerConnection::State::Connected:
+			return STATE_CONNECTED;
+		case rtc::PeerConnection::State::Disconnected:
+			return STATE_DISCONNECTED;
+		case rtc::PeerConnection::State::Failed:
+			return STATE_FAILED;
+		default:
+			return STATE_CLOSED;
+	}
+}
+
+WebRTCLibPeerConnection::GatheringState WebRTCLibPeerConnection::_get_gathering_state() const {
+	ERR_FAIL_COND_V(peer_connection == nullptr, GATHERING_STATE_NEW);
+
+	rtc::PeerConnection::GatheringState state = peer_connection->gatheringState();
+	switch (state) {
+		case rtc::PeerConnection::GatheringState::New:
+			return GATHERING_STATE_NEW;
+		case rtc::PeerConnection::GatheringState::InProgress:
+			return GATHERING_STATE_GATHERING;
+		case rtc::PeerConnection::GatheringState::Complete:
+			return GATHERING_STATE_COMPLETE;
+		default:
+			return GATHERING_STATE_NEW;
+	}
+}
+
+WebRTCLibPeerConnection::SignalingState WebRTCLibPeerConnection::_get_signaling_state() const {
+	ERR_FAIL_COND_V(peer_connection == nullptr, SIGNALING_STATE_CLOSED);
+
+	rtc::PeerConnection::SignalingState state = peer_connection->signalingState();
+	switch (state) {
+		case rtc::PeerConnection::SignalingState::Stable:
+			return SIGNALING_STATE_STABLE;
+		case rtc::PeerConnection::SignalingState::HaveLocalOffer:
+			return SIGNALING_STATE_HAVE_LOCAL_OFFER;
+		case rtc::PeerConnection::SignalingState::HaveRemoteOffer:
+			return SIGNALING_STATE_HAVE_REMOTE_OFFER;
+		case rtc::PeerConnection::SignalingState::HaveLocalPranswer:
+			return SIGNALING_STATE_HAVE_LOCAL_PRANSWER;
+		case rtc::PeerConnection::SignalingState::HaveRemotePranswer:
+			return SIGNALING_STATE_HAVE_REMOTE_PRANSWER;
+		default:
+			return SIGNALING_STATE_CLOSED;
+	}
+}
+
+Error WebRTCLibPeerConnection::_initialize(const Dictionary &p_config) {
+	rtc::Configuration config = {};
+	if (p_config.has("iceServers") && p_config["iceServers"].get_type() == Variant::ARRAY) {
+		Array servers = p_config["iceServers"];
+		for (int i = 0; i < servers.size(); i++) {
+			ERR_FAIL_COND_V(servers[i].get_type() != Variant::DICTIONARY, ERR_INVALID_PARAMETER);
+			Dictionary server = servers[i];
+			Error err = _parse_ice_server(config, server);
+			ERR_FAIL_COND_V(err != OK, FAILED);
+		}
+	}
+	return _create_pc(config);
+}
+
+Object *WebRTCLibPeerConnection::_create_data_channel(const String &p_channel, const Dictionary &p_channel_config) try {
+	ERR_FAIL_COND_V(!peer_connection, nullptr);
+
+	// Read config from dictionary
+	rtc::DataChannelInit config;
+
+	Error err = _parse_channel_config(config, p_channel_config);
+	ERR_FAIL_COND_V(err != OK, nullptr);
+
+	std::shared_ptr<rtc::DataChannel> ch = peer_connection->createDataChannel(p_channel.utf8().get_data(), config);
+	ERR_FAIL_COND_V(ch == nullptr, nullptr);
+
+	WebRTCLibDataChannel *wrapper = WebRTCLibDataChannel::new_data_channel(ch, ch->id().has_value());
+	ERR_FAIL_COND_V(wrapper == nullptr, nullptr);
+	return wrapper;
+} catch (const std::exception &e) {
+	ERR_PRINT(e.what());
+	ERR_FAIL_V(nullptr);
+}
+
+Error WebRTCLibPeerConnection::_create_offer() try {
+	ERR_FAIL_COND_V(!peer_connection, ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(_get_connection_state() != STATE_NEW, FAILED);
+	peer_connection->setLocalDescription(rtc::Description::Type::Offer);
+	return OK;
+} catch (const std::exception &e) {
+	ERR_PRINT(e.what());
+	ERR_FAIL_V(FAILED);
+}
+
+Error WebRTCLibPeerConnection::_set_remote_description(const String &p_type, const String &p_sdp) try {
+	ERR_FAIL_COND_V(!peer_connection, ERR_UNCONFIGURED);
+	std::string sdp(p_sdp.utf8().get_data());
+	std::string type(p_type.utf8().get_data());
+	rtc::Description desc(sdp, type);
+	peer_connection->setRemoteDescription(desc);
+	// Automatically create the answer.
+	if (p_type == String("offer")) {
+		peer_connection->setLocalDescription(rtc::Description::Type::Answer);
+	}
+	return OK;
+} catch (const std::exception &e) {
+	ERR_PRINT(e.what());
+	ERR_FAIL_V(FAILED);
+}
+
+Error WebRTCLibPeerConnection::_set_local_description(const String &p_type, const String &p_sdp) {
+	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);
+	return OK;
+}
+
+Error WebRTCLibPeerConnection::_add_ice_candidate(const String &sdpMidName, int64_t sdpMlineIndexName, const String &sdpName) try {
+	ERR_FAIL_COND_V(!peer_connection, ERR_UNCONFIGURED);
+	rtc::Candidate candidate(sdpName.utf8().get_data(), sdpMidName.utf8().get_data());
+	peer_connection->addRemoteCandidate(candidate);
+	return OK;
+} catch (const std::exception &e) {
+	ERR_PRINT(e.what());
+	ERR_FAIL_V(FAILED);
+}
+
+Error WebRTCLibPeerConnection::_poll() {
+	ERR_FAIL_COND_V(!peer_connection, ERR_UNCONFIGURED);
+
+	while (!signal_queue.empty()) {
+		mutex_signal_queue->lock();
+		Signal signal = signal_queue.front();
+		signal_queue.pop();
+		mutex_signal_queue->unlock();
+		signal.emit(this);
+	}
+	return OK;
+}
+
+void WebRTCLibPeerConnection::_close() {
+	if (peer_connection != nullptr) {
+		try {
+			peer_connection->close();
+		} catch (...) {
+		}
+	}
+
+	while (!signal_queue.empty()) {
+		signal_queue.pop();
+	}
+}
+
+void WebRTCLibPeerConnection::_init() {
+#ifdef GDNATIVE_WEBRTC
+	register_interface(&interface);
+#endif
+	mutex_signal_queue = new std::mutex;
+
+	_initialize(Dictionary());
+}
+
+Error WebRTCLibPeerConnection::_create_pc(rtc::Configuration &r_config) try {
+	// Prevents libdatachannel from automatically creating offers.
+	r_config.disableAutoNegotiation = true;
+
+	peer_connection = std::make_shared<rtc::PeerConnection>(r_config);
+	ERR_FAIL_COND_V(!peer_connection, FAILED);
+
+	// Binding this should be fine as long as we call close when going out of scope.
+	peer_connection->onLocalDescription([this](rtc::Description description) {
+		String type = description.type() == rtc::Description::Type::Offer ? "offer" : "answer";
+		queue_signal("session_description_created", 2, type, String(std::string(description).c_str()));
+	});
+	peer_connection->onLocalCandidate([this](rtc::Candidate candidate) {
+		queue_signal("ice_candidate_created", 3, String(candidate.mid().c_str()), 0, String(candidate.candidate().c_str()));
+	});
+	peer_connection->onDataChannel([this](std::shared_ptr<rtc::DataChannel> channel) {
+		queue_signal("data_channel_received", 1, WebRTCLibDataChannel::new_data_channel(channel, false));
+	});
+	/*
+	peer_connection->onStateChange([](rtc::PeerConnection::State state) {
+		std::cout << "[State: " << state << "]" << std::endl;
+	});
+
+	peer_connection->onGatheringStateChange([](rtc::PeerConnection::GatheringState state) {
+		std::cout << "[Gathering State: " << state << "]" << std::endl;
+	});
+	*/
+	return OK;
+} catch (const std::exception &e) {
+	ERR_PRINT(e.what());
+	ERR_FAIL_V(FAILED);
+}
+
+WebRTCLibPeerConnection::WebRTCLibPeerConnection() {
+#ifndef GDNATIVE_WEBRTC
+	_init();
+#endif
+}
+
+WebRTCLibPeerConnection::~WebRTCLibPeerConnection() {
+#ifdef GDNATIVE_WEBRTC
+	if (_owner) {
+		register_interface(nullptr);
+	}
+#endif
+	_close();
+	delete mutex_signal_queue;
+}
+
+void WebRTCLibPeerConnection::queue_signal(String p_name, int p_argc, const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3) {
+	mutex_signal_queue->lock();
+	const Variant argv[3] = { p_arg1, p_arg2, p_arg3 };
+	signal_queue.push(Signal(p_name, p_argc, argv));
+	mutex_signal_queue->unlock();
+}
--- a/src/WebRTCLibPeerConnection.hpp
+++ b/src/WebRTCLibPeerConnection.hpp
@@ -0,0 +1,129 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#ifndef WEBRTC_PEER_H
+#define WEBRTC_PEER_H
+
+#ifdef GDNATIVE_WEBRTC
+#include <Godot.hpp> // Godot.hpp must go first, or windows builds breaks
+
+#include "net/WebRTCPeerConnectionNative.hpp"
+#define WebRTCPeerConnectionExtension WebRTCPeerConnectionNative
+#if !defined(GDCLASS)
+#define GDCLASS(arg1, arg2) GODOT_CLASS(arg1, arg2)
+#endif
+#else
+#include <godot_cpp/core/binder_common.hpp>
+
+#include <godot_cpp/classes/global_constants_binds.hpp>
+#include <godot_cpp/classes/web_rtc_peer_connection_extension.hpp>
+#endif
+
+#include "rtc/rtc.hpp"
+
+#include <mutex>
+#include <queue>
+
+namespace godot_webrtc {
+
+class WebRTCLibPeerConnection : public godot::WebRTCPeerConnectionExtension {
+	GDCLASS(WebRTCLibPeerConnection, WebRTCPeerConnectionExtension);
+
+private:
+	std::shared_ptr<rtc::PeerConnection> peer_connection = nullptr;
+	godot::Array candidates;
+
+	godot::Error _create_pc(rtc::Configuration &r_config);
+	godot::Error _parse_ice_server(rtc::Configuration &r_config, godot::Dictionary p_server);
+	godot::Error _parse_channel_config(rtc::DataChannelInit &r_config, const godot::Dictionary &p_dict);
+
+protected:
+	static void _bind_methods() {}
+
+public:
+	static void _register_methods() {}
+	static void initialize_signaling();
+	static void deinitialize_signaling();
+
+	void _init();
+
+	ConnectionState _get_connection_state() const override;
+	GatheringState _get_gathering_state() const override;
+	SignalingState _get_signaling_state() const override;
+
+	godot::Error _initialize(const godot::Dictionary &p_config) override;
+	godot::Object *_create_data_channel(const godot::String &p_channel, const godot::Dictionary &p_channel_config) override;
+	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;
+	godot::Error _add_ice_candidate(const godot::String &sdpMidName, int64_t sdpMlineIndexName, const godot::String &sdpName) override;
+	godot::Error _poll() override;
+	void _close() override;
+
+	WebRTCLibPeerConnection();
+	~WebRTCLibPeerConnection();
+
+private:
+	class Signal {
+		godot::String method;
+		godot::Variant argv[3];
+		int argc = 0;
+
+	public:
+		Signal(godot::String p_method, int p_argc, const godot::Variant *p_argv) {
+			method = p_method;
+			argc = p_argc;
+			for (int i = 0; i < argc; i++) {
+				argv[i] = p_argv[i];
+			}
+		}
+
+		void emit(godot::Object *p_object) {
+			if (argc == 0) {
+				p_object->emit_signal(method);
+			} else if (argc == 1) {
+				p_object->emit_signal(method, argv[0]);
+			} else if (argc == 2) {
+				p_object->emit_signal(method, argv[0], argv[1]);
+			} else if (argc == 3) {
+				p_object->emit_signal(method, argv[0], argv[1], argv[2]);
+			}
+		}
+	};
+
+	std::mutex *mutex_signal_queue = nullptr;
+	std::queue<Signal> signal_queue;
+
+	void queue_signal(godot::String p_name, int p_argc, const godot::Variant &p_arg1 = godot::Variant(), const godot::Variant &p_arg2 = godot::Variant(), const godot::Variant &p_arg3 = godot::Variant());
+};
+
+} // namespace godot_webrtc
+
+#endif // WEBRTC_PEER_H
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1,25 +0,0 @@
-#include "WebRTCLibPeer.hpp"
-#include "net/WebRTCPeerNative.hpp"
-#include <gdnative_api_struct.gen.h>
-
-/* Godot export stuff */
-extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
-	const godot_gdnative_core_api_struct *api = o->api_struct;
-	for (int i = 0; i < api->num_extensions; i++) {
-		if (api->extensions[i]->type == GDNATIVE_EXT_NET) {
-			WebRTCPeerNative::_net_api = (godot_gdnative_ext_net_api_struct *)api->extensions[i];
-		}
-	}
-
-	godot::Godot::gdnative_init(o);
-}
-
-extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
-	godot::Godot::gdnative_terminate(o);
-}
-
-extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
-	godot::Godot::nativescript_init(handle);
-
-	godot::register_class<godot_webrtc::WebRTCLibPeer>();
-}
--- a/src/init_gdextension.cpp
+++ b/src/init_gdextension.cpp
@@ -0,0 +1,78 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#include <gdextension_interface.h>
+
+#include <godot_cpp/core/class_db.hpp>
+#include <godot_cpp/core/defs.hpp>
+#include <godot_cpp/godot.hpp>
+
+#include "WebRTCLibDataChannel.hpp"
+#include "WebRTCLibPeerConnection.hpp"
+
+#ifdef _WIN32
+// See upstream godot-cpp GH-771.
+#undef GDN_EXPORT
+#define GDN_EXPORT __declspec(dllexport)
+#endif
+
+using namespace godot;
+using namespace godot_webrtc;
+
+void register_webrtc_extension_types(ModuleInitializationLevel p_level) {
+	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
+		return;
+	}
+
+	WebRTCLibPeerConnection::initialize_signaling();
+	godot::ClassDB::register_class<WebRTCLibDataChannel>();
+	godot::ClassDB::register_class<WebRTCLibPeerConnection>();
+	WebRTCPeerConnection::set_default_extension("WebRTCLibPeerConnection");
+}
+
+void unregister_webrtc_extension_types(ModuleInitializationLevel p_level) {
+	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
+		return;
+	}
+
+	WebRTCLibPeerConnection::deinitialize_signaling();
+}
+
+extern "C" {
+GDExtensionBool GDE_EXPORT webrtc_extension_init(const GDExtensionInterface *p_interface, const GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
+	GDExtensionBinding::InitObject init_obj(p_interface, p_library, r_initialization);
+
+	init_obj.register_initializer(register_webrtc_extension_types);
+	init_obj.register_terminator(unregister_webrtc_extension_types);
+	init_obj.set_minimum_library_initialization_level(MODULE_INITIALIZATION_LEVEL_SCENE);
+
+	return init_obj.init();
+}
+}
--- a/src/init_gdnative.cpp
+++ b/src/init_gdnative.cpp
@@ -0,0 +1,141 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#include "WebRTCLibDataChannel.hpp"
+#include "WebRTCLibPeerConnection.hpp"
+#include "net/WebRTCPeerConnectionNative.hpp"
+#include <gdnative_api_struct.gen.h>
+#include <net/godot_net.h>
+
+#ifdef _WIN32
+// See upstream godot GH-62173.
+#undef GDN_EXPORT
+#define GDN_EXPORT __declspec(dllexport)
+#endif
+
+/* Singleton */
+static bool _singleton = false;
+static const godot_object *_singleton_lib = NULL;
+static const godot_gdnative_core_api_struct *_singleton_api = NULL;
+static godot_class_constructor _create_ns_cb = NULL;
+static godot_method_bind *_set_script_mb = NULL;
+static godot_method_bind *_set_class_name_mb = NULL;
+static godot_method_bind *_set_library_mb = NULL;
+
+void unregistered() {
+	_singleton = false; // We are no longer the active singleton
+}
+
+godot_error create_peer_connection_wp(godot_object *out) {
+	ERR_FAIL_COND_V(!_singleton, GODOT_FAILED);
+	// Create Script
+	godot_object *script = _create_ns_cb();
+	ERR_FAIL_COND_V(!script, GODOT_FAILED);
+
+	const void *args[] = { (void *)_singleton_lib };
+	_singleton_api->godot_method_bind_ptrcall(_set_library_mb, script, args, nullptr);
+
+	godot_string s;
+	_singleton_api->godot_string_new(&s);
+	_singleton_api->godot_string_parse_utf8(&s, "WebRTCLibPeerConnection");
+	const void *args2[] = { (void *)&s };
+	_singleton_api->godot_method_bind_ptrcall(_set_class_name_mb, script, args2, nullptr);
+	_singleton_api->godot_string_destroy(&s);
+
+	// Bind script to Object
+	const void *args3[] = { (void *)script };
+	_singleton_api->godot_method_bind_ptrcall(_set_script_mb, out, args3, nullptr);
+
+	return GODOT_OK;
+}
+
+godot_net_webrtc_library library = {
+	{ 3, 2 },
+	&unregistered,
+	&create_peer_connection_wp,
+	NULL,
+};
+
+extern "C" void GDN_EXPORT godot_gdnative_singleton() {
+	if (godot::WebRTCPeerConnectionNative::_net_api) {
+		ERR_FAIL_COND(!godot::gdnlib);
+		_singleton_lib = godot::gdnlib;
+		ERR_FAIL_COND(!godot::api);
+		_singleton_api = godot::api;
+		_create_ns_cb = godot::api->godot_get_class_constructor("NativeScript");
+		ERR_FAIL_COND(!_create_ns_cb);
+		_set_script_mb = godot::api->godot_method_bind_get_method("Object", "set_script");
+		ERR_FAIL_COND(!_set_script_mb);
+		_set_class_name_mb = godot::api->godot_method_bind_get_method("NativeScript", "set_class_name");
+		ERR_FAIL_COND(!_set_class_name_mb);
+		_set_library_mb = godot::api->godot_method_bind_get_method("NativeScript", "set_library");
+		ERR_FAIL_COND(!_set_library_mb);
+		// If registration is successful _singleton will be set to true
+		_singleton = godot::WebRTCPeerConnectionNative::_net_api->godot_net_set_webrtc_library(&library) == GODOT_OK;
+		if (!_singleton)
+			ERR_PRINT("Failed initializing webrtc singleton library");
+	}
+}
+
+/* Godot export stuff */
+extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
+	const godot_gdnative_core_api_struct *api = o->api_struct;
+	for (int i = 0; i < api->num_extensions; i++) {
+		if (api->extensions[i]->type != GDNATIVE_EXT_NET)
+			continue;
+
+		const godot_gdnative_ext_net_api_struct *net_api = (godot_gdnative_ext_net_api_struct *)api->extensions[i];
+
+		if (!net_api->next)
+			break;
+
+		if (net_api->next->version.major == 3 && net_api->next->version.minor == 2) {
+			godot::WebRTCPeerConnectionNative::_net_api = (const godot_gdnative_ext_net_3_2_api_struct *)net_api->next;
+		}
+	}
+
+	godot_webrtc::WebRTCLibPeerConnection::initialize_signaling();
+	godot::Godot::gdnative_init(o);
+}
+
+extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
+	if (_singleton) { // If we are the active singleton, unregister
+		godot::WebRTCPeerConnectionNative::_net_api->godot_net_set_webrtc_library(NULL);
+	}
+	godot_webrtc::WebRTCLibPeerConnection::deinitialize_signaling();
+	godot::Godot::gdnative_terminate(o);
+}
+
+extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
+	godot::Godot::nativescript_init(handle);
+
+	godot::register_class<godot_webrtc::WebRTCLibPeerConnection>();
+	godot::register_class<godot_webrtc::WebRTCLibDataChannel>();
+}
--- a/src/net/WebRTCDataChannelNative.cpp
+++ b/src/net/WebRTCDataChannelNative.cpp
@@ -0,0 +1,128 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#include "WebRTCDataChannelNative.hpp"
+#include "net/WebRTCPeerConnectionNative.hpp"
+
+using namespace godot;
+
+void WebRTCDataChannelNative::register_interface(const godot_net_webrtc_data_channel *p_interface) {
+	ERR_FAIL_COND(!WebRTCPeerConnectionNative::_net_api);
+	WebRTCPeerConnectionNative::_net_api->godot_net_bind_webrtc_data_channel(_owner, p_interface);
+}
+
+void WebRTCDataChannelNative::_register_methods() {}
+
+void WebRTCDataChannelNative::_init() {
+	register_interface(&interface);
+}
+
+WebRTCDataChannelNative::~WebRTCDataChannelNative() {
+	if (_owner) {
+		register_interface(NULL);
+	}
+}
+
+/*
+ * The C interface that implements WebRTCDataChannel.
+ * In this case it forwards calls to our C++ class, but could be plain C,
+ * and you could use void *user for any kind of state struct pointer you have.
+ */
+godot_error get_packet_wdc(void *user, const uint8_t **r_buffer, int *r_len) {
+	return (godot_error)(((WebRTCDataChannelNative *)user)->_get_packet(r_buffer, r_len));
+}
+
+godot_error put_packet_wdc(void *user, const uint8_t *p_buffer, int p_len) {
+	return (godot_error)(((WebRTCDataChannelNative *)user)->_put_packet(p_buffer, p_len));
+}
+
+godot_int get_available_packet_count_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_available_packet_count();
+}
+
+godot_int get_max_packet_size_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_max_packet_size();
+}
+
+void set_write_mode_wdc(void *user, godot_int write_mode) {
+	((WebRTCDataChannelNative *)user)->_set_write_mode((godot::WebRTCDataChannel::WriteMode)write_mode);
+}
+
+godot_int get_write_mode_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_write_mode();
+}
+
+bool was_string_packet_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_was_string_packet();
+}
+
+godot_int get_ready_state_wdc(const void *user) {
+	return (godot_int)(((WebRTCDataChannelNative *)user)->_get_ready_state());
+}
+
+const char *get_label_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_label().utf8().get_data();
+}
+
+bool is_ordered_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_is_ordered();
+}
+
+int get_id_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_id();
+}
+
+int get_max_packet_life_time_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_max_packet_life_time();
+}
+
+int get_max_retransmits_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_max_retransmits();
+}
+
+const char *get_protocol_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_protocol().utf8().get_data();
+}
+
+bool is_negotiated_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_is_negotiated();
+}
+
+int get_buffered_amount_wdc(const void *user) {
+	return ((WebRTCDataChannelNative *)user)->_get_buffered_amount();
+}
+
+godot_error poll_wdc(void *user) {
+	return (godot_error)(((WebRTCDataChannelNative *)user)->_poll());
+}
+
+void close_wdc(void *user) {
+	((WebRTCDataChannelNative *)user)->_close();
+}
--- a/src/net/WebRTCDataChannelNative.hpp
+++ b/src/net/WebRTCDataChannelNative.hpp
@@ -0,0 +1,143 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#ifndef WEBRTC_DATA_CHANNEL_NATIVE
+#define WEBRTC_DATA_CHANNEL_NATIVE
+
+#include <Godot.hpp>
+#include <Reference.hpp>
+#include <WebRTCDataChannelGDNative.hpp>
+
+#include <net/godot_net.h>
+
+/* Forward declare interface functions */
+godot_error get_packet_wdc(void *, const uint8_t **, int *);
+godot_error put_packet_wdc(void *, const uint8_t *, int);
+godot_int get_available_packet_count_wdc(const void *);
+godot_int get_max_packet_size_wdc(const void *);
+
+void set_write_mode_wdc(void *, godot_int);
+godot_int get_write_mode_wdc(const void *);
+bool was_string_packet_wdc(const void *);
+godot_int get_ready_state_wdc(const void *);
+const char *get_label_wdc(const void *);
+bool is_ordered_wdc(const void *);
+int get_id_wdc(const void *);
+int get_max_packet_life_time_wdc(const void *);
+int get_max_retransmits_wdc(const void *);
+const char *get_protocol_wdc(const void *);
+bool is_negotiated_wdc(const void *);
+int get_buffered_amount_wdc(const void *);
+godot_error poll_wdc(void *);
+void close_wdc(void *);
+
+#if GODOT_NET_WEBRTC_API_MAJOR == 3 && GODOT_NET_WEBRTC_API_MINOR < 4
+extern "C" {
+/* Extensions to WebRTCDataChannel */
+typedef struct {
+	int (*get_buffered_amount)(const void *);
+
+	void *next; /* For extension? */
+} godot_net_webrtc_data_channel_ext;
+}
+#endif
+
+namespace godot {
+
+class WebRTCDataChannelNative : public godot::WebRTCDataChannelGDNative {
+	GODOT_CLASS(WebRTCDataChannelNative, godot::WebRTCDataChannelGDNative);
+
+protected:
+	godot_net_webrtc_data_channel_ext interface_ext = {
+		&get_buffered_amount_wdc,
+		NULL,
+	};
+
+	godot_net_webrtc_data_channel interface = {
+		{ 3, 1 },
+		this,
+
+		&get_packet_wdc,
+		&put_packet_wdc,
+		&get_available_packet_count_wdc,
+		&get_max_packet_size_wdc,
+
+		&set_write_mode_wdc,
+		&get_write_mode_wdc,
+		&was_string_packet_wdc,
+		&get_ready_state_wdc,
+		&get_label_wdc,
+		&is_ordered_wdc,
+		&get_id_wdc,
+		&get_max_packet_life_time_wdc,
+		&get_max_retransmits_wdc,
+		&get_protocol_wdc,
+		&is_negotiated_wdc,
+
+		&poll_wdc,
+		&close_wdc,
+		&interface_ext,
+	};
+
+public:
+	static void _register_methods();
+
+	void _init();
+	void register_interface(const godot_net_webrtc_data_channel *interface);
+
+	virtual void _set_write_mode(WriteMode mode) = 0;
+	virtual WriteMode _get_write_mode() const = 0;
+	virtual bool _was_string_packet() const = 0;
+
+	virtual ChannelState _get_ready_state() const = 0;
+	virtual godot::String _get_label() const = 0;
+	virtual bool _is_ordered() const = 0;
+	virtual int64_t _get_id() const = 0;
+	virtual int64_t _get_max_packet_life_time() const = 0;
+	virtual int64_t _get_max_retransmits() const = 0;
+	virtual godot::String _get_protocol() const = 0;
+	virtual bool _is_negotiated() const = 0;
+	virtual int64_t _get_buffered_amount() const = 0;
+
+	virtual godot::Error _poll() = 0;
+	virtual void _close() = 0;
+
+	/* PacketPeer */
+	virtual godot::Error _get_packet(const uint8_t **r_buffer, int32_t *r_len) = 0;
+	virtual godot::Error _put_packet(const uint8_t *p_buffer, int64_t p_len) = 0;
+	virtual int64_t _get_available_packet_count() const = 0;
+	virtual int64_t _get_max_packet_size() const = 0;
+
+	~WebRTCDataChannelNative();
+};
+
+}; // namespace godot
+
+#endif // WEBRTC_DATA_CHANNEL_NATIVE
--- a/src/net/WebRTCPeerConnectionNative.cpp
+++ b/src/net/WebRTCPeerConnectionNative.cpp
@@ -0,0 +1,101 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#include "WebRTCPeerConnectionNative.hpp"
+
+using namespace godot;
+
+const godot_gdnative_ext_net_3_2_api_struct *WebRTCPeerConnectionNative::_net_api = NULL;
+
+void WebRTCPeerConnectionNative::register_interface(const godot_net_webrtc_peer_connection *p_interface) {
+	ERR_FAIL_COND(!_net_api);
+	_net_api->godot_net_bind_webrtc_peer_connection(_owner, p_interface);
+}
+
+void WebRTCPeerConnectionNative::_register_methods() {}
+
+void WebRTCPeerConnectionNative::_init() {
+	register_interface(&interface);
+}
+
+WebRTCPeerConnectionNative::~WebRTCPeerConnectionNative() {
+	if (_owner) {
+		register_interface(NULL);
+	}
+}
+
+/*
+ * The C interface that implements WebRTCPeerConnection.
+ * In this case it forwards calls to our C++ class, but could be plain C,
+ * and you could use void *user for any kind of state struct pointer you have.
+ */
+godot_int get_connection_state_wp(const void *user) {
+	return (godot_int)((WebRTCPeerConnectionNative *)user)->_get_connection_state();
+}
+
+godot_error initialize_wp(void *user, const godot_dictionary *p_config) {
+	return (godot_error)(((WebRTCPeerConnectionNative *)user)->_initialize(*(Dictionary *)p_config));
+}
+
+godot_object *create_data_channel_wp(void *user, const char *p_channel, const godot_dictionary *p_channel_config) {
+	Object *ptr = ((WebRTCPeerConnectionNative *)user)->_create_data_channel(p_channel, *(Dictionary *)p_channel_config);
+	if (ptr) {
+		return ptr->_owner;
+	}
+	return nullptr;
+}
+
+godot_error create_offer_wp(void *user) {
+	return (godot_error)(((WebRTCPeerConnectionNative *)user)->_create_offer());
+}
+
+godot_error create_answer_wp(void *user) {
+	return GODOT_ERR_UNAVAILABLE; // Not implemented, not used yet.
+}
+
+godot_error set_remote_description_wp(void *user, const char *type, const char *sdp) {
+	return (godot_error)(((WebRTCPeerConnectionNative *)user)->_set_remote_description(type, sdp));
+}
+
+godot_error set_local_description_wp(void *user, const char *type, const char *sdp) {
+	return (godot_error)(((WebRTCPeerConnectionNative *)user)->_set_local_description(type, sdp));
+}
+
+godot_error add_ice_candidate_wp(void *user, const char *sdpMidName, int sdpMlineIndexName, const char *sdpName) {
+	return (godot_error)(((WebRTCPeerConnectionNative *)user)->_add_ice_candidate(sdpMidName, sdpMlineIndexName, sdpName));
+}
+
+godot_error poll_wp(void *user) {
+	return (godot_error)((WebRTCPeerConnectionNative *)user)->_poll();
+}
+
+void close_wp(void *user) {
+	((WebRTCPeerConnectionNative *)user)->_close();
+}
--- a/src/net/WebRTCPeerConnectionNative.hpp
+++ b/src/net/WebRTCPeerConnectionNative.hpp
@@ -0,0 +1,117 @@
+/*************************************************************************/
+/*  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.                */
+/*************************************************************************/
+
+#ifndef WEBRTC_PEER_NATIVE
+#define WEBRTC_PEER_NATIVE
+
+#include <Godot.hpp>
+#include <Reference.hpp>
+#include <WebRTCPeerConnectionGDNative.hpp>
+
+#include <net/godot_net.h>
+
+/* Forward declare interface functions */
+godot_int get_connection_state_wp(const void *);
+
+godot_error initialize_wp(void *, const godot_dictionary *);
+godot_object *create_data_channel_wp(void *, const char *, const godot_dictionary *);
+godot_error create_offer_wp(void *);
+godot_error create_answer_wp(void *);
+godot_error set_remote_description_wp(void *, const char *, const char *);
+godot_error set_local_description_wp(void *, const char *, const char *);
+godot_error add_ice_candidate_wp(void *, const char *, int, const char *);
+godot_error poll_wp(void *);
+void close_wp(void *);
+
+namespace godot {
+
+class WebRTCPeerConnectionNative : public godot::WebRTCPeerConnectionGDNative {
+	GODOT_CLASS(WebRTCPeerConnectionNative, godot::WebRTCPeerConnectionGDNative);
+
+protected:
+	godot_net_webrtc_peer_connection interface = {
+		{ 3, 1 },
+		this,
+
+		&get_connection_state_wp,
+
+		&initialize_wp,
+		&create_data_channel_wp,
+		&create_offer_wp,
+		&create_answer_wp,
+		&set_remote_description_wp,
+		&set_local_description_wp,
+		&add_ice_candidate_wp,
+		&poll_wp,
+		&close_wp,
+		NULL,
+	};
+
+public:
+	enum GatheringState {
+		GATHERING_STATE_NEW,
+		GATHERING_STATE_GATHERING,
+		GATHERING_STATE_COMPLETE,
+	};
+
+	enum SignalingState {
+		SIGNALING_STATE_STABLE,
+		SIGNALING_STATE_HAVE_LOCAL_OFFER,
+		SIGNALING_STATE_HAVE_REMOTE_OFFER,
+		SIGNALING_STATE_HAVE_LOCAL_PRANSWER,
+		SIGNALING_STATE_HAVE_REMOTE_PRANSWER,
+		SIGNALING_STATE_CLOSED,
+	};
+
+	static void _register_methods();
+	static const godot_gdnative_ext_net_3_2_api_struct *_net_api;
+
+	void _init();
+	void register_interface(const godot_net_webrtc_peer_connection *interface);
+
+	virtual ConnectionState _get_connection_state() const = 0;
+	virtual GatheringState _get_gathering_state() const = 0;
+	virtual SignalingState _get_signaling_state() const = 0;
+
+	virtual godot::Error _initialize(const godot::Dictionary &p_config) = 0;
+	virtual godot::Object *_create_data_channel(const godot::String &p_channel, const godot::Dictionary &p_channel_config) = 0;
+	virtual godot::Error _create_offer() = 0;
+	virtual godot::Error _set_remote_description(const godot::String &type, const godot::String &sdp) = 0;
+	virtual godot::Error _set_local_description(const godot::String &type, const godot::String &sdp) = 0;
+	virtual godot::Error _add_ice_candidate(const godot::String &sdpMidName, int64_t sdpMlineIndexName, const godot::String &sdpName) = 0;
+	virtual godot::Error _poll() = 0;
+	virtual void _close() = 0;
+
+	~WebRTCPeerConnectionNative();
+};
+
+}; // namespace godot
+
+#endif // WEBRTC_PEER_NATIVE
--- a/src/net/WebRTCPeerNative.cpp
+++ b/src/net/WebRTCPeerNative.cpp
@@ -1,77 +0,0 @@
-#include "WebRTCPeerNative.hpp"
-
-const godot_gdnative_ext_net_api_struct *WebRTCPeerNative::_net_api = NULL;
-
-void WebRTCPeerNative::register_interface(const godot_net_webrtc_peer *p_interface) {
-	ERR_FAIL_COND(!_net_api);
-	_net_api->godot_net_bind_webrtc_peer(_owner, p_interface);
-}
-
-void WebRTCPeerNative::_register_methods() {}
-
-void WebRTCPeerNative::_init() {
-	register_interface(&interface);
-}
-
-WebRTCPeerNative::~WebRTCPeerNative() {
-	if (_owner) {
-		register_interface(NULL);
-	}
-}
-
-/*
- * The C interface that implements WebRTCPeer.
- * In this case it forwards calls to our C++ class, but could be plain C,
- * and you could use void *user for any kind of state struct pointer you have.
- */
-godot_error get_packet_wp(void *user, const uint8_t **r_buffer, int *r_len) {
-	return ((WebRTCPeerNative *)user)->get_packet(r_buffer, r_len);
-}
-
-godot_error put_packet_wp(void *user, const uint8_t *p_buffer, int p_len) {
-	return ((WebRTCPeerNative *)user)->put_packet(p_buffer, p_len);
-}
-
-godot_int get_available_packet_count_wp(const void *user) {
-	return ((WebRTCPeerNative *)user)->get_available_packet_count();
-}
-
-godot_int get_max_packet_size_wp(const void *user) {
-	return ((WebRTCPeerNative *)user)->get_max_packet_size();
-}
-
-void set_write_mode_wp(void *user, godot_int write_mode) {
-	((WebRTCPeerNative *)user)->set_write_mode(write_mode);
-}
-
-godot_int get_write_mode_wp(const void *user) {
-	return ((WebRTCPeerNative *)user)->get_write_mode();
-}
-
-bool was_string_packet_wp(const void *user) {
-	return ((WebRTCPeerNative *)user)->was_string_packet();
-}
-
-godot_int get_connection_state_wp(const void *user) {
-	return ((WebRTCPeerNative *)user)->get_connection_state();
-}
-
-godot_error create_offer_wp(void *user) {
-	return ((WebRTCPeerNative *)user)->create_offer();
-}
-
-godot_error set_remote_description_wp(void *user, const char *type, const char *sdp) {
-	return ((WebRTCPeerNative *)user)->set_remote_description(type, sdp);
-}
-
-godot_error set_local_description_wp(void *user, const char *type, const char *sdp) {
-	return ((WebRTCPeerNative *)user)->set_local_description(type, sdp);
-}
-
-godot_error add_ice_candidate_wp(void *user, const char *sdpMidName, int sdpMlineIndexName, const char *sdpName) {
-	return ((WebRTCPeerNative *)user)->add_ice_candidate(sdpMidName, sdpMlineIndexName, sdpName);
-}
-
-godot_error poll_wp(void *user) {
-	return ((WebRTCPeerNative *)user)->poll();
-}
--- a/src/net/WebRTCPeerNative.hpp
+++ b/src/net/WebRTCPeerNative.hpp
@@ -1,80 +0,0 @@
-#ifndef WEBRTC_PEER_NATIVE
-#define WEBRTC_PEER_NATIVE
-
-#include <Godot.hpp>
-#include <Reference.hpp>
-#include <WebRTCPeerGDNative.hpp>
-
-#include <net/godot_net.h>
-
-/* Forward declare interface functions */
-godot_error get_packet_wp(void *, const uint8_t **, int *);
-godot_error put_packet_wp(void *, const uint8_t *, int);
-godot_int get_available_packet_count_wp(const void *);
-godot_int get_max_packet_size_wp(const void *);
-
-void set_write_mode_wp(void *, godot_int);
-godot_int get_write_mode_wp(const void *);
-bool was_string_packet_wp(const void *);
-godot_int get_connection_state_wp(const void *);
-
-godot_error create_offer_wp(void *);
-godot_error set_remote_description_wp(void *, const char *, const char *);
-godot_error set_local_description_wp(void *, const char *, const char *);
-godot_error add_ice_candidate_wp(void *, const char *, int, const char *);
-godot_error poll_wp(void *);
-
-class WebRTCPeerNative : public godot::WebRTCPeerGDNative {
-	GODOT_CLASS(WebRTCPeerNative, godot::WebRTCPeerGDNative);
-
-protected:
-	godot_net_webrtc_peer interface = {
-		{ 3, 1 },
-		this,
-
-		&get_packet_wp,
-		&put_packet_wp,
-		&get_available_packet_count_wp,
-		&get_max_packet_size_wp,
-
-		&set_write_mode_wp,
-		&get_write_mode_wp,
-		&was_string_packet_wp,
-		&get_connection_state_wp,
-
-		&create_offer_wp,
-		&set_remote_description_wp,
-		&set_local_description_wp,
-		&add_ice_candidate_wp,
-		&poll_wp,
-		NULL,
-	};
-
-public:
-	static void _register_methods();
-	static const godot_gdnative_ext_net_api_struct *_net_api;
-
-	void _init();
-	void register_interface(const godot_net_webrtc_peer *interface);
-
-	virtual void set_write_mode(godot_int mode) = 0;
-	virtual godot_int get_write_mode() const = 0;
-	virtual bool was_string_packet() const = 0;
-	virtual godot_int get_connection_state() const = 0;
-
-	virtual godot_error create_offer() = 0;
-	virtual godot_error set_remote_description(const char *type, const char *sdp) = 0;
-	virtual godot_error set_local_description(const char *type, const char *sdp) = 0;
-	virtual godot_error add_ice_candidate(const char *sdpMidName, int sdpMlineIndexName, const char *sdpName) = 0;
-	virtual godot_error poll() = 0;
-
-	/* PacketPeer */
-	virtual godot_error get_packet(const uint8_t **r_buffer, int *r_len) = 0;
-	virtual godot_error put_packet(const uint8_t *p_buffer, int p_len) = 0;
-	virtual godot_int get_available_packet_count() const = 0;
-	virtual godot_int get_max_packet_size() const = 0;
-
-	~WebRTCPeerNative();
-};
-
-#endif // WEBRTC_PEER_NATIVE
--- a/thirdparty/README.md
+++ b/thirdparty/README.md
@@ -0,0 +1,82 @@
+# Third party libraries
+
+Please keep categories (`##` level) listed alphabetically and matching their
+respective folder names. Use two empty lines to separate categories for
+readability.
+
+
+## json
+
+- Upstream: https://github.com/nlohmann/json
+- Version: 3.10.5 (4f8fba14066156b73f1189a2b8bd568bde5284c5, 2022)
+- License: MIT
+
+Module location:
+
+- thirdparty/libdatachannel/deps/json
+
+
+## libdatachannel
+
+- Upstream: https://github.com/paullouisageneau/libdatachannel
+- Version: 0.18.0 (084445012d6c63c9f2cc250d88df553aed2eb189, 2022)
+- License: MPL 2.0
+
+Module location:
+
+- thirdparty/libdatachannel
+
+
+# libjuice
+
+- Upstream: https://github.com/paullouisageneau/libjuice
+- Version: 1.1.0 (0dabc046cd23da6908749e4c6add834ec29a7c49, 2022)
+- License: MPL 2.0
+
+Module location:
+
+- thirdparty/libdatachannel/deps/libjuice
+
+
+## libsrtp
+
+- Upstream: https://github.com/cisco/libsrtp
+- Version: 2.4.2 (90d05bf8980d16e4ac3f16c19b77e296c4bc207b, 2021)
+- License: BSD-3-Clause
+
+Module location:
+
+- thirdparty/libdatachannel/deps/libsrtp
+
+
+## openssl
+
+- Upstream: git://git.openssl.org/openssl.git
+- Version: 3.0.7 (19cc035b6c6f2283573d29c7ea7f7d675cf750ce, 2022)
+- License: Apache 2.0
+
+Module location:
+
+- thirdparty/openssl
+
+
+## plog
+
+- Upstream: https://github.com/SergiusTheBest/plog
+- Version: git (d8461e9d473e59fbcc1f79eee021550dcf81e618, 2021)
+- License: MPL 2.0
+
+Module location:
+
+- thirdparty/libdatachannel/deps/plog
+
+
+## usrsctp
+
+- Upstream: https://github.com/sctplab/usrsctp
+- Version: git (7c31bd35c79ba67084ce029511193a19ceb97447, 2021)
+- License: BSD-3-Clause
+
+Module location:
+
+- thirdparty/libdatachannel/deps/usrsctp
--- a/thirdparty/libdatachannel
+++ b/thirdparty/libdatachannel
--- a/thirdparty/openssl
+++ b/thirdparty/openssl
--- a/webrtc/lib/.gitignore
+++ b/webrtc/lib/.gitignore
@@ -1,2 +0,0 @@
-*
-!.gitignore
Author	SHA1	Message	Date
Fabio Alessandrelli	5348407de9	Merge pull request #77 from Faless/bump/beta10 Update to Godot 4.0-beta10.	2022-12-29 17:30:51 +01:00
Fabio Alessandrelli	5002991511	Update to Godot 4.0-beta10.	2022-12-29 15:38:48 +01:00
Fabio Alessandrelli	0fc992e0d5	Merge pull request #76 from Faless/bump/beta9 Update to Godot 4.0 beta9	2022-12-19 22:11:33 +01:00
Fabio Alessandrelli	fbadff454c	Update to Godot 4.0 beta9	2022-12-19 20:42:56 +01:00
Fabio Alessandrelli	61a6d25c47	Merge pull request #75 from Faless/bump/beta8 Bump godot-cpp to beta8, libdatachannel to v0.18.0	2022-12-10 18:26:25 +01:00
Fabio Alessandrelli	dfaad6f5ba	Bump godot-cpp to beta8, libdatachannel to v0.18.0 libdatachannel and libjuice are now released under MPL 2.0. Dependencies has been refactored under a `thirdparty` folder similar to what we have in Godot, with a dedicated `thirdparty/README.md` containing details information on dependencies upstreams, versions, and licenses.	2022-12-10 17:13:59 +01:00
Fabio Alessandrelli	35bdd5efa7	Merge pull request #73 from Faless/bump/beta6 Update to Godot 4.0 beta6, and bump dependencies.	2022-11-28 20:19:47 +01:00
Fabio Alessandrelli	90aaa0b82e	Update to libdatachannel v0.17.12+git.	2022-11-28 17:54:19 +01:00
Fabio Alessandrelli	16f311844b	Update to OpenSSL 3.0.7.	2022-11-28 17:54:19 +01:00
Fabio Alessandrelli	dfb34df36e	Update to Godot 4.0-beta6	2022-11-28 17:54:19 +01:00
Fabio Alessandrelli	9715e73ae4	Merge pull request #74 from Faless/build/cache_and_paths [SCons] Fix caching and path detection.	2022-11-28 17:53:10 +01:00
Fabio Alessandrelli	2e9a25bb39	[SCons] Fix caching and path detection. Add version file depenencies to SSL and RTC targets. Disable OpenSSL caching since it causes issues as it doesn't properly cache generated header files. Add hack to prepend PATH and few other vars (should probably be added to upstream godot-cpp), and clone scons envs when building ssl/rtc (so that PATHs are properly setup).	2022-11-28 03:10:20 +01:00
Fabio Alessandrelli	6067addd96	Merge pull request #72 from JonathanPicques/patch-1 Rename osx to macos in webrtc.gdextension	2022-11-26 15:50:07 +01:00
Jonathan Picques	a3fbd33464	Rename osx to macos in webrtc.gdextension The plugin wouldn't work with Godot beta 5 because it expects a macos key instead of an osx	2022-11-26 13:56:06 +01:00
Fabio Alessandrelli	d697901f81	Merge pull request #70 from Faless/bump/beta5 Update to Godot 4.0-beta5	2022-11-19 11:08:34 +01:00
Fabio Alessandrelli	3eb7d0aa3b	Update to Godot 4.0-beta5	2022-11-19 01:43:24 +01:00
Fabio Alessandrelli	ecec40f59e	Merge pull request #68 from Faless/bump/beta4 Update to Godot 4.0-beta4.	2022-11-15 00:41:01 +01:00
Fabio Alessandrelli	37a289addf	Update to Godot 4.0-beta4.	2022-11-14 22:48:46 +01:00
Fabio Alessandrelli	1436024f59	Merge pull request #65 from Faless/bump/beta3 [Upstream] Update to Godot Beta 3	2022-10-17 22:42:33 +02:00
Fabio Alessandrelli	690b31e7dd	[Upstream] Update to Godot beta 3. Update build targets. Move release script out of CI yaml. Disable debug CI builds for Godot 3.x since they are mostly used for debugging the extension itself.	2022-10-17 20:59:33 +02:00
Fabio Alessandrelli	9b0a5d8b46	[CI] Update actions, add cache for faster builds.	2022-10-16 16:15:42 +02:00
Fabio Alessandrelli	1769730ef0	Merge pull request #63 from Faless/bump/beta2 [CPP] Bump godot-cpp to beta2 headers.	2022-10-10 11:49:36 +02:00
Fabio Alessandrelli	04898f2714	[CPP] Bump godot-cpp to beta2 headers.	2022-10-09 19:42:31 +02:00
Fabio Alessandrelli	d7fc6cde3b	Merge pull request #61 from Faless/bump/beta1 [Extension] Update to Godot 4.0 beta 1	2022-09-16 14:39:41 +02:00
Fabio Alessandrelli	1009e8bb1c	Add methods to get gathering and signaling state.	2022-09-16 13:07:06 +02:00
Fabio Alessandrelli	5fd359f674	Bump godot-cpp to Godot 4.0 beta1.	2022-09-16 13:07:06 +02:00
Fabio Alessandrelli	822e0532c2	Merge pull request #60 from Faless/bump/alpha16 Update to Godot alpha16	2022-09-11 18:26:08 +02:00
Fabio Alessandrelli	d8cbd14a28	Disable android 32 bits builds.	2022-09-11 15:34:08 +02:00
Fabio Alessandrelli	6e52fce986	Update sources to alpha16	2022-09-11 15:34:08 +02:00
Fabio Alessandrelli	a93af67d75	[godot-cpp] Bump to alpha16.	2022-09-11 14:48:51 +02:00
Fabio Alessandrelli	22ee6435a1	Update to libdatachannel 0.17.10+git.	2022-09-11 14:48:51 +02:00
Fabio Alessandrelli	b5d8a72ef8	Update to OpenSSL 3.0.5	2022-09-11 14:48:51 +02:00
Fabio Alessandrelli	2ad1bf1716	Merge pull request #57 from Faless/bump/4.0_alpha11 Bump godot-cpp to alpha11.	2022-07-06 13:24:04 +02:00
Fabio Alessandrelli	e683c79938	Bump godot-cpp to alpha11.	2022-07-06 11:45:03 +02:00
Fabio Alessandrelli	426ca6cc8e	Merge pull request #56 from Faless/fix/write_mode Fix default data channel write mode to binary.	2022-06-19 13:48:20 +02:00
Fabio Alessandrelli	9b53ef3325	Fix default data channel write mode to binary. It's the engine expected default, and the least surprising for the users since it allows any data to be sent, while text mode requires valid UTF.	2022-06-19 12:18:49 +02:00
Fabio Alessandrelli	e41d2903ad	Merge pull request #54 from Faless/fix/win32_mingw [Windows] Fix windows build with mingw.	2022-06-18 16:46:06 +02:00
Fabio Alessandrelli	f315912d85	[Windows] Fix windows build with mingw. Forces ".dll" extension for library when building with mingw. Override GDN_EXPORT which is incorrectly defined in the upstream gdnative headers (3.x) and godot-cpp include (4.0) when building for windows with mingw.	2022-06-18 14:35:51 +02:00
Fabio Alessandrelli	62ab2e59f8	Merge pull request #53 from Faless/fix/build_deps_target [SCons] Apply "target" to dependencies.	2022-06-18 03:00:48 +02:00
Fabio Alessandrelli	a2fc27f646	[SCons] Apply "target" to dependencies. Dependencies used to be built with the default option (release for OpenSSL, debug for libdachannel). They now follow the desired target (producing smaller binaries in release, and bigger in debug).	2022-06-18 02:00:18 +02:00
Fabio Alessandrelli	b2654cc2bd	Merge pull request #51 from Faless/libdatachannel_pr Switch to libdatachannel as RTC library. Add GDExtension support.	2022-06-16 11:32:10 +02:00
Fabio Alessandrelli	e19b370126	Use libdatachannel library, add Godot 4 support.	2022-06-15 21:38:12 +02:00
Fabio Alessandrelli	8c18112f5d	Merge pull request #43 from dsnopek/buffered-amount Add get_buffered_amount() to WebRTCDataChannel (GDNative)	2021-09-22 23:06:19 +02:00
Fabio Alessandrelli	c37cc530e7	Merge pull request #46 from Faless/issue_template Add issue templates for reporting bugs.	2021-07-26 15:39:53 +02:00
Fabio Alessandrelli	13ab33af36	Add issue templates for reporting bugs.	2021-07-26 13:19:29 +02:00
David Snopek	3bdf6cdc13	Add get_buffered_amount() to WebRTCDataChannel	2021-07-21 10:48:09 -05:00
Fabio Alessandrelli	072ba5c1d0	Merge pull request #40 from Faless/osx/arm64 Add OSX arm64 build.	2021-07-11 10:51:37 +02:00
Fabio Alessandrelli	7cb6d6c846	Add OSX arm64 build. Needs a more recent revision of godot-cpp, but can still use godot-headers from 3.2 . See CI script update for details.	2021-07-11 10:01:55 +02:00
Fabio Alessandrelli	c0b31562f5	Merge pull request #39 from Faless/style/clang_black Add static checks	2021-07-09 19:43:04 +02:00
Fabio Alessandrelli	69f92fa26c	Run clang-format on src/*	2021-07-09 18:55:32 +02:00
Fabio Alessandrelli	d06e536d12	Add copyright headers	2021-07-09 18:55:32 +02:00
Fabio Alessandrelli	68a892d9f3	run black -l 120 on SConstruct.	2021-07-09 18:55:32 +02:00
Fabio Alessandrelli	72b337e32c	static checks.	2021-07-09 18:55:32 +02:00
Fabio Alessandrelli	eeabf0a844	Merge pull request #38 from Faless/refactor/signals Refactor signals and obeserver, fixes answer creation.	2021-07-09 16:24:35 +02:00
Fabio Alessandrelli	04fbae6ce3	Properly wait success callback before creating answers.	2021-07-09 03:46:25 +02:00
Fabio Alessandrelli	ce3f086ec4	Move observers implementations into PeerConnection.	2021-07-09 03:45:45 +02:00
Fabio Alessandrelli	00ac03c8e7	Use a class instead of lambdas for signals.	2021-07-09 00:53:15 +02:00
Fabio Alessandrelli	fa5296a4e4	Merge pull request #37 from Faless/ci/auto [CI] Use organization's repository for automated builds.	2021-07-08 23:56:42 +02:00
Fabio Alessandrelli	189c353264	[CI] Use organization's repository for automated builds. Update README.md to reflect new build sources.	2021-07-08 23:04:16 +02:00
Fabio Alessandrelli	e44c42fde8	Merge pull request #36 from Faless/ci/single Setup CI for Android, iOS, Linux, macOS, Windows.	2021-07-06 16:27:59 +02:00
Fabio Alessandrelli	524fdde8f2	Setup CI for Android, iOS, Linux, macOS, Windows. Includes all supported architectures: * Android: - arm (neon) - arm64 - x86 - x64 * iOS: - arm - arm64 - x64 (simulator) * Linux - x86 - x64 * macOS - x64 * windows - x86 - x64 Use a single matrix for builds, then an extra step will package for release. Artefacts are generated for each platform/arch combination, along for the 2 zip containing the full `webrtc` and `webrtc_debug` plugin.	2021-07-06 15:57:55 +02:00
Fabio Alessandrelli	673a4c1a1c	Merge pull request #34 from Faless/build/optimization_flags Fix osx, android optimization flags.	2021-07-05 03:17:27 +02:00
Fabio Alessandrelli	cf98eb2e7a	Fix osx, android optimization flags. Will need to be also fixed in upstream godot-cpp.	2021-07-02 21:58:44 +02:00
Fabio Alessandrelli	7b92ab2a7b	Add missing iOS armv7 entry.	2021-07-02 18:11:35 +02:00
Fabio Alessandrelli	e120cc7ed6	Merge pull request #33 from Faless/bump/webrtc_4472 Bump webrtc to branch-heads/4472. Fixes signalling.	2021-07-02 15:50:08 +02:00
Fabio Alessandrelli	da20ebf397	Unified signalling thread.	2021-07-02 15:12:41 +02:00
Fabio Alessandrelli	3711ad23f6	Bump webrtc to branch-heads/4472.	2021-07-02 15:12:41 +02:00
Fabio Alessandrelli	001be78500	Merge pull request #32 from Faless/release/3.2_fix Fix API breakage after godot cpp 3.2 bump.	2021-07-02 00:39:52 +02:00
Fabio Alessandrelli	416ea27305	Fix API breakage after godot cpp 3.2 bump.	2021-07-02 00:36:41 +02:00
Fabio Alessandrelli	65bb4cb9ae	Merge pull request #31 from Faless/release/3.2 Update godot-cpp to tip of 3.2 branch.	2021-07-02 00:29:11 +02:00
Fabio Alessandrelli	3014c3099f	Update godot-cpp to tip of 3.2 branch.	2021-07-02 00:26:10 +02:00
Fabio Alessandrelli	c1c7ae5081	Merge pull request #30 from Faless/scons/mac_ios Add mac and ios platforms. Fix GDNLibrary.	2021-07-02 00:13:48 +02:00
Fabio Alessandrelli	9e287f7cee	Add mac and ios platforms. Fix GDNLibrary.	2021-07-01 23:58:01 +02:00
Fabio Alessandrelli	a374cf4510	Merge pull request #24 from rondao/add_android_build_support Add build support for Android	2021-07-01 07:34:03 +02:00
Fabio Alessandrelli	9ee98ff0e9	Merge pull request #28 from Faless/fix/python3 Fix gdns generation with python3.	2021-05-05 16:42:21 +02:00
Fabio Alessandrelli	f26a1d8e83	Fix gdns generation with python3. Python2 has reached end-of-life.	2021-05-05 16:40:22 +02:00
Rafael Rondao	7a62fe467b	Add build support for Android To build for Android, use platform=android. ANDROID_NDK_ROOT env variable needs to be defined. By default, it builds for armv7 with Api 18. To build for arm64v8 (or x86, x86_64), use android_arch=arm64v8. 64 bits requires at least Api level 21. If needed, you can change it with android_api_level=XX. Signed-off-by: Rafael Rondao <rafael.rondao@gmail.com>	2020-11-07 23:01:34 -03:00
Fabio Alessandrelli	74f2c78db5	Merge pull request #18 from MarkSort/support-server-platform set library paths for Server platform	2020-08-02 12:07:13 +02:00
Mark Achée	db6d416eba	set library paths for Server platform	2020-06-20 12:22:29 -05:00
Fabio Alessandrelli	5f9e74f2fb	Merge pull request #11 from Faless/fix/close_crash Fix crash when closing an invalid peerconnection.	2020-01-13 18:18:20 +01:00
Fabio Alessandrelli	bd8e139ccc	Fix crash when closing an invalid peerconnection.	2020-01-03 19:50:48 +01:00
Fabio Alessandrelli	61e45cb083	Merge pull request #10 from Faless/refactor/better-scons Better build script, readme	2020-01-03 19:43:01 +01:00
Fabio Alessandrelli	6983019cab	Initial README	2020-01-03 19:41:21 +01:00
Fabio Alessandrelli	54cbe83c56	Simplify webrtc lib folder structure	2020-01-03 19:41:21 +01:00
Fabio Alessandrelli	20f8f89c2c	Use submodule for godot-cpp	2020-01-03 19:41:21 +01:00
Fabio Alessandrelli	4b22741255	Build script also create gdnlib	2020-01-03 19:41:07 +01:00
Fabio Alessandrelli	5769d8b2de	Merge observers	2020-01-03 19:35:20 +01:00
Fabio Alessandrelli	423454086e	Merge pull request #3 from Faless/channels_pr Update to new DataChannel API, singleton load.	2019-05-21 14:08:30 +02:00
Fabio Alessandrelli	599ed98f6c	Small build system improvement	2019-05-16 12:08:39 +02:00
Fabio Alessandrelli	f5ebac4519	Working singleton load	2019-05-16 10:32:51 +02:00
Fabio Alessandrelli	3e64a42b14	Update to new DataChannel API. New WebRTCLibDataChannel class act as PacketPeer. Old WebRTCPeer (now WebRTCPeerConnection) now allows you to set configuration (STUN/TURN) and creating multiple data channels. Fixed many bugs and implemented most of the missing API.	2019-05-16 10:32:51 +02:00
Fabio Alessandrelli	f2cf2e5340	Merge pull request #2 from Faless/build/refactor Refactor Scons build script	2019-04-17 16:46:17 +02:00
Fabio Alessandrelli	1763d278e0	Better flags	2019-04-17 16:41:45 +02:00
Fabio Alessandrelli	8e46eed9e8	Better gitignores	2019-04-17 16:41:45 +02:00
Fabio Alessandrelli	6c0831b6c6	Refactor SCons build script	2019-04-17 15:47:51 +02:00
Fabio Alessandrelli	c30ddd9b22	Update GDNative bind. The GDNative bind was moved to the "next" version of the extention for compatibility reasons.	2019-04-12 01:34:33 +02:00