Teilen über

Einführung in OpenTK in Xamarin.Mac

  • Artikel

OpenTK (Das Open Toolkit) ist eine erweiterte C#-Bibliothek auf niedriger Ebene, die das Arbeiten mit OpenGL, OpenCL und OpenAL erleichtert. OpenTK kann für Spiele, wissenschaftliche Anwendungen oder andere Projekte verwendet werden, die 3D-Grafiken, Audio- oder Rechenfunktionen erfordern. Dieser Artikel enthält eine kurze Einführung in die Verwendung von OpenTK in einer Xamarin.Mac-App.

Beispiel für eine App-Ausführung

In diesem Artikel behandeln wir die Grundlagen von OpenTK in einer Xamarin.Mac-Anwendung. Es wird dringend empfohlen, dass Sie zuerst den Artikel "Hello, Mac " durcharbeiten, insbesondere die Abschnitte "Einführung in Xcode" und "Interface Builder " und "Outlets" und "Actions ", da es sich um wichtige Konzepte und Techniken handelt, die wir in diesem Artikel verwenden werden.

Möglicherweise möchten Sie sich auch die Verfügbarmachen von C#-Klassen /-Methoden imObjective-CAbschnitt des Xamarin.Mac Internals-Dokuments ansehen, und es werden die befehle Export erläutert, die Register zum Verketten Ihrer C#-Klassen mit Objective-C Objekten und UI-Elementen verwendet werden.

Informationen zu OpenTK

Wie oben erwähnt, ist OpenTK (The Open Toolkit) eine erweiterte C#-Bibliothek auf niedriger Ebene, die das Arbeiten mit OpenGL, OpenCL und OpenAL erleichtert. Die Verwendung von OpenTK in einer Xamarin.Mac-App bietet die folgenden Features:

  • Schnelle Entwicklung – OpenTK bietet starke Datentypen und Inlinedokumentationen, um Ihren Codierungsworkflow zu verbessern und Fehler einfacher und schneller abzufangen.
  • Einfache Integration – OpenTK wurde entwickelt, um problemlos in .NET-Anwendungen zu integrieren.
  • Promissive License - OpenTK wird unter den MIT/X11-Lizenzen verteilt und ist völlig kostenlos.
  • Rich,Type-Tresor Bindings - OpenTK unterstützt die neuesten Versionen von OpenGL, OpenGL|ES, OpenAL und OpenCL mit automatischem Laden der Erweiterung, Fehlerüberprüfung und Inlinedokumentation.
  • Flexible GUI-Optionen – OpenTK bietet das systemeigene Hochleistungsspielfenster, das speziell für Spiele und Xamarin.Mac entwickelt wurde.
  • Vollständig verwalteter, CLS-kompatibler Code – OpenTK unterstützt 32-Bit- und 64-Bit-Versionen von macOS ohne nicht verwaltete Bibliotheken.
  • 3D Math Toolkit OpenTK liefert Vector, MatrixQuaternion und Bezier strukturiert über das 3D Math Toolkit.

OpenTK kann für Spiele, wissenschaftliche Anwendungen oder andere Projekte verwendet werden, die 3D-Grafiken, Audio- oder Rechenfunktionen erfordern.

Weitere Informationen finden Sie auf der Open Toolkit-Website .

Schnellstart zu OpenTK

Als schnelle Einführung in die Verwendung von OpenTK in einer Xamarin.Mac-App erstellen wir eine einfache Anwendung, die eine Spielansicht öffnet, rendert ein einfaches Dreieck in dieser Ansicht und fügt die Spielansicht an das Hauptfenster der Mac-App an, um das Dreieck für den Benutzer anzuzeigen.

Starten eines neuen Projekts

Starten Sie Visual Studio für Mac, und erstellen Sie eine neue Xamarin.Mac-Lösung. Allgemeine Kakao-App für Mac-App>>> auswählen:

Hinzufügen einer neuen Cocoa-App

Geben Sie MacOpenTK für den Projektnamen ein:

Festlegen des Projektnamens

Klicken Sie auf die Schaltfläche "Erstellen ", um das neue Projekt zu erstellen.

Einschließen von OpenTK

Bevor Sie Open TK in einer Xamarin.Mac-Anwendung verwenden können, müssen Sie einen Verweis auf die OpenTK-Assembly einschließen. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Verweise", und wählen Sie "Verweise bearbeiten" aus.

Platzieren Sie eine Überprüfung, OpenTK und klicken Sie auf die Schaltfläche "OK ":

Bearbeiten der Projektverweise

Verwenden von OpenTK

Doppelklicken Sie bei der Erstellung des neuen Projekts auf die MainWindow.cs Datei in der Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen. Sorgen Sie dafür, dass die MainWindow Klasse wie folgt aussieht:

using System;
using System.Drawing;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
using OpenTK.Platform.MacOS;
using Foundation;
using AppKit;
using CoreGraphics;

