Para desenhar gráficos com o OpenGL ES no seu aplicativo Android, você precisa criar um
contêiner de visualização para eles. Uma das maneiras mais simples de fazer isso é implementar um
GLSurfaceView
e um GLSurfaceView.Renderer
. Um
GLSurfaceView
é um contêiner de visualização para gráficos desenhados com o OpenGL, e
GLSurfaceView.Renderer
controla o que é desenhado dentro dessa visualização. Para saber mais
sobre essas classes, consulte o guia do desenvolvedor
do OpenGL ES.
O GLSurfaceView
é apenas uma maneira de incorporar gráficos do OpenGL ES no seu
aplicativo. Para uma visualização de gráficos em tela cheia ou quase cheia, essa é uma escolha razoável.
Os desenvolvedores que quiserem incorporar gráficos do OpenGL ES em uma pequena parte dos layouts podem
usar TextureView
. Para desenvolvedores que fazem você mesmo, também é
possível criar uma visualização do OpenGL ES usando SurfaceView
, mas isso exige
que você programe um pouco mais de código.
Esta lição explica como concluir uma implementação mínima de GLSurfaceView
e GLSurfaceView.Renderer
em uma atividade
de aplicativo simples.
Declarar o uso de OpenGL ES no manifesto
Para que o aplicativo use a API OpenGL ES 2.0, adicione a seguinte declaração ao manifesto:
<uses-feature android:glEsVersion="0x00020000" android:required="true" />
Caso seu aplicativo use compactação de textura, também é necessário declarar a quais formatos de compactação seu app oferece suporte, para que ele seja instalado apenas em dispositivos compatíveis.
<supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" /> <supports-gl-texture android:name="GL_OES_compressed_paletted_texture" />
Para saber mais sobre formatos de compactação de textura, consulte o guia para desenvolvedores do OpenGL (link em inglês).
Criar uma atividade para gráficos do OpenGL ES
Os aplicativos Android que usam o OpenGL ES têm atividades como qualquer outro aplicativo que tem
uma interface do usuário. A principal diferença em relação a outros aplicativos é o que você coloca no layout da sua
atividade. Embora em muitos aplicativos você possa usar TextView
, Button
e ListView
, em um app que usa o OpenGL ES, também é possível
adicionar um GLSurfaceView
.
O exemplo de código abaixo mostra uma implementação mínima de uma atividade que usa um
GLSurfaceView
como visualização principal:
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); } }
Observação:o OpenGL ES 2.0 requer o Android 2.2 (API de nível 8) ou uma versão mais recente. Portanto, seu projeto para Android precisa ser destinado a essa API ou a uma versão mais recente.
Criar um objeto GLSurfaceView
Um GLSurfaceView
é uma visualização especializada em que você pode desenhar gráficos do
OpenGL ES.
Ela não faz muito sozinha. O desenho real dos objetos é controlado na
GLSurfaceView.Renderer
definida nessa visualização. Na verdade, o código desse
objeto é tão fino que você pode ficar tentado a pular a extensão dela e apenas criar uma instância
GLSurfaceView
não modificada, mas não faça isso. Você precisa estender essa classe para
capturar eventos de toque. Isso é abordado na lição Responder a eventos
de toque.
O código essencial para uma GLSurfaceView
é mínimo. Portanto, para uma implementação
rápida, é comum
apenas criar uma classe interna na atividade que a utiliza:
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); } }
Outra adição opcional à implementação de GLSurfaceView
é definir
o modo de renderização para desenhar a visualização apenas quando houver uma mudança nos dados de desenho usando a
configuração
GLSurfaceView.RENDERMODE_WHEN_DIRTY
:
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);
Essa configuração impede que o frame GLSurfaceView
seja redesenhado até você
chamar requestRender()
, o que é mais
eficiente para este app de exemplo.
Criar uma classe de renderizador
A implementação da classe GLSurfaceView.Renderer
, ou renderizador, em um aplicativo que usa o OpenGL ES é onde as coisas começam a ficar interessantes. Essa classe
controla
o que é desenhado na GLSurfaceView
a que ela está associada. Existem
três métodos em um renderizador que são chamados pelo sistema Android para descobrir o que e
como desenhar em um GLSurfaceView
:
onSurfaceCreated()
: chamado uma vez para configurar o ambiente OpenGL ES da visualização.onDrawFrame()
: chamado para cada reexibição da visualização.onSurfaceChanged()
: chamado se a geometria da visualização muda, por exemplo, quando a orientação da tela do dispositivo muda.
Veja uma implementação muito básica de um renderizador OpenGL ES, que não faz nada mais do que desenhar um
segundo plano preto na 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); } }
Isso é tudo! Os exemplos de código acima criam um aplicativo Android simples que exibe uma tela preta usando o OpenGL. Embora esse código não faça nada de interessante, ao criar essas classes, você estabeleceu a base necessária para começar a desenhar elementos gráficos com o OpenGL.
Observação:você pode se perguntar por que esses métodos têm um parâmetro GL10
ao usar as APIs do OpengGL ES 2.0.
Essas assinaturas de método são simplesmente reutilizadas para as APIs 2.0 para manter o código do framework do Android
mais simples.
Se você estiver familiarizado com as APIs OpenGL ES, agora poderá configurar um ambiente OpenGL ES no seu app e começar a desenhar gráficos. No entanto, se você precisar de mais ajuda para começar a usar o OpenGL, siga as próximas lições para ver mais algumas dicas.