Bagikan melalui

Pengantar OpenTK di Xamarin.Mac

  • Artikel

OpenTK (Open Toolkit) adalah pustaka C# tingkat rendah tingkat lanjut yang membuat bekerja dengan OpenGL, OpenCL, dan OpenAL lebih mudah. OpenTK dapat digunakan untuk game, aplikasi ilmiah, atau proyek lain yang memerlukan grafis 3D, audio, atau fungsionalitas komputasi. Artikel ini memberikan pengenalan singkat tentang menggunakan OpenTK di aplikasi Xamarin.Mac.

Contoh eksekusi aplikasi

Dalam artikel ini, kita akan membahas dasar-dasar OpenTK dalam aplikasi Xamarin.Mac. Sangat disarankan agar Anda bekerja melalui artikel Hello, Mac terlebih dahulu, khususnya bagian Pengenalan Xcode dan Penyusun Antarmuka dan Outlet dan Tindakan , karena mencakup konsep dan teknik utama yang akan kita gunakan dalam artikel ini.

Anda mungkin ingin melihat kelas / metode Exposing C# keObjective-Cbagian dari dokumen Xamarin.Mac Internals juga, ini menjelaskan Register perintah dan Export yang digunakan untuk menyambungkan kelas C# Anda ke Objective-C objek dan Elemen UI.

Tentang OpenTK

Seperti yang dinyatakan di atas, OpenTK (Open Toolkit) adalah pustaka C# tingkat rendah canggih yang membuat bekerja dengan OpenGL, OpenCL, dan OpenAL lebih mudah. Menggunakan OpenTK di aplikasi Xamarin.Mac menyediakan fitur-fitur berikut:

  • Pengembangan Cepat - OpenTK menyediakan jenis data yang kuat dan dokumentasi sebaris untuk meningkatkan alur kerja pengkodan Anda dan menangkap kesalahan lebih mudah dan lebih cepat.
  • Integrasi Mudah - OpenTK dirancang untuk dengan mudah diintegrasikan dengan aplikasi .NET.
  • Lisensi Permisif - OpenTK didistribusikan berdasarkan Lisensi MIT/X11 dan benar-benar gratis.
  • Pengikatan Brankas Jenis yang Kaya - OpenTK mendukung versi terbaru OpenGL, OpenGL|ES, OpenAL, dan OpenCL dengan pemuatan ekstensi otomatis, pemeriksaan kesalahan, dan dokumentasi sebaris.
  • Opsi GUI Fleksibel - OpenTK menyediakan Game Window asli berperkinerja tinggi yang dirancang khusus untuk game dan Xamarin.Mac.
  • Kode yang Dikelola Penuh dan Sesuai CLS - OpenTK mendukung macOS versi 32-bit dan 64-bit tanpa pustaka yang tidak dikelola.
  • Toolkit Matematika 3D OpenTK memasok Vector, , MatrixQuaternion dan Bezier struktur melalui Toolkit Matematika 3D-nya.

OpenTK dapat digunakan untuk game, aplikasi ilmiah, atau proyek lain yang memerlukan grafis 3D, audio, atau fungsionalitas komputasi.

Untuk informasi selengkapnya, silakan lihat situs web Open Toolkit .

Mulai Cepat OpenTK

Sebagai pengantar cepat untuk menggunakan OpenTK di aplikasi Xamarin.Mac, kita akan membuat aplikasi sederhana yang membuka Tampilan Game, merender segitiga sederhana dalam tampilan itu dan melampirkan Tampilan Game ke Jendela Utama aplikasi Mac untuk menampilkan segitiga kepada pengguna.

Memulai Proyek Baru

Mulai Visual Studio untuk Mac dan buat solusi Xamarin.Mac baru. Pilih Aplikasi Kakao Umum>Mac>App>:

Menambahkan Aplikasi Kakao baru

Masukkan MacOpenTK untuk Nama Proyek:

Mengatur nama proyek

Klik tombol Buat untuk membuat proyek baru.

Termasuk OpenTK

Sebelum Anda dapat menggunakan Open TK dalam aplikasi Xamarin.Mac, Anda perlu menyertakan referensi ke rakitan OpenTK. Di Penjelajah Solusi, klik kanan folder Referensi dan pilih Edit Referensi....

Lakukan pemeriksaan oleh OpenTK dan klik tombol OK :

Mengedit referensi proyek

Menggunakan OpenTK

Dengan proyek baru dibuat, klik MainWindow.cs dua kali file di Penjelajah Solusi untuk membukanya untuk pengeditan. Buat kelas MainWindow terlihat seperti berikut:

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

Mari kita membahas kode ini secara rinci di bawah ini.

API yang diperlukan

Beberapa referensi diperlukan untuk menggunakan OpenTK di kelas Xamarin.Mac. Pada awal definisi, kami telah menyertakan pernyataan berikut using :

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

Set minimal ini akan diperlukan untuk kelas apa pun menggunakan OpenTK.

Menambahkan Tampilan Permainan

Selanjutnya kita perlu membuat Tampilan Game untuk berisi semua interaksi kita dengan OpenTK dan menampilkan hasilnya. Kami menggunakan kode berikut:

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

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

