Einführung in OpenGL in Android

OpenGL steht für Open Graphics Library. Es ist im Grunde eine API, die vom Android verwendet wird, um Hochleistungsgrafiken wie 2D- und 3D-Grafiken zu unterstützen. Die allgemeine Verwendung von OpenGL zum Übertragen der Daten von der CPU zur GPU. Dies geschieht durch OpenGL Objects. Es ist eine plattformübergreifende Grafik-API. In diesem Thema lernen wir OpenGL in Android kennen.

OpenGL-Objekte bestehen aus Status und Daten und unterstützen die Datenübertragung zwischen CPU und GPU. OpenGL ES ist eine beliebte Spezifikation der OpenGL-API, die speziell für eingebettete Systeme entwickelt wurde.

OpenGL in Android wird von Android mit dem Native Development Kit (NDK) und dessen Framework-API unterstützt. Die grundlegenden Klassen im Android-Framework unterstützen Sie beim Erstellen und Bearbeiten von Grafiken. Die mit diesen Klassen verwendete OpenGL ES-API heißt GLSurfVaceiew.Renderer und GLSurfaceView. Ein gutes Verständnis der Implementierung dieser Klassen ist hilfreich bei der Verwendung von OpenGL in Ihrer Android-Anwendung.

GLSurfaceView

In dieser Ansicht können Sie Objekte zeichnen und bearbeiten. Diese Klasse ist einfach zu verwenden, da Sie ein Objekt von GLSurfaceView erstellen und diesem einen Renderer hinzufügen können. Sie können Touchscreen-Ereignisse erfassen, indem Sie die GLSurfaceView-Klasse erweitern, um die Touchscreen-Listener zu implementieren.

GLSurfaceView.Renderer

Die GLSurfaceView.Renderer-Schnittstelle enthält Methoden, die zum Zeichnen von Grafiken in einer GLSurfaceView erforderlich sind. Die Implementierung dieser Schnittstelle sollte als separate Klasse bereitgestellt werden, die mit GLSurfaceView.setRenderer () an die GLSurfaceView-Instanz angehängt wird .

Sie müssen die folgenden Methoden für die Implementierung der GLSurfaceView.Renderer-Schnittstelle implementieren:

  • onSurfaceCreated () : Diese Methode wird während der Erstellung der GLSurfaceView aufgerufen.
  • onDrawFrame () : Diese Methode wird bei jedem Neuzeichnen von GLSurfaceView aufgerufen.
  • onSurfaceChanged () : Diese Methode wird aufgerufen, wenn sich die GLSurfaceView-Geometrie ändert (Größe, Ausrichtung usw.).

Wie funktioniert OpenGL in Android?

Es gibt verschiedene Arten von OpenGL-Objekten. Zum Beispiel ein Vertex Buffer Object, das Vertices eines Zeichens speichern kann. Das zweite Beispiel ist Textur, die Bilddaten speichern kann.

Daten wie Scheitelpunkte, Normalen und UV-Koordinaten, die die Eigenschaften des Netzes darstellen, werden in ein Scheitelpunkt-Pufferobjekt geladen und dann zur Verarbeitung an die GPU gesendet. Sobald es in der GPU ist, würden diese Daten durchlaufen, was als OpenGL-Rendering-Pipeline bezeichnet wird.

Die Hauptaufgaben, für die Rendering Pipeline verantwortlich ist, sind die Konvertierung der Scheitelpunkte in das richtige Koordinatensystem, das Zusammensetzen der Scheitelpunkte eines Zeichens, das Anwenden von Farbe oder Textur und das Anzeigen des Zeichens auf dem Standard-Framebuffer, der der Bildschirm ist.

Der Rendering-Pipeline-Prozess von OpenGL unter Android besteht aus den folgenden sechs Schritten:

  1. Per-Vertex-Operation
  2. Primitive Versammlung
  3. Primitive Verarbeitung
  4. Rasterisierung
  5. Fragmentverarbeitung
  6. Per-Fragment-Operation

Per-Vertex-Operation

Der erste und wichtigste Schritt zum Rendern eines Bildes sind Geometriedaten, die von einem Koordinatensystem in ein anderes Koordinatensystem konvertiert werden müssen.

Primitive Versammlung

Die Eckpunkte werden in diesem speziellen Schritt zu Paaren von 2, 3 und mehr gesammelt, und das Grundelement wird beispielsweise zu einem Dreieck zusammengesetzt.

Primitive Verarbeitung

Wenn die Grundelemente zusammengesetzt wurden, werden sie getestet, um zu überprüfen, ob sie in ein Ansichtsvolumen fallen. Falls sie diesen speziellen Test nicht bestehen, werden sie in weiteren Schritten ignoriert. Dieser Test wird als Clipping bezeichnet.

