Einführung in OpenTK in Xamarin.Mac
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.
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
Vector
Strukturen,Matrix
,Quaternion
undBezier
ü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:
Geben Sie MacOpenTK
als Projektname folgendes ein:
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 :
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 MonoMacGameView
ersetzt. 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 API
sodass 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:
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 undRenderFrame
zu ändern. - Ändern Sie die Farbe des Dreiecks, wenn der Benutzer eine Taste in den
UpdateFrame
Ereignissen undRenderFrame
drückt, oder erstellen Sie Eine eigene benutzerdefinierteMonoMacGameView
Klasse, und überschreiben Sie dieKeyUp
Methoden undKeyDown
. - Bewegen Sie das Dreieck mithilfe der fähigen Tasten im Ereignis über den
UpdateFrame
Bildschirm. Hinweis: Verwenden Sie dieMatrix4.CreateTranslation
-Methode, um eine Übersetzungsmatrix zu erstellen, und rufen Sie dieGL.LoadMatrix
-Methode auf, um sie imRenderFrame
-Ereignis zu laden. - Verwenden Sie eine
for
Schleife, um mehrere Dreiecke imRenderFrame
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 dieGL.LoadMatrix
-Methode auf, um sie zu laden. Sie können auch dieVector2
Klassen ,Vector3
undVector4
Matrix4
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.