Introducción a OpenTK en Xamarin.Mac

OpenTK (The Open Toolkit) es una biblioteca avanzada de C# de bajo nivel que facilita el trabajo con OpenGL, OpenCL y OpenAL. OpenTK se puede usar para juegos, aplicaciones científicas u otros proyectos que requieren gráficos 3D, audio o funcionalidad computacional. En este artículo se proporciona una breve introducción al uso de OpenTK en una aplicación de Xamarin.Mac.

En este artículo, se tratarán los conceptos básicos de OpenTK en una aplicación de Xamarin.Mac. Se recomienda encarecidamente que trabaje primero en el artículo Hello, Mac, en concreto en las secciones Introduction to Xcode and Interface Builder and Outlets and Actions (Introducción a Xcode y Interface Builder y salidas y acciones), ya que trata los conceptos y técnicas clave que se usarán en este artículo.

También puede echar un vistazo a la sección del documento Exposing C# classes / methods to Objective-CExposing C# classes / methods to Objective-C internos de Xamarin.Mac), donde se explican los comandos y que se usan para conectar las clases de C# a objetos y elementos de interfaz de RegisterExportObjective-C usuario.

Acerca de OpenTK

Como se indicó anteriormente, OpenTK (The Open Toolkit) es una biblioteca avanzada de C# de bajo nivel que facilita el trabajo con OpenGL, OpenCL y OpenAL. El uso de OpenTK en una aplicación de Xamarin.Mac proporciona las siguientes características:

• Desarrollo rápido: OpenTK proporciona tipos de datos sólidos y documentación en línea para mejorar el flujo de trabajo de codificación y detectar errores más fácilmente y antes.
• Integración sencilla: OpenTK se diseñó para integrarse fácilmente con aplicaciones .NET.
• Licencia permisiva: OpenTK se distribuye bajo las licencias MIT/X11 y es totalmente gratuito.
• Enlaces completos y Type-Safe: OpenTK admite las versiones más recientes de OpenGL, OpenGL|ES, OpenAL y OpenCL con carga automática de extensiones, comprobación de errores y documentación en línea.
• Opciones de GUI flexibles: OpenTK proporciona la ventana de juegos nativa de alto rendimiento diseñada específicamente para juegos y Xamarin.Mac.
• Código de CLS-Compliant totalmente administrado: OpenTK admite versiones de 32 y 64 bits de macOS sin bibliotecas no administradas.
• 3D Math Toolkit OpenTK proporciona los structs , y a través de sus estructuras MatrixQuaternionBezier matemáticas 3D Toolkit.

OpenTK se puede usar para juegos, aplicaciones científicas u otros proyectos que requieren gráficos 3D, audio o funcionalidad computacional.

Para obtener más información, consulte El sitio web Toolkit open.

Inicio rápido de OpenTK

Como introducción rápida al uso de OpenTK en una aplicación de Xamarin.Mac, vamos a crear una aplicación sencilla que abra una vista de juego, represente un triángulo sencillo en esa vista y adjunte la vista de juegos a la ventana principal de la aplicación Mac para mostrar el triángulo al usuario.

Iniciar un nuevo Project

Inicie Visual Studio para Mac y cree una nueva solución de Xamarin.Mac. Seleccione Aplicación MacGeneralCocoa App:

Escriba MacOpenTK para el nombre Project MacOpenTK

Haga clic en el botón Crear para compilar el nuevo proyecto.

Inclusión de OpenTK

Para poder usar Open TK en una aplicación de Xamarin.Mac, debe incluir una referencia al ensamblado OpenTK. En la Explorador de soluciones , hagaclic con el botón derecho en la carpeta Referencias y seleccione Editar referencias....

Haga una comprobación y OpenTK haga clic en el OpenTK Aceptar:

Uso de OpenTK

Una vez creado el nuevo proyecto, haga doble clic en el archivo del MainWindow.csMainWindow.cs para abrirlo para su edición. Haga que MainWindow la clase se parezca a la siguiente:

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;

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

Veamos este código en detalle a continuación.

API necesarias

Se requieren varias referencias para usar OpenTK en una clase de Xamarin.Mac. Al principio de la definición hemos incluido las using siguientes instrucciones:

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

Este conjunto mínimo será necesario para cualquier clase que use OpenTK.

Adición de la vista de juegos

A continuación, es necesario crear una vista de juego que contenga toda nuestra interacción con OpenTK y mostrar los resultados. Hemos usado el código siguiente:

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

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

