OpenGL ES-Umgebung erstellen

Um Grafiken mit OpenGL ES in Ihrer Android-App zu zeichnen, müssen Sie ein Ansicht-Container für sie. Eine der unkomplizierteren Möglichkeiten besteht darin, sowohl ein GLSurfaceView und GLSurfaceView.Renderer. A GLSurfaceView ist ein Ansichtscontainer für mit OpenGL und Mit GLSurfaceView.Renderer wird festgelegt, was in dieser Ansicht gezeichnet wird. Weitere Informationen finden Sie in der OpenGL ES Entwicklerleitfaden.

GLSurfaceView ist nur eine Möglichkeit, wie du OpenGL ES-Grafiken in deinen . Für eine Vollbild- oder Vollbildgrafikansicht ist dies eine vernünftige Wahl. Entwickler, die OpenGL ES-Grafiken in einem kleinen Teil ihrer Layouts verwenden möchten, sollten TextureView ansehen. Für echte Do-it-yourself-Entwickler: mit SurfaceView eine OpenGL ES-Ansicht erstellen. und viel zusätzlichen Code schreiben.

In dieser Lektion erfahren Sie, wie Sie eine minimale Implementierung von GLSurfaceView und GLSurfaceView.Renderer auf einfache Weise durchführen. App-Aktivitäten.

OpenGL ES-Nutzung im Manifest deklarieren

Damit Ihre Anwendung die OpenGL ES 2.0 API verwenden kann, müssen Sie Folgendes hinzufügen: -Deklaration zu deinem Manifest hinzu:

<uses-feature android:glEsVersion="0x00020000" android:required="true" />

Wenn Ihre Anwendung die Texturkomprimierung verwendet, müssen Sie auch angeben, welche Komprimierungsformate die deine App unterstützt, sodass sie nur auf kompatiblen Geräten installiert wird.

<supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" />
<supports-gl-texture android:name="GL_OES_compressed_paletted_texture" />

Weitere Informationen zu Texturkomprimierungsformaten findest du in der OpenGL-Entwicklerleitfaden

Aktivität für OpenGL ES-Grafiken erstellen

Android-Apps, die OpenGL ES nutzen, haben dieselben Aktivitäten wie jede andere App, eine Benutzeroberfläche. Der Hauptunterschied zu anderen Anwendungen besteht darin, was Sie in das Layout für Ihre Aktivitäten. In vielen Anwendungen können Sie TextView, Button und ListView verwenden. In einer App mit OpenGL ES können Sie fügen Sie außerdem GLSurfaceView hinzu.

Das folgende Codebeispiel zeigt eine minimale Implementierung einer Aktivität, bei der ein GLSurfaceView als primäre Ansicht:

class OpenGLES20Activity : Activity() {

    private lateinit var gLView: GLSurfaceView

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Create a GLSurfaceView instance and set it
        // as the ContentView for this Activity.
        gLView = MyGLSurfaceView(this)
        setContentView(gLView)
    }
}

public class OpenGLES20Activity extends Activity {

    private GLSurfaceView gLView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Create a GLSurfaceView instance and set it
        // as the ContentView for this Activity.
        gLView = new MyGLSurfaceView(this);
        setContentView(gLView);
    }
}

Hinweis:Für OpenGL ES 2.0 ist Android 2.2 (API-Level 8) oder höher erforderlich. Stellen Sie daher sicher, dass Ihr Android-Projekt auf diese oder eine höhere API ausgerichtet ist.

GLSurfaceView-Objekt erstellen

Ein GLSurfaceView ist eine spezielle Ansicht, in der du OpenGL ES zeichnen kannst. Grafiken. Alleine kann es nicht viel tun. Das eigentliche Zeichnen der Objekte wird im GLSurfaceView.Renderer, die Sie für diese Ansicht festgelegt haben. Der Code für diese so dünn ist, könnten Sie versucht sein, die Erweiterung zu überspringen und einfach ein unverändertes GLSurfaceView-Instanz, aber tu das nicht. Sie müssen diesen Kurs verlängern in um Touch-Ereignisse zu erfassen. Dies wird im Abschnitt Auf Berührung reagieren .

Der Code für GLSurfaceView ist minimal. Implementierung ist es üblich, erstellen Sie einfach eine innere Klasse in der Aktivität, in der sie verwendet wird:

import android.content.Context
import android.opengl.GLSurfaceView

class MyGLSurfaceView(context: Context) : GLSurfaceView(context) {

    private val renderer: MyGLRenderer