Di sini kami telah membuat Tampilan Game berukuran sama dengan Jendela Mac Utama kami dan mengganti Tampilan Konten jendela dengan yang baru MonoMacGameView. Karena kami mengganti konten jendela yang ada, Tampilan Yang Diberikan akan diubah ukurannya secara otomatis saat Windows Utama diubah ukurannya.

Menanggapi Peristiwa

Ada beberapa peristiwa default yang harus direspons oleh setiap Tampilan Game. Di bagian ini akan mencakup peristiwa utama yang diperlukan.

Peristiwa Pemuatan

Acara Load ini adalah tempat untuk memuat sumber daya dari disk seperti gambar, tekstur, atau musik. Untuk aplikasi pengujian sederhana kami, kami tidak menggunakan peristiwa, Load tetapi telah menyertakannya untuk referensi:

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

Peristiwa Mengubah Ukuran

Kejadian Resize harus dipanggil setiap kali Tampilan Game diubah ukurannya. Untuk aplikasi sampel kami, kami membuat GL Viewport berukuran sama dengan Tampilan Game kami (yang diubah ukurannya secara otomatis oleh Jendela Utama Mac) dengan kode berikut:

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

Peristiwa UpdateFrame

Peristiwa UpdateFrame ini digunakan untuk menangani input pengguna, memperbarui posisi objek, menjalankan fisika atau perhitungan AI. Untuk aplikasi pengujian sederhana kami, kami tidak menggunakan peristiwa, UpdateFrame tetapi telah menyertakannya untuk referensi:

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

Penting

Implementasi Xamarin.Mac dari OpenTK tidak menyertakan Input API, sehingga Anda harus menggunakan API yang disediakan Apple untuk menambahkan keyboard dan dukungan Mouse. Secara opsional Anda dapat membuat instans kustom dan MonoMacGameView mengambil KeyDown alih metode dan KeyUp .

Peristiwa RenderFrame

Peristiwa RenderFrame berisi kode yang digunakan untuk merender (menggambar) grafik Anda. Untuk contoh aplikasi kami, kami mengisi Tampilan Game dengan segitiga sederhana:

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

};

Biasanya kode render akan dengan panggilan ke GL.Clear untuk menghapus elemen yang ada sebelum menggambar elemen baru.

Penting

Untuk OpenTK versi Xamarin.Mac, jangan panggil SwapBuffers metode instans Anda MonoMacGameView di akhir kode penyajian Anda. Melakukannya akan menyebabkan Tampilan Game terhenti dengan cepat alih-alih menampilkan tampilan yang Anda render.

Menjalankan Tampilan Permainan

Dengan semua peristiwa yang diperlukan mendefinisikan dan Tampilan Game yang dilampirkan ke Jendela Mac Utama aplikasi kami, kami dibaca untuk menjalankan Tampilan Game dan menampilkan grafik kami. Gunakan kode berikut:

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

Kami meneruskan kecepatan bingkai yang diinginkan yang kami inginkan untuk diperbarui oleh Tampilan Game, misalnya kami telah memilih 60 bingkai per detik (kecepatan refresh yang sama dengan TV normal).

Mari kita jalankan aplikasi kita dan lihat outputnya:

Sampel output aplikasi

Jika kita mengubah ukuran jendela, Tampilan Game juga akan berada dan segitiga juga akan diubah ukurannya dan diperbarui secara real time.

Di mana Berikutnya?

Dengan dasar-dasar bekerja dengan OpenTk dalam aplikasi Xamarin.mac yang dilakukan, berikut adalah beberapa saran tentang apa yang harus dicoba berikutnya:

  • Coba ubah warna segitiga dan warna latar belakang Tampilan Game dalam Load peristiwa dan RenderFrame .
  • Buat warna perubahan segitiga saat pengguna menekan tombol dalam UpdateFrame peristiwa dan RenderFrame atau membuat kelas kustom MonoMacGameView Anda sendiri dan mengambil alih KeyUp metode dan KeyDown .
  • Buat segitiga bergerak melintasi layar menggunakan kunci sadar dalam peristiwa tersebut UpdateFrame . Petunjuk: gunakan Matrix4.CreateTranslation metode untuk membuat matriks terjemahan dan panggil GL.LoadMatrix metode untuk memuatnya dalam peristiwa.RenderFrame
  • Gunakan perulangan for untuk merender beberapa segitiga dalam peristiwa tersebut RenderFrame .
  • Putar kamera untuk memberikan tampilan segitiga yang berbeda dalam ruang 3D. Petunjuk: gunakan Matrix4.CreateTranslation metode untuk membuat matriks terjemahan dan panggil GL.LoadMatrix metode untuk memuatnya. Anda juga dapat menggunakan Vector2kelas , Vector3, Vector4 dan Matrix4 untuk manipulasi kamera.

Untuk contoh selengkapnya, silakan lihat repositori GitHub Sampel OpenTK. Ini berisi daftar resmi contoh penggunaan OpenTK. Anda harus menyesuaikan contoh-contoh ini untuk digunakan dengan OpenTK versi Xamarin.Mac.

Ringkasan

Artikel ini telah melihat sekilas bekerja dengan OpenTK dalam aplikasi Xamarin.Mac. Kami melihat cara membuat Jendela Game, cara melampirkan Jendela Game ke Jendela Mac dan cara merender bentuk sederhana di Jendela Game.