O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Criar um ambiente OpenGL ES

Para desenhar gráficos com o OpenGL ES no seu aplicativo para Android, você precisa criar um contêiner de visualização para eles. Uma das maneiras mais simples de fazer isso é implementar GLSurfaceView e GLSurfaceView.Renderer. Um GLSurfaceView é um contêiner de visualização para gráficos desenhados com o OpenGL, e o GLSurfaceView.Renderer controla o que é desenhado dentro dessa visualização. Para mais informações sobre essas classes, consulte o guia do desenvolvedor do OpenGL ES.

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 tudo por conta própria, também é possível construir uma visualização do OpenGL ES usando SurfaceView, mas isso requer escrever um pouco a mais de código.

Esta lição explica como realizar 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 seu aplicativo use a API OpenGL ES 2.0, você precisa adicionar a seguinte declaração ao seu manifesto:

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

Se seu aplicativo usa compactação de textura, você também precisa declarar quais formatos de compactação são compatíveis com seu app, 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 mais informações sobre formatos de compactação de textura, consulte o guia do desenvolvedor do OpenGL.

Criar uma atividade para gráficos do OpenGL ES

Os aplicativos para Android que usam o OpenGL ES têm atividades como qualquer outro aplicativo com 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 seja possível usar TextView, Button e ListView, em um aplicativo que usa o OpenGL ES, você também pode adicionar um GLSurfaceView.

O exemplo de código a seguir mostra uma implementação mínima de uma atividade que utiliza um GLSurfaceView como visualização primária:

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 Android 2.2 (API de nível 8) ou posterior. Assim, seu projeto para Android precisa ser direcionado para uma dessas APIs.

Criar um objeto GLSurfaceView

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 no GLSurfaceView.Renderer que você configura 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 de GLSurfaceView não modificada, mas não faça isso. Você precisa estender essa classe para capturar eventos de toque, o que é abordado na lição Responder a eventos de toque.

O código essencial para o GLSurfaceView é mínimo, portanto, para uma implementação rápida, é comum apenas criar uma classe interna na atividade que o 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);
        }
    }
    

Outro acréscimo opcional para a implementação de GLSurfaceView é definir o modo de renderização para desenhar a visualização apenas quando houver uma mudança nos seus 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é que você chame requestRender(), que é mais eficiente para esse aplicativo 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 redesenho da visualização.
  • onSurfaceChanged(): chamado se a geometria da visualização muda, por exemplo, quando a orientação da tela do dispositivo é alterada.

Veja uma implementação muito básica de um renderizador OpenGL ES, que não faz nada mais do que desenhar um fundo 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 para Android simples que exibe uma tela preta usando o OpenGL. Embora esse código não faça nada de muito 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 quando está usando as APIs do OpengGL ES 2.0. Essas assinaturas de método são simplesmente reutilizadas para as APIs 2.0 deixarem o código de framework do Android mais simples.

Se você estiver familiarizado com as APIs do OpenGL ES, conseguirá 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 para as próximas lições para ver mais algumas dicas.