C#-einheitliches Render-Streaming mit WebRTC für bidirektionale Textnachrichten vom Unity-Client zum JavaScript-Server

Ermöglichen der Echtzeitkommunikation zwischen Unity und JavaScript mithilfe von WebRTC

Angesichts der wachsenden Nachfrage nach Echtzeitkommunikation in Anwendungen nutzen Entwickler WebRTC, um Video, Audio und Daten nahtlos zu übertragen. In diesem Zusammenhang bietet Unity Render Streaming ein leistungsstarkes Framework zum Streamen von Videos von einem JavaScript-Server an einen Unity-Client. Allerdings kann die Einrichtung einer bidirektionalen Kommunikation – etwa das Zurücksenden von Textnachrichten von Unity an den JavaScript-Server – eine Herausforderung darstellen.

In diesem Projekt möchten wir eine Streaming-App erstellen, indem wir das Unity Render Streaming-Plugin zusammen mit dem WebRTC-Protokoll verwenden. Nachdem der Video-Streaming-Teil erfolgreich konfiguriert wurde, besteht der nächste Schritt darin, den Datenaustausch über einen RTCDataChannel zu aktivieren. Dadurch können während aktiver Videostreams Textnachrichten vom Unity-Client gesendet werden.

Wir werden untersuchen, wie Sie vorhandene Codebeispiele ändern können, um diese Anforderungen zu erfüllen. Die JavaScript-basierte Web-App verwaltet das Video-Streaming, während der Unity-Client versucht, eine Beispielnachricht wie „Hello World“ zurück an den Server zu senden. Wir gehen die aufgetretenen Konfigurationsherausforderungen und ihre möglichen Lösungen durch.

In diesem Artikel werden auch Probleme wie fehlende Namespaces und ungelöste Referenzen in Unity besprochen. Wir beurteilen, ob der aktuelle Code auf dem richtigen Weg ist und bieten Lösungen zur Behebung häufiger Probleme, wie z. B. des Fehlers im Zusammenhang mit „SingleConnection“. Am Ende wollen wir mithilfe von WebRTC eine reibungslose, bidirektionale Textnachrichten-Pipeline zwischen Unity und JavaScript einrichten.

Aufbau eines Unity-zu-JavaScript-Messaging-Systems mit WebRTC

Das Ziel dieses Projekts ist die Nutzung der Unity-Render-Streaming Plugin mit WebRTC, um Videos von einem JavaScript-Server an einen Unity-Client zu übertragen und gleichzeitig Datennachrichten von Unity zurückzusenden. Der erste Schritt im JavaScript-Skript besteht darin, einen Medienstream einzurichten. Wir verwenden die Methode „captureStream()“, um Videoinhalte von einem HTML5-Element zu streamen, und ein RTCPeerConnection Das Objekt verwaltet die Verbindung zwischen den beiden Peers. Innerhalb dieser Verbindung entsteht ein DataChannel, der die Übertragung nicht-medialer Daten (z. B. Text) neben dem Videostream ermöglicht.

Auf der Unity-Seite initialisieren wir die WebRTC-Verbindung im Skript „ReceiverSample.cs“, indem wir eine einrichten RTCDataChannel. Dieser Kanal ist für das Senden und Empfangen von Textdaten an den JavaScript-Server verantwortlich. Eine Coroutine-Funktion wird verwendet, um die Nachricht „Hello World“ wiederholt alle zwei Sekunden zu senden, nur wenn der Kanalstatus „Offen“ ist. Wenn der DataChannel auf dem JavaScript-Server eine Nachricht empfängt, protokolliert er den Inhalt in der Konsole, um die erfolgreiche Verbindung zu bestätigen.

Ein kritisches Problem, das während dieses Prozesses hervorgehoben wurde, ist der fehlende Verweis auf den „SingleConnection“-Namespace im Unity-Code, der zu Kompilierungsfehlern führt. Dies deutet darauf hin, dass entweder das erforderliche Paket fehlt oder eine falsche Abhängigkeit in der Projektkonfiguration besteht. Um dieses Problem zu beheben, empfehlen wir zu überprüfen, ob alle erforderlichen Abhängigkeiten, wie z. B. das Unity WebRTC-Paket, korrekt installiert und referenziert sind. Wenn das Paket nicht verfügbar ist, muss die Klasse möglicherweise durch einen Standard ersetzt werden RTCPeerConnection Objekt.

Schließlich stellt der Fehlerbehandlungsmechanismus für beide Skripte sicher, dass fehlgeschlagene Verbindungen in der Konsole gemeldet werden, was beim Debuggen hilft. Das Unity-Skript enthält eine „StartCoroutine()“-Funktion zur Verwaltung asynchroner Nachrichtenübermittlung, die bei der Aufrechterhaltung des Echtzeit-Datenaustauschs nützlich ist, ohne andere Prozesse zu blockieren. Wir verwenden außerdem die Ereignisse „OnOpen“ und „OnClose“, um den Status des DataChannels zu überwachen und sicherzustellen, dass Nachrichten nur gesendet werden, wenn die Verbindung stabil ist. Dieser modulare Aufbau stellt sicher, dass der Code problemlos erweitert oder geändert werden kann, und bietet einen soliden Ausgangspunkt für die Erstellung komplexerer Streaming-Anwendungen mit Unity und WebRTC.