Aquí hemos hecho que la vista de juegos sea del mismo tamaño que la ventana principal de Mac y reemplazamos la vista de contenido de la ventana por la nueva MonoMacGameView . Dado que reemplazamos el contenido de la ventana existente, la vista especificada se cambiará automáticamente cuando se cambie el tamaño Windows principal.

Respuesta a eventos

Hay varios eventos predeterminados a los que debe responder cada vista de juego. En esta sección se tratarán los eventos principales necesarios.

El evento Load

El Load evento es el lugar para cargar recursos desde el disco, como imágenes, texturas o música. Para nuestra sencilla aplicación de prueba, no estamos usando el Load evento, pero lo hemos incluido como referencia:

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

El evento Resize

Se Resize debe llamar al evento cada vez que se cambia el tamaño de la vista de juego. Para nuestra aplicación de ejemplo, estamos haciendo que la ventanilla GL tenga el mismo tamaño que la vista de juego (cuyo tamaño automático cambia la ventana principal de Mac) con el código siguiente:

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

El evento UpdateFrame

El evento se usa para controlar la entrada del usuario, actualizar las posiciones de los UpdateFrame objetos, ejecutar cálculos físicos o de inteligencia artificial. Para nuestra sencilla aplicación de prueba, no estamos usando el UpdateFrame evento, pero lo hemos incluido como referencia:

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

El evento RenderFrame

El RenderFrame evento contiene el código que se usa para representar (dibujar) los gráficos. Para nuestra aplicación de ejemplo, estamos rellenando la vista de juegos con un triángulo simple:

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

};

Normalmente, el código de representación estará con una llamada a GL.Clear para quitar los elementos existentes antes de dibujar los nuevos elementos.

Ejecución de la vista de juegos

Con todos los eventos necesarios definidos y la vista de juegos adjuntada a la ventana principal de Mac de nuestra aplicación, se lee para ejecutar la vista de juegos y mostrar los gráficos. Use el código siguiente:

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

Pasamos la velocidad de fotogramas deseada a la que queremos que se actualice la vista de juego; en nuestro ejemplo, hemos elegido fotogramas por segundo (la misma frecuencia de actualización que la 60 tv normal).

Vamos a ejecutar la aplicación y ver la salida:

Si cambiamos el tamaño de la ventana, también residirá la vista de juegos y el triángulo también se cambiará de tamaño y se actualizará en tiempo real.

¿Dónde se encuentra Siguiente?

Con los conceptos básicos de trabajar con OpenTk en una aplicación xamarin.mac, estas son algunas sugerencias de lo que se debe probar a continuación:

• Intente cambiar el color del triángulo y el color de fondo de la vista de juego en los Load eventos RenderFrame y .
• Haga que el triángulo cambie de color cuando el usuario presione una tecla en los eventos y o haga su propia clase personalizada UpdateFrameRenderFrame e MonoMacGameView invalide los KeyUpKeyDown métodos y .
• Haga que el triángulo se mueva a través de la pantalla mediante las claves que se deben tener en cuenta en el UpdateFrame evento. Sugerencia: use el Matrix4.CreateTranslation método para crear una matriz de traducción y llamar al método para GL.LoadMatrix cargarla en el RenderFrame evento.
• Use un for bucle para representar varios triángulos en el RenderFrame evento.
• Gira la cámara para proporcionar una vista diferente del triángulo en el espacio 3D. Sugerencia: use el Matrix4.CreateTranslation método para crear una matriz de traducción y llamar al método para GL.LoadMatrix cargarla. También puede usar las clases Vector2 , y para las Vector3Vector4Matrix4 manipulaciones de cámara.

Para obtener más ejemplos, consulte el repositorio de ejemplos GitHub OpenTK. Contiene una lista oficial de ejemplos de uso de OpenTK. Tendrá que adaptar estos ejemplos para usarlos con la versión de Xamarin.Mac de OpenTK.

Para ver un ejemplo más complejo de Xamarin.Mac de una implementación de OpenTK, consulte nuestro ejemplo monoMacGameView.

Resumen

En este artículo se ha dado un vistazo rápido al trabajo con OpenTK en una aplicación de Xamarin.Mac. Hemos visto cómo crear una ventana de juego, cómo adjuntar la ventana de juego a una ventana de Mac y cómo representar una forma sencilla en la ventana de juego.

Vínculos relacionados

• MacOpenTK (ejemplo)
• MonoMacGameView (ejemplo)
• Hello, Mac
• Trabajar con Windows
• La ventana Toolkit
• OS X Human Interface Guidelines (Directrices de interfaz humana de OS X)
• Introducción a Windows