    init {

        // Create an OpenGL ES 2.0 context
        setEGLContextClientVersion(2)

        renderer = MyGLRenderer()

        // Set the Renderer for drawing on the GLSurfaceView
        setRenderer(renderer)
    }
}

import android.content.Context;
import android.opengl.GLSurfaceView;

class MyGLSurfaceView extends GLSurfaceView {

    private final MyGLRenderer renderer;

    public MyGLSurfaceView(Context context){
        super(context);

        // Create an OpenGL ES 2.0 context
        setEGLContextClientVersion(2);

        renderer = new MyGLRenderer();

        // Set the Renderer for drawing on the GLSurfaceView
        setRenderer(renderer);
    }
}

Eine weitere optionale Ergänzung zu Ihrer GLSurfaceView-Implementierung besteht darin, Rendermodus so, dass die Ansicht nur dann gezeichnet wird, wenn sich Ihre Zeichnungsdaten mithilfe der Funktion GLSurfaceView.RENDERMODE_WHEN_DIRTY Einstellung:

// Render the view only when there is a change in the drawing data
renderMode = GLSurfaceView.RENDERMODE_WHEN_DIRTY

// Render the view only when there is a change in the drawing data
setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

Diese Einstellung verhindert, dass der Frame GLSurfaceView neu gezeichnet wird, bis Sie Rufen Sie requestRender() auf, für diese Beispiel-App.

Renderer-Klasse erstellen

Die Implementierung der GLSurfaceView.Renderer-Klasse oder des Renderers in einer Anwendung, die OpenGL ES nutzt, wird es interessant. Dieser Kurs Einstellungen was auf die GLSurfaceView gezogen wird, mit der es verknüpft ist. Es gibt drei Methoden in einem Renderer, die vom Android-System aufgerufen werden, um herauszufinden, So zeichnen Sie auf einem GLSurfaceView:

• onSurfaceCreated() – Wird einmal aufgerufen, um die OpenGL ES-Umgebung der Ansicht einzurichten.
• onDrawFrame() – für jede aufgerufen die Ansicht neu zu zeichnen.
• onSurfaceChanged() – Angerufen, wenn ändert sich die Geometrie der Ansicht, beispielsweise wenn sich die Bildschirmausrichtung des Geräts ändert.

Hier sehen Sie eine sehr einfache Implementierung eines OpenGL ES-Renderers, der nichts weiter tut, als eine schwarzer Hintergrund im GLSurfaceView:

import javax.microedition.khronos.egl.EGLConfig
import javax.microedition.khronos.opengles.GL10

import android.opengl.GLES20
import android.opengl.GLSurfaceView

class MyGLRenderer : GLSurfaceView.Renderer {

    override fun onSurfaceCreated(unused: GL10, config: EGLConfig) {
        // Set the background frame color
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f)
    }

    override fun onDrawFrame(unused: GL10) {
        // Redraw background color
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT)
    }

    override fun onSurfaceChanged(unused: GL10, width: Int, height: Int) {
        GLES20.glViewport(0, 0, width, height)
    }
}

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLES20;
import android.opengl.GLSurfaceView;

public class MyGLRenderer implements GLSurfaceView.Renderer {

    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
        // Set the background frame color
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    }

    public void onDrawFrame(GL10 unused) {
        // Redraw background color
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
    }

    public void onSurfaceChanged(GL10 unused, int width, int height) {
        GLES20.glViewport(0, 0, width, height);
    }
}

Das ist schon alles! Mit den Codebeispielen oben wird eine einfache Android-App erstellt, die zeigt einen schwarzen Bildschirm mit OpenGL an. Dieser Code erfüllt zwar nichts Interessantes, Sie diese Kurse erstellt haben, haben Sie den Grundstein gelegt, den Sie benötigen, um mit dem Zeichnen von Grafikelementen OpenGL

Hinweis:Wenn Sie die OpengGL ES 2.0 APIs verwenden, fragen Sie sich vielleicht, warum diese Methoden den Parameter GL10 haben. Diese Methodensignaturen werden einfach für die 2.0-APIs wiederverwendet, damit der Code des Android-Frameworks erhalten bleibt. einfacher zu machen.

Wenn ihr mit den OpenGL ES-APIs vertraut seid, solltet ihr jetzt in der Lage sein, eine OpenGL ES-API einzurichten. und zeichnen Sie Grafiken. Wenn Sie jedoch etwas mehr Hilfe benötigen, mit OpenGL begonnen hat, finden Sie in den nächsten Lektionen ein paar weitere Hinweise.