Rasterisierung

Dann werden Primitive in Stücke kleinerer Einheiten zerlegt, die denen der Pixel im Framebuffer entsprechen. Jede dieser kleineren Einheiten wird dann als Fragmente bezeichnet.

Fragmentverarbeitung

Wenn das Grundelement gerastert wurde, werden Farbe oder Textur auf die Geometrie angewendet.

Per-Fragment-Operation

Zuletzt werden die Fragmente verschiedenen Tests unterzogen, wie zum Beispiel:

  • Pixel Ownership Test
  • Scherentest
  • Alpha Test
  • Schablonentest
  • Tiefenprüfung

Von diesen sechs Stufen werden zwei Stufen durch Programme gesteuert, die als Shader bezeichnet werden.

Kurz gesagt, Shader ist ein kleines Programm, das von Ihnen nur für die GPU entwickelt wurde. Es gibt eine spezielle Grafiksprache namens OpenGL Shading Language (GLSL), in der ein Shader geschrieben ist. Die beiden wichtigen Phasen in der OpenGL-Pipeline, in denen ein Shader stattfindet, werden als "Per-Vertex-Verarbeitung" und "Per-Fragment-Verarbeitung" bezeichnet.

Der Shader, der in der Stufe "Pro Vertex" verarbeitet wird, wird als Vertex-Shader bezeichnet. Der Shader, der in der Stufe "Pro Fragment" verarbeitet wird, wird als Fragment-Shader bezeichnet. Das ultimative und grundlegende Ziel des Vertex-Shaders besteht darin, die endgültige Transformation der Vertices des Zeichens in die Rendering-Pipeline zu geben, während das Ziel des Fragment-Shaders darin besteht, die Farb- und Texturdaten für jede der Pixelüberschriften in den Framebuffer einzugeben.

Wenn Daten durch die OpenGL-Rendering-Pipeline geleitet werden, wird entweder das 3D- oder das 2D-Modell auf dem Bildschirm Ihres Geräts angezeigt.

GL-Programm

Hinweise für OpenGL in Android

Wenn Sie ein Anfänger im OpenGL-Programmieren sind, sind einige der folgenden Punkte möglicherweise noch nicht von Ihnen angetroffen worden. Im Folgenden finden Sie einige Richtlinien, die Sie bei der Verwendung von OpenGL unter Android beachten müssen. Sie sind häufige Fehler. Denken Sie also immer daran.

  1. Unsachgemäße Skalierung von Normalen für die Beleuchtung
  2. Schlechte Tessellation schmerzt Beleuchtung
  3. Denken Sie immer an Ihren Matrix-Modus
  4. Überlaufen des Projektionsmatrixstapels
  5. Nicht alle Mipmap-Ebenen festlegen
  6. Luminanzpixel zurücklesen

Voraussetzungen für OpenGL in Android

Nachfolgend finden Sie die Voraussetzungen für OpenGL in Android.

Software-Kenntnisse

  • C, also Programmiersprache.
  • C ++ Kenntnisse sind nicht erforderlich, aber hilfreich.
  • Verwendung verschiedener Bibliotheken, die entweder statisch oder dynamisch sein können.

Mathematik

  • Vektorkenntnisse in 2D und 3D.
  • Matrizen
  • Grundstufe Mathematik Konzepte.

Dies sind alles Haupt- und Grundkonzepte, die benötigt werden, um mit OpenGL zu beginnen. Möglicherweise müssen Sie mehr über mathematische Konzepte lernen, aber nachdem Sie die Mittelstufe erreicht haben. Aber das hängt total von dir ab. Mit Hilfe verschiedener Bibliotheken können Sie viele Dinge übergehen.

Fazit: OpenGL in Android

Daher ist OpenGL eine vollständig funktionsfähige API, die primitiv ist und es dem Programmierer ermöglicht, Grafikhardware effektiv zu adressieren und zu nutzen. Eine große Anzahl von High-Level-Bibliotheken sowie Anwendungen verwenden OpenGL aufgrund seiner Leistung, Programmierfreundlichkeit, Erweiterbarkeit und umfassenden Unterstützung.

Empfohlener Artikel

Dies war eine Anleitung zu OpenGL in Android. Hier haben wir den Arbeitsprozess und die Voraussetzungen von OpenGL in Android besprochen. Sie können auch unsere anderen Artikelvorschläge durchgehen, um mehr zu erfahren -

  1. WebGL gegen OpenGL
  2. Was ist Cognos?
  3. Was ist Jira Software?
  4. Karriere in Azure