Cómo utilizar los efectos multimedia de OpenGL ES en Android
Para comenzar este tutorial, debe tener:
1. Un entorno de desarrollo integrado que admita el desarrollo de Android. Si no, puede descargar la última versión de Android Studio. el sitio web para desarrolladores de Android.
2. Un teléfono Android con Android 4.0, la GPU es compatible con OpenGL ES2.0
3 Conocimientos básicos sobre OpenGL
Configurar el entorno OpenGL ES<. /p>
Crear un GLSurfaceView
Para mostrar gráficos OpenGL, necesita usar la clase GLSurfaceView, como cualquier otra subclase de Vista, puede definirla en el archivo xml de diseño o crear un instancia en forma de código para agregarla a la parte superior de la Actividad o Fragmento.
En este tutorial, usamos GLSurfaceView como la única vista en la Actividad, así que para hacerlo simple, creemos una instancia de
GLSurfaceView en código y pasémosla a setContentView para que que llene toda la pantalla del teléfono. El método onCreate en Actividad
es el siguiente:
protected void onCreate(Bundle saveInstanceState) {
super.onCreate(savedInstanceState);
GLSurfaceView view = new GLSurfaceView(this);
setContentView(view);
}123456123456
Porque el marco de efectos multimedia solo admite OpenGL ES2.setRenderMode ( GLSurfaceView.RENDERMODE_WHEN_DIRTY);11
Crear un renderizador
El renderizador es responsable de renderizar el contenido en GLSurfaceView.
Renderizador {
public EffectsRenderer(Contexto de contexto){
super()
}
@Override
}
@Override
public void onSurfaceChanged(GL10 gl, int ancho, int alto) {
}
@Override
public void onDrawFrame(GL10 gl) {
}
}123456789101112131415161718123456789101112131415161718
Regrese a Actividad y llame al método setRenderer para hacer que GLSurfaceView use el renderizador que creamos:
view.setRenderer(new EffectsRenderer(this));11
Escribir. el archivo Manifiesto
Si desea publicar su aplicación en Google Play Store, agregue la siguiente declaración en el archivo AndroidManifest.xml:
Esto garantizará que su aplicación solo pueda instalarse en dispositivos compatibles con OpenGL ES2.0. Ahora el entorno OpenGL está listo.
Crear un plano OpenGL
Definir vértices
GLSurfaceView no puede mostrar la foto directamente, la foto primero debe convertirse en una textura y aplicarse en la parte superior de el cuadrado OpenGL. En este tutorial crearé un plano 2D con 4 vértices. Para simplificar, usaré un rectángulo y ahora crearé una nueva clase Cuadrado para representar esa forma.
(-1, 1)
Todos los objetos que dibujamos usando OpenGL deben estar determinados por triángulos. Para dibujar un cuadrado, necesitamos dos triángulos con un lado *** común, lo que significa que las coordenadas. debe ser:
Triángulo 1: (-1, -1), (1, -1) y (-1, 1)
Triángulo 2: (1, - 1 ), (-1, 1) y (1, 1)
Cree una matriz flotante para representar estos vértices:
vértices flotantes privados[] = {
-1f, -1f,
1f , -1f,
-1f, 1f,
1f, 1f,
};123456123456
Para posicionar la textura en el cuadrado, necesita determinar las coordenadas de los vértices de la textura, cree otra matriz para representar las coordenadas de los vértices de la textura:
textura flotante privadaVértices[ ] = {
0f,1f,
1f,1f,
0f,0f,
1f,0f
};123456123456
Creación de buffers
Antes de usar estas matrices de coordenadas con OpenGL, se deben convertir a caracteres de buffer (buffers de bytes):
private FloatBuffer verticesBuffer;
private FloatBuffer texturaBuffer;1212
Inicialice estos búferes en el método inicializeBuffers: use ByteBuffer.allocateDirect para crear el búfer, porque float es una sección de 4 palabras, por lo que la longitud de la matriz de bytes que necesitamos debe ser 4 veces la longitud del flotante.
El método ByteBuffer.nativeOrder se utilizará a continuación para definir el orden de los bytes en la plataforma nativa subyacente. Utilice el método asFloatBuffer para convertir el
ByteBuffer en un FloatBuffer. Después de crear el FloatBuffer, llamaremos al método put para colocar la matriz de punto flotante en el búfer y finalmente llamaremos al
. >método de posición para garantizar que comenzamos desde el búfer. Lee los datos desde la posición inicial del área.
private void inicializeBuffers(){
ByteBuffer buff = ByteBuffer.allocateDirect(vertices.length * 4);
buff.order( ByteOrder.nativeOrder() );
verticesBuffer = buff.asFloatBuffer();
verticesBuffer.put(vértices);
verticesBuffer.position(0);
buff = ByteBuffer.allocateDirect(textureVertices.length * 4);
buff.order(ByteOrder.nativeOrder());
texturaBuffer = buff.asFloatBuffer(); p>
texturaBuffer.put(textureVertices);
texturaBuffer.position(0);
}1234567891011121312345678910111213
Crear sombreador
< Los sombreadores no son más que programas en C que se ejecutan en cada vértice de la GPU. En este tutorial, usaremos dos tipos de sombreadores: sombreadores de vértices y sombreadores de fragmentos.Código del sombreador de vértices:
atributo vec4 aPosition
atributo vec2 aTexPosition
variante vec2 vTexPosition
void main() {
g_Position = aPosition;
vTexPosition = aTexPosition
};12345671234567
Código para sombreador de fragmentos
precisión mediap float;
muestra uniforme2D uTexture;
variante vec2 vTexPosition
void main() {
gl_FragColor = textura2D(uTexture, vTexPosition);
};123456123456
Si conoce OpenGL, este código le resultará familiar. Aquí hay una breve descripción:
El sombreador de vértices es responsable de dibujar un único vértice. aPosition es una variable vinculada a un FloatBuffer que contiene las coordenadas de estos vértices. Asimismo
, aTexPosition es una variable vinculada a un FloatBuffer que contiene las coordenadas de la textura. gl_Position
es una variable creada en OpenGL que representa la posición de cada vértice, mientras que vTexPosition es una variable de matriz cuyo valor se pasa al sombreador de fragmentos.
En este tutorial, el sombreador de fragmentos es responsable de sombrear los cuadrados. Obtiene el color de la textura usando el método textura2D y asigna el color al fragmento usando una variable llamada gl_FragColor creada en OpenGL.
En esta clase, el código del sombreador debe convertirse en una cadena.
Cadena final privada vertexShaderCode =
"atributo vec4 aPosition;" +
"atributo vec2 aTexPosition;" +
"variante vec2 vTexPosition;" +
"void main() {" +
" gl_Position = aPosition;" +
" vTexPosition = aTexPosition;" +
"}";
FragmentShaderCode final privado =
"precisión mediump float;" +
"muestra uniforme2D uTexture;" p>
"variando vec2 vTexPosition;" +
"void main() {" +
" gl_FragColor = textura2D(uTexture, vTexPosition);"
" }";1234567891011121314151612345678910111213141516
Creación de un programa
Crea un nuevo método inicializeProgram para crear un programa OpenGL para compilar y vincular sombreadores.
Utilice glCreateShader para crear un objeto de sombreado y devolver un puntero a una representación int. Para crear un sombreador de vértices, páselo
GL_VERTEX_SHADER. Del mismo modo, para crear un sombreador de fragmentos, pase GL_FRAGMENT_SHADER. A continuación, utilizará el método
glShaderSource para asociar el código de sombreado correspondiente al sombreador. Utilice glCompileShader para compilar código de sombreado.
Después de compilar el código del sombreador, cree un nuevo programa, glCreateProgram, que, al igual que glCreateShader, devuelve un puntero a una representación int. Llame al método glAttachShader para adjuntar el sombreador al programa y finalmente llame a glLinkProgram para vincularlo.
Código:
privado int vertexShader;
privado int fragmentShader;
programa privado int;
privado void inicializeProgram(){
vertexShader = GLES20.glCreateShader(GLES20.glCreateShader)(GLES20.glCreateShader)glShaderSource(fragmentShader, fragmentShaderCode);
GLES20.glCompileShader(fragmentShader); p>
Programa = gles20.glcreatePrograph () fragmentshader);
Gles20.gllinkProgram (Programa);
} 2345678910111213141516171819
Puede que lo notes , los métodos OpenGL (comenzando con gl) están todos en la clase GLES20, esto se debe a que estamos usando OpenGL ES2.
Dibujar formas
Ahora defina el método de dibujo para que podamos Utilice los puntos y los sombreadores para dibujar formas.
Esto es lo que debe hacer:
1. Utilice el método glBindFramebuffer para crear un objeto framebuffer (FBO)
2 Como se mencionó anteriormente, llame a glUseProgram. para crear el Procedimiento
3. Pase GL_BLEND al método glDisable, que deshabilita la mezcla de colores durante el renderizado.
4. Llame a glGetAttribLocation para obtener los identificadores de las variables aPosition y aTexPosition
5. Utilice glVertexAttribPointer para conectar los identificadores de aPosition y aTexPosition a los respectivos verticesBuffer y aTexPosition.
6. Utilice el método glBindTexture para vincular la textura (pasada como parámetro al método de dibujo) al sombreador de fragmentos
7.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0); /p>
GLES20.glUseProgram(programa);
GLES20.glDisable(GLES20.GL_BLEND);
int positionHandle = GLES20.glGetAttribLocation( programa, "aPosition");
int texturaHandle = GLES20.glGetUniformLocation(GLES20.GL_BLEND);