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:
Kotlin
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)
}
}
Java
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:
Kotlin
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)
}
}
Java
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:
Kotlin
// Render the view only when there is a change in the drawing data renderMode = GLSurfaceView.RENDERMODE_WHEN_DIRTY
Java
// 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:
Kotlin
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)
}
}
Java
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.