namespace MacOpenTK
{
    public partial class MainWindow : NSWindow
    {
        #region Computed Properties
        public MonoMacGameView Game { get; set; }
        #endregion

        #region Constructors
        public MainWindow (IntPtr handle) : base (handle)
        {
        }

        [Export ("initWithCoder:")]
        public MainWindow (NSCoder coder) : base (coder)
        {
        }
        #endregion

        #region Override Methods
        public override void AwakeFromNib ()
        {
            base.AwakeFromNib ();

            // Create new Game View and replace the window content with it
            Game = new MonoMacGameView(ContentView.Frame);
            ContentView = Game;
            Game.OpenGLContext.View = Game;

            // Wire-up any required Game events
            Game.Load += (sender, e) =>
            {
                // TODO: Initialize settings, load textures and sounds here
            };

            Game.Resize += (sender, e) =>
            {
                // Adjust the GL view to be the same size as the window
                GL.Viewport(0, 0, Game.Size.Width, Game.Size.Height);
            };

            Game.UpdateFrame += (sender, e) =>
            {
                // TODO: Add any game logic or physics
            };

            Game.RenderFrame += (sender, e) =>
            {
                // Setup buffer
                GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
                GL.MatrixMode(MatrixMode.Projection);

                // Draw a simple triangle
                GL.LoadIdentity();
                GL.Ortho(-1.0, 1.0, -1.0, 1.0, 0.0, 4.0);
                GL.Begin(BeginMode.Triangles);
                GL.Color3(Color.MidnightBlue);
                GL.Vertex2(-1.0f, 1.0f);
                GL.Color3(Color.SpringGreen);
                GL.Vertex2(0.0f, -1.0f);
                GL.Color3(Color.Ivory);
                GL.Vertex2(1.0f, 1.0f);
                GL.End();

            };

            // Run the game at 60 updates per second
            Game.Run(60.0);
        }
        #endregion
    }
}

Lassen Sie uns diesen Code im Detail unten durchgehen.

Erforderliche APIs

Es sind mehrere Verweise erforderlich, um OpenTK in einer Xamarin.Mac-Klasse zu verwenden. Am Anfang der Definition haben wir die folgenden using Anweisungen eingefügt:

using System;
using System.Drawing;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
using OpenTK.Platform.MacOS;
using Foundation;
using CoreGraphics;

Dieser minimale Satz ist für jede Klasse mit OpenTK erforderlich.

Hinzufügen der Spielansicht

Als Nächstes müssen wir eine Spielansicht erstellen, um alle interaktionen mit OpenTK zu enthalten und die Ergebnisse anzuzeigen. Wir haben den folgenden Code verwendet:

public MonoMacGameView Game { get; set; }
...

// Create new Game View and replace the window content with it
Game = new MonoMacGameView(ContentView.Frame);
ContentView = Game;

Hier haben wir die Spielansicht zur gleichen Größe wie unser Haupt-Mac-Fenster gemacht und die Inhaltsansicht des Fensters durch das neue MonoMacGameViewersetzt. Da wir den vorhandenen Fensterinhalt ersetzt haben, wird die Größe unserer "Gegebenen Ansicht" automatisch geändert, wenn die Größe des Hauptfensters geändert wird.

Reagieren auf Ereignisse

Es gibt mehrere Standardereignisse, auf die jede Spielansicht reagieren sollte. In diesem Abschnitt werden die erforderlichen Standard Ereignisse behandelt.

Das Load-Ereignis

Das Load Ereignis ist der Ort zum Laden von Ressourcen von Datenträgern wie Bildern, Texturen oder Musik. Für unsere einfache, Test-App verwenden wir das Load Ereignis nicht, haben es jedoch zur Referenz hinzugefügt:

Game.Load += (sender, e) =>
{
    // TODO: Initialize settings, load textures and sounds here
};

Das Resize-Ereignis

Das Resize Ereignis sollte jedes Mal aufgerufen werden, wenn die Größe der Spielansicht geändert wird. Für unsere Beispiel-App machen wir den GL Viewport mit dem folgenden Code zur gleichen Größe wie unsere Spielansicht (die automatisch vom Mac-Hauptfenster angepasst wird):

Game.Resize += (sender, e) =>
{
    // Adjust the GL view to be the same size as the window
    GL.Viewport(0, 0, Game.Size.Width, Game.Size.Height);
};

Das UpdateFrame-Ereignis

Das UpdateFrame Ereignis wird verwendet, um Benutzereingaben zu verarbeiten, Objektpositionen zu aktualisieren, Physik- oder KI-Berechnungen auszuführen. Für unsere einfache, Test-App verwenden wir das UpdateFrame Ereignis nicht, haben es jedoch zur Referenz hinzugefügt:

Game.UpdateFrame += (sender, e) =>
{
    // TODO: Add any game logic or physics
};

Wichtig