// sendvideo.js - JavaScript Server-Side Code
import * as Logger from "../../module/logger.js";
export class SendVideo {
  constructor(localVideoElement, remoteVideoElement) {
    this.localVideo = localVideoElement;
    this.remoteVideo = remoteVideoElement;
    this.peerConnection = new RTCPeerConnection();
    this.dataChannel = this.peerConnection.createDataChannel("myDataChannel");
  }
  async startLocalVideo() {
    const stream = document.createElement('video').captureStream();
    this.localVideo.srcObject = stream;
    await this.localVideo.play();
    this.peerConnection.createOffer().then(offer => {
      this.peerConnection.setLocalDescription(offer);
    });
  }
}

// ReceiverSample.cs - Unity Client Code
using System.Collections;
using UnityEngine;
using Unity.WebRTC;
public class ReceiverSample : MonoBehaviour {
  private RTCDataChannel dataChannel;
  void Start() { StartCoroutine(InitializeConnection()); }
  IEnumerator InitializeConnection() {
    var connection = new RTCPeerConnection();
    dataChannel = connection.CreateDataChannel("myDataChannel");
    dataChannel.OnOpen += OnChannelOpen;
    yield return null;
  }
  void OnChannelOpen() { StartCoroutine(SendMessageLoop()); }
  IEnumerator SendMessageLoop() {
    while (dataChannel.ReadyState == RTCDataChannelState.Open) {
      dataChannel.Send("Hello World");
      yield return new WaitForSeconds(2);
    }
  }
}

// Adjustments to avoid missing reference issues in ReceiverSample.cs
using Unity.WebRTC;
public class FixedReceiverSample : MonoBehaviour {
  private RTCPeerConnection peerConnection;
  private RTCDataChannel dataChannel;
  void Start() { InitializeWebRTC(); }
  void InitializeWebRTC() {
    peerConnection = new RTCPeerConnection();
    dataChannel = peerConnection.CreateDataChannel("myDataChannel");
    dataChannel.OnOpen += () => Debug.Log("DataChannel open!");
    peerConnection.CreateOffer().ContinueWith(offer => {
      peerConnection.SetLocalDescription(offer.Result);
    });
  }
}

// DataChannelTest.cs - Unity Unit Test
using NUnit.Framework;
using Unity.WebRTC;
public class DataChannelTest {
  [Test]
  public void TestDataChannelCommunication() {
    var connection = new RTCPeerConnection();
    var channel = connection.CreateDataChannel("testChannel");
    bool messageReceived = false;
    channel.OnMessage += message => {
      messageReceived = message == "Hello World";
    };
    channel.Send("Hello World");
    Assert.IsTrue(messageReceived);
  }
}

Erkundung der Herausforderungen bei der Datenübertragung bei Unity- und WebRTC-Streaming

Zusätzlich zum Video-Streaming ist die Aktivierung möglich Datenkommunikation zwischen einem Unity-Client und einem JavaScript-Server mithilfe von WebRTC eröffnet neue Möglichkeiten. Allerdings ist die Implementierung einer solchen Kommunikation nicht immer einfach, insbesondere wenn Sie das Unity Render Streaming-Plugin integrieren. Ein häufiges Problem ist die ordnungsgemäße Einrichtung und Verwaltung RTCDataChannel für nahtlose Textkommunikation. In unserem Beispiel sollte der Unity-Client in der Lage sein, eine „Hello World“-Nachricht an den JavaScript-Server zurückzusenden. Dieser Schritt erfordert einen sorgfältigen Umgang sowohl mit der Skriptumgebung von Unity als auch mit den Protokollnuancen von WebRTC.

Eine wichtige Herausforderung betrifft das Abhängigkeitsmanagement in Unity. Fehler wie der fehlende „SingleConnection“-Namespace in unserem „ReceiverSample.cs“-Code verdeutlichen die Notwendigkeit, sicherzustellen, dass alle erforderlichen Plugins, einschließlich WebRTC, korrekt installiert sind. Hier empfiehlt es sich, die Kompatibilität zwischen der Unity-Version und der verwendeten Plugin-Version zu prüfen. Das Problem könnte auch auf veraltete oder fehlende Unity Render Streaming-Komponenten zurückzuführen sein, die richtig konfiguriert werden müssen Verbindung Objekte.

Neben technischen Problemen ist die Latenz zwischen Unity und JavaScript über WebRTC ein weiterer zu untersuchender Aspekt. Während WebRTC eine Kommunikation mit geringer Latenz bietet, können Netzwerkbedingungen dennoch die Nachrichtenübermittlung beeinträchtigen. Die Verwendung von Coroutinen in Unity ermöglicht eine nicht blockierende Nachrichtenzustellung und stellt sicher, dass das Senden von Textdaten (z. B. über „StartCoroutine“) das Video-Streaming nicht unterbricht. Das Testen der Stabilität der Verbindung über „RTCDataChannelState“ ist eine weitere wichtige Vorgehensweise, um sicherzustellen, dass Nachrichten nur gesendet werden, wenn der Kanal aktiv ist. Diese Strategien tragen dazu bei, die Leistung zu optimieren und ein besseres Benutzererlebnis in Echtzeitanwendungen sicherzustellen.