Einführung in OpenTK in Xamarin.Mac

  • Artikel

OpenTK (Das Open Toolkit) ist eine erweiterte C#-Bibliothek auf niedriger Ebene, die die Arbeit 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 bietet eine kurze Einführung in die Verwendung von OpenTK in einer Xamarin.Mac-App.

Beispiel für eine App-Ausführung

In diesem Artikel werden die Grundlagen von OpenTK in einer Xamarin.Mac-Anwendung behandelt. 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 Aktionen , da er wichtige Konzepte und Techniken behandelt, die wir in diesem Artikel verwenden werden.

Möglicherweise sollten Sie auch einen Blick auf den Abschnitt Verfügbarmachen von C#-Klassen/-Methoden für Objective-C das Xamarin.Mac Internals-Dokument werfen. Darin werden die Befehle und Export erläutert, die Register zum Verknüpfen Ihrer C#-Klassen mit Objective-C Objekten und UI-Elementen verwendet werden.

Informationen zu OpenTK

Wie bereits erwähnt, ist OpenTK (The Open Toolkit) eine erweiterte C#-Bibliothek auf niedriger Ebene, die die Arbeit 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 Inlinedokumentation, um Ihren Codierungsworkflow zu verbessern und Fehler einfacher und früher abzufangen.
  • Einfache Integration : OpenTK wurde für die einfache Integration in .NET-Anwendungen entwickelt.
  • Permissive License : OpenTK wird unter den MIT/X11-Lizenzen verteilt und ist völlig kostenlos.
  • Rich, Type-Safe Bindings : OpenTK unterstützt die neuesten Versionen von OpenGL, OpenGL|ES, OpenAL und OpenCL mit automatischem Laden von Erweiterungen, Fehlerüberprüfung und Inlinedokumentation.
  • Flexible GUI-Optionen : OpenTK bietet das native, leistungsstarke Spielfenster, das speziell für Spiele und Xamarin.Mac entwickelt wurde.
  • Vollständig verwaltet, CLS-Compliant Code : OpenTK unterstützt 32-Bit- und 64-Bit-Versionen von macOS ohne nicht verwaltete Bibliotheken.
  • 3D Math Toolkit OpenTK stellt VectorStrukturen, Matrix, Quaternion und Bezier über das 3D Math Toolkit bereit.

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 .

OpenTK-Schnellstart

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

Starten eines neuen Projekts

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

Hinzufügen einer neuen Cocoa-App

Geben Sie MacOpenTK als Projektname folgendes 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.

Setzen Sie eine Überprüfung durch 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 im Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen. Lassen Sie die MainWindow Klasse wie folgt aussehen:

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
    }
}

Sehen wir uns diesen Code weiter unten im Detail an.

Erforderliche APIs

Für die Verwendung von OpenTK in einer Xamarin.Mac-Klasse sind mehrere Verweise erforderlich. Zu Beginn 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 Mindestsatz ist für jede Klasse erforderlich, die OpenTK verwendet.

Hinzufügen der Spielansicht

Als Nächstes müssen wir eine Spielansicht erstellen, die unsere gesamte Interaktion mit OpenTK enthält und die Ergebnisse anzeigt. 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 auf die gleiche Größe wie unser Mac-Hauptfenster gesetzt und die Inhaltsansicht des Fensters durch das neue MonoMacGameViewersetzt. Da wir den vorhandenen Fensterinhalt ersetzt haben, wird die Größe der angezeigten 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, sondern haben es als Referenz eingefü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 stellen wir den GL Viewport mit dem folgenden Code auf dieselbe Größe wie die Spielansicht (die vom Mac-Hauptfenster automatisch geändert wird) her:

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, sondern haben es als Referenz eingefügt:

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

Wichtig

Die Xamarin.Mac-Implementierung von OpenTK enthält nicht , Input APIsodass Sie die von Apple bereitgestellten APIs verwenden müssen, um Tastatur- und Mausunterstützung hinzuzufügen. Optional können Sie eine benutzerdefinierte instance der MonoMacGameView -Methode erstellen und die KeyDown Methoden und KeyUp überschreiben.

Das 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();

};

In der Regel wird der Rendercode mit einem Aufruf von GL.Clear ausgeführt, um alle vorhandenen Elemente zu entfernen, bevor die neuen Elemente gezeichnet werden.

Wichtig

Rufen Sie für die Xamarin.Mac-Version von OpenTK nicht die SwapBuffers -Methode Ihres MonoMacGameView instance am Ende des Renderingcodes auf. Dies führt dazu, dass die Spielansicht schnell strobiert, anstatt Ihre gerenderte Ansicht anzuzeigen.

Ausführen der Spielansicht

Da alle erforderlichen Ereignisse definiert sind und die Spielansicht an das Mac-Hauptfenster unserer App angefügt ist, werden wir gelesen, 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. Für unser Beispiel haben wir Frames pro Sekunde ausgewählt 60 (die gleiche Aktualisierungsrate wie normales TV).

Führen Sie unsere App aus, und sehen Sie sich die Ausgabe an:

Beispiel für die App-Ausgabe

Wenn wir die Größe des Fensters ändern, befindet sich auch die Spielansicht, und die Größe des Dreiecks wird ebenfalls in Echtzeit geändert und aktualisiert.

Wohin geht es als Nächstes?

Nachdem die Grundlagen der Arbeit mit OpenTk in einer Xamarin.mac-Anwendung abgeschlossen sind, finden Sie hier einige Vorschläge, was Sie als Nächstes ausprobieren können:

  • Versuchen Sie, die Farbe des Dreiecks und die Hintergrundfarbe der Spielansicht in den Load Ereignissen und RenderFrame zu ändern.
  • Ändern Sie die Farbe des Dreiecks, wenn der Benutzer eine Taste in den UpdateFrame Ereignissen und RenderFrame drückt, oder erstellen Sie Eine eigene benutzerdefinierte MonoMacGameView Klasse, und überschreiben Sie die KeyUp Methoden und KeyDown .
  • Bewegen Sie das Dreieck mithilfe der fähigen Tasten im Ereignis über den UpdateFrame Bildschirm. Hinweis: Verwenden Sie die Matrix4.CreateTranslation -Methode, um eine Übersetzungsmatrix zu erstellen, und rufen Sie die GL.LoadMatrix -Methode auf, 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 rufen Sie die GL.LoadMatrix -Methode auf, um sie zu laden. Sie können auch die Vector2Klassen , Vector3und Vector4Matrix4 für Kamerabearbeitungen verwenden.

Weitere Beispiele finden Sie im GitHub-Repository OpenTK-Beispiele . 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.

Ein komplexeres Xamarin.Mac-Beispiel für eine OpenTK-Implementierung finden Sie in unserem MonoMacGameView-Beispiel .

Zusammenfassung

In diesem Artikel wird die Arbeit mit OpenTK in einer Xamarin.Mac-Anwendung schnell erläutert. Wir haben erfahren, wie Sie ein Spielfenster erstellen, das Spielfenster an ein Mac-Fenster anfügen und eine einfache Form im Spielfenster rendern.