Die Xamarin.Mac-Implementierung von OpenTK enthält nicht die Input API, daher müssen Sie die von Apple bereitgestellten APIs verwenden, um Tastatur- und Mausunterstützung hinzuzufügen. Optional können Sie eine benutzerdefinierte Instanz der MonoMacGameView Und außer Kraft setzen und die KeyDownKeyUp Methoden außer Kraft setzen.

RenderFrame-Ereignis

Das RenderFrame Ereignis enthält den Code, der zum Rendern (Zeichnen) Ihrer Grafiken verwendet wird. Für unsere Beispiel-App füllen wir die Spielansicht mit einem einfachen Dreieck:

Game.RenderFrame += (sender, e) =>
{
    // Setup buffer
    GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
    GL.MatrixMode(MatrixMode.Projection);

    // Draw a simple triangle
    GL.LoadIdentity();
    GL.Ortho(-1.0, 1.0, -1.0, 1.0, 0.0, 4.0);
    GL.Begin(BeginMode.Triangles);
    GL.Color3(Color.MidnightBlue);
    GL.Vertex2(-1.0f, 1.0f);
    GL.Color3(Color.SpringGreen);
    GL.Vertex2(0.0f, -1.0f);
    GL.Color3(Color.Ivory);
    GL.Vertex2(1.0f, 1.0f);
    GL.End();

};

Normalerweise wird der Rendercode mit einem Aufruf zum GL.Clear Entfernen vorhandener Elemente verwendet, bevor die neuen Elemente gezeichnet werden.

Wichtig

Für die Xamarin.Mac-Version von OpenTK rufen Sie die SwapBuffers Methode Ihrer MonoMacGameView Instanz nicht am Ende des Renderingcodes auf. Dies bewirkt, dass die Spielansicht schnell blinkt, anstatt die gerenderte Ansicht anzuzeigen.

Ausführen der Spielansicht

Wenn alle erforderlichen Ereignisse definiert und die Spielansicht an das Haupt-Mac-Fenster unserer App angefügt ist, lesen wir, um die Spielansicht auszuführen und unsere Grafiken anzuzeigen. Verwenden Sie den folgenden Code:

// Run the game at 60 updates per second
Game.Run(60.0);

Wir übergeben die gewünschte Bildfrequenz, bei der die Spielansicht aktualisiert werden soll, z. B. haben wir Frames pro Sekunde ausgewählt 60 (die gleiche Aktualisierungsrate wie normale TV).

Lassen Sie uns unsere App ausführen und die Ausgabe anzeigen:

Beispiel für die App-Ausgabe

Wenn wir die Größe unseres Fensters ändern, befindet sich auch die Spielansicht, und das Dreieck wird auch in Echtzeit geändert und aktualisiert.

Wo geht's weiter?

Mit den Grundlagen der Arbeit mit OpenTk in einer Xamarin.mac-Anwendung sind hier einige Vorschläge für das nächste Ausprobieren:

  • Versuchen Sie, die Farbe des Dreiecks und die Hintergrundfarbe der Spielansicht in den Load und RenderFrame Ereignissen zu ändern.
  • Ändern Sie die Farbe des Dreiecks, wenn der Benutzer eine Taste in den UpdateFrame Und-Ereignissen RenderFrame drückt, oder erstellen Sie eine eigene benutzerdefinierte MonoMacGameView Klasse, und überschreiben Sie die und KeyDown die KeyUp Methoden.
  • Bewegen Sie das Dreieck über den Bildschirm, indem Sie die fähigen Tasten im UpdateFrame Ereignis verwenden. Hinweis: Verwenden Sie die Matrix4.CreateTranslation Methode, um eine Übersetzungsmatrix zu erstellen und die GL.LoadMatrix Methode aufzurufen, um sie im RenderFrame Ereignis zu laden.
  • Verwenden Sie eine for Schleife, um mehrere Dreiecke im RenderFrame Ereignis zu rendern.
  • Drehen Sie die Kamera, um eine andere Ansicht des Dreiecks im 3D-Raum zu erhalten. Hinweis: Verwenden Sie die Matrix4.CreateTranslation Methode, um eine Übersetzungsmatrix zu erstellen und die GL.LoadMatrix Methode aufzurufen, um sie zu laden. Sie können auch die Vector2Klassen und Vector3Vector4Matrix4 Die Klassen für Kameramanipulationen verwenden.

Weitere Beispiele finden Sie im GitHub-Repository von OpenTK-Beispielen. Es enthält eine offizielle Liste von Beispielen für die Verwendung von OpenTK. Sie müssen diese Beispiele für die Verwendung mit der Xamarin.Mac-Version von OpenTK anpassen.

Zusammenfassung

Dieser Artikel hat einen schnellen Blick auf die Arbeit mit OpenTK in einer Xamarin.Mac-Anwendung gemacht. Wir haben gesehen, wie Sie ein Spielfenster erstellen, das Spielfenster an ein Mac-Fenster anfügen und wie sie eine einfache Form im Spielfenster rendern.