Tworzenie środowiska OpenGL ES

Aby rysować grafikę za pomocą OpenGL ES w aplikacji na Androida, musisz utworzyć kontener widoku danych. Jednym z prostszych sposobów realizacji tego zadania jest wdrożenie GLSurfaceView i GLSurfaceView.Renderer. O GLSurfaceView to kontener widoku dla grafiki rysowanej za pomocą OpenGL i GLSurfaceView.Renderer określa, co ma być rysowane w tym widoku. Więcej informacji na temat konfiguracji Więcej informacji o tych zajęciach znajdziesz na stronie OpenGL ES przewodnik dla programistów.

GLSurfaceView to tylko jeden ze sposobów na włączenie grafiki OpenGL ES do aplikacji. Rozsądnie jest wyświetlać grafikę na pełnym ekranie lub prawie na pełnym ekranie. Programiści, którzy chcą uwzględnić grafikę OpenGL ES w niewielkiej części swoich układów, zapoznaj się z artykułem TextureView. W przypadku prawdziwych programistów – dla majsterkowiczów można utworzyć widok OpenGL ES za pomocą interfejsu SurfaceView, ale wymaga to na pisanie sporo dodatkowego kodu.

Z tej lekcji dowiesz się, jak w prosty sposób przeprowadzić minimalną implementację GLSurfaceView i GLSurfaceView.Renderer aktywności aplikacji.

Zadeklaruj użycie OpenGL ES w pliku manifestu

Aby aplikacja używała interfejsu API OpenGL ES 2.0, musisz dodać: do pliku manifestu:

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

Jeśli aplikacja wykorzystuje kompresję tekstur, musisz też zadeklarować, które formaty kompresji obsługuje Twoją aplikację, więc jest instalowana tylko na zgodnych urządzeniach.

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

Więcej informacji o formatach kompresji tekstur znajdziesz tutaj Przewodnik dla programistów OpenGL.

Utwórz aktywność dla grafiki OpenGL ES

Aplikacje na Androida korzystające z OpenGL ES wykonują działania tak samo jak każda inna aplikacja, która do interfejsu użytkownika. Główna różnica między nimi polega na tym, co musisz umieścić w układzie działania. W wielu aplikacjach możesz używać interfejsów TextView, Button i ListView, ale w przypadku aplikacji, które korzystają z OpenGL ES, możesz dodaj też GLSurfaceView.

Poniższy przykładowy kod pokazuje minimalną implementację działania, które korzysta z GLSurfaceView jako widok podstawowy:

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

Uwaga: OpenGL ES 2.0 wymaga Androida w wersji 2.2 (poziom interfejsu API 8) lub nowszego, więc upewnij się, że Twój projekt na Androida jest kierowany na ten lub wyższy interfejs API.

Tworzenie obiektu GLSurfaceView

GLSurfaceView to specjalny widok, w którym można rysować OpenGL ES grafiki. Sama w sobie niewiele daje. Rzeczywiste rysowanie obiektów jest kontrolowane za pomocą GLSurfaceView.Renderer ustawione w tym widoku. W rzeczywistości kod jest tak cienki, że czasem warto pominąć jego rozszerzanie i utworzyć w postaci niezmodyfikowanej GLSurfaceView, ale nie rób tego. Musisz przedłużyć te zajęcia w rejestrowania zdarzeń dotknięcia. Sekcja ta jest omówiona w sekcji Reagowanie na dotyk wydarzeń.

Kod aplikacji GLSurfaceView jest minimalny, więc w krótkim czasie implementacji, często pojawia się po prostu stwórz klasę wewnętrzną w ćwiczeniu, które jej używa:

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

Dodatkowym opcjonalnym dodatkiem do implementacji GLSurfaceView jest ustawienie w trybie renderowania, aby rysować widok tylko wtedy, gdy nastąpiła zmiana danych rysunku za pomocą GLSurfaceView.RENDERMODE_WHEN_DIRTY ustawienie:

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

To ustawienie zapobiega ponownemu wyświetlaniu ramki GLSurfaceView do czasu Zadzwoń do: requestRender(), czyli więcej dla tej przykładowej aplikacji.

Tworzenie klasy mechanizmu renderowania

implementację klasy GLSurfaceView.Renderer (czyli mechanizmu renderowania), w aplikacji korzystającej z platformy OpenGL ES robi się ciekawiej. Te zajęcia elementy sterujące co jest narysowane na elemencie GLSurfaceView, z którym jest powiązany. Istnieją trzy metody w mechanizmie renderowania, które są wywoływane przez system Android, aby określić, jak rysować na GLSurfaceView:

• onSurfaceCreated() – Wywołane raz w celu skonfigurowania środowiska OpenGL ES widoku.
• onDrawFrame() – wywołanie dla każdego ponownie odsłonić widok.
• onSurfaceChanged() – wywołano, jeśli geometria widoku zmieni się, np. gdy zmieni się orientacja ekranu urządzenia.

To jest bardzo podstawowa implementacja mechanizmu renderowania OpenGL ES, która nie robi nic więcej niż czarne tło w elemencie 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);
    }
}

To wszystko. Powyższe przykłady kodu pozwalają utworzyć prostą aplikację na Androida, powoduje wyświetlanie czarnego ekranu w trybie OpenGL. Chociaż ten kod nie robi nic interesującego, podczas tworzenia tych zajęć, stworzyłeś podstawy, musisz zacząć rysować elementy graficzne za pomocą OpenGL.

Uwaga: możesz się zastanawiać, dlaczego te metody mają parametr GL10, gdy używasz interfejsów API OpengGL ES 2.0. Podpisy tych metod są po prostu ponownie używane w interfejsach API w wersji 2.0, by zachować kod platformy Androida prostsza.

Jeśli znasz interfejs OpenGL ES API, powinieneś teraz być w stanie skonfigurować OpenGL ES. w aplikacji i zacznij rysować grafikę. Jeśli jednak potrzebujesz dodatkowej pomocy z używaniem OpenGL, przejdź do następnych lekcji, gdzie znajdziesz kilka dodatkowych wskazówek.