Cómo agregar movimiento
Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Dibujar objetos en la pantalla es una función bastante básica de OpenGL, pero se puede hacer con otros
Las clases de framework de gráficos de Android, incluidas Canvas
y
Drawable
. OpenGL ES proporciona capacidades adicionales para
mover y transformar objetos dibujados en tres dimensiones o de otras formas únicas para crear
experiencias del usuario atractivas.
En esta lección, darás otro paso hacia el uso de OpenGL ES y aprenderás a agregar movimiento.
a una forma con rotación.
Cómo rotar una forma
La rotación de un objeto de dibujo con OpenGL ES 2.0 es bastante simple. En tu procesador, crea
otra matriz de transformación (una matriz de rotación) y, luego, combinarla con tu proyección
Matrices de transformación de vista de cámara:
Kotlin
private val rotationMatrix = FloatArray(16)
override fun onDrawFrame(gl: GL10) {
val scratch = FloatArray(16)
...
// Create a rotation transformation for the triangle
val time = SystemClock.uptimeMillis() % 4000L
val angle = 0.090f * time.toInt()
Matrix.setRotateM(rotationMatrix, 0, angle, 0f, 0f, -1.0f)
// Combine the rotation matrix with the projection and camera view
// Note that the vPMatrix factor *must be first* in order
// for the matrix multiplication product to be correct.
Matrix.multiplyMM(scratch, 0, vPMatrix, 0, rotationMatrix, 0)
// Draw triangle
mTriangle.draw(scratch)
}
Java
private float[] rotationMatrix = new float[16];
@Override
public void onDrawFrame(GL10 gl) {
float[] scratch = new float[16];
...
// Create a rotation transformation for the triangle
long time = SystemClock.uptimeMillis() % 4000L;
float angle = 0.090f * ((int) time);
Matrix.setRotateM(rotationMatrix, 0, angle, 0, 0, -1.0f);
// Combine the rotation matrix with the projection and camera view
// Note that the vPMatrix factor *must be first* in order
// for the matrix multiplication product to be correct.
Matrix.multiplyMM(scratch, 0, vPMatrix, 0, rotationMatrix, 0);
// Draw triangle
mTriangle.draw(scratch);
}
Si el triángulo no rota después de hacer estos cambios, asegúrate de haber comentado el
GLSurfaceView.RENDERMODE_WHEN_DIRTY
de configuración, como se describe en la siguiente sección.
Cómo habilitar el procesamiento continuo
Si seguiste diligentemente el código de ejemplo de esta clase hasta ahora,
asegúrate de comentar la línea que configura el modo de renderización solo dibuja cuando está sucia; de lo contrario, OpenGL
Rota la forma solo un incremento y, luego, espera una llamada a requestRender()
desde el contenedor GLSurfaceView
:
Kotlin
class MyGLSurfaceView(context: Context) : GLSurfaceView(context) {
init {
...
// Render the view only when there is a change in the drawing data.
// To allow the triangle to rotate automatically, this line is commented out:
// renderMode = GLSurfaceView.RENDERMODE_WHEN_DIRTY
}
}
Java
public class MyGLSurfaceView(Context context) extends GLSurfaceView {
...
// Render the view only when there is a change in the drawing data.
// To allow the triangle to rotate automatically, this line is commented out:
//setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}
A menos que haya objetos que cambien sin ninguna interacción del usuario, suele ser una buena idea tener este
función experimental activada. Prepárate para quitar el comentario de este código, ya que la siguiente lección hace que esta llamada sea aplicable
una vez más.
El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.
Última actualización: 2025-07-27 (UTC)
[null,null,["Última actualización: 2025-07-27 (UTC)"],[],[],null,["# Add motion\n\nDrawing objects on screen is a pretty basic feature of OpenGL, but you can do this with other\nAndroid graphics framework classes, including [Canvas](/reference/android/graphics/Canvas) and\n[Drawable](/reference/android/graphics/drawable/Drawable) objects. OpenGL ES provides additional capabilities for\nmoving and transforming drawn objects in three dimensions or in other unique ways to create\ncompelling user experiences.\n\nIn this lesson, you take another step forward into using OpenGL ES by learning how to add motion\nto a shape with rotation.\n\nRotate a shape\n--------------\n\nRotating a drawing object with OpenGL ES 2.0 is relatively simple. In your renderer, create\nanother transformation matrix (a rotation matrix) and then combine it with your projection and\ncamera view transformation matrices: \n\n### Kotlin\n\n```kotlin\nprivate val rotationMatrix = FloatArray(16)\n\noverride fun onDrawFrame(gl: GL10) {\n val scratch = FloatArray(16)\n\n ...\n\n // Create a rotation transformation for the triangle\n val time = SystemClock.uptimeMillis() % 4000L\n val angle = 0.090f * time.toInt()\n Matrix.setRotateM(rotationMatrix, 0, angle, 0f, 0f, -1.0f)\n\n // Combine the rotation matrix with the projection and camera view\n // Note that the vPMatrix factor *must be first* in order\n // for the matrix multiplication product to be correct.\n Matrix.multiplyMM(scratch, 0, vPMatrix, 0, rotationMatrix, 0)\n\n // Draw triangle\n mTriangle.draw(scratch)\n}\n```\n\n### Java\n\n```java\nprivate float[] rotationMatrix = new float[16];\n@Override\npublic void onDrawFrame(GL10 gl) {\n float[] scratch = new float[16];\n\n ...\n\n // Create a rotation transformation for the triangle\n long time = SystemClock.uptimeMillis() % 4000L;\n float angle = 0.090f * ((int) time);\n Matrix.setRotateM(rotationMatrix, 0, angle, 0, 0, -1.0f);\n\n // Combine the rotation matrix with the projection and camera view\n // Note that the vPMatrix factor *must be first* in order\n // for the matrix multiplication product to be correct.\n Matrix.multiplyMM(scratch, 0, vPMatrix, 0, rotationMatrix, 0);\n\n // Draw triangle\n mTriangle.draw(scratch);\n}\n```\n\nIf your triangle does not rotate after making these changes, make sure you have commented out the\n[GLSurfaceView.RENDERMODE_WHEN_DIRTY](/reference/android/opengl/GLSurfaceView#RENDERMODE_WHEN_DIRTY)\nsetting, as described in the next section.\n\nEnable continuous rendering\n---------------------------\n\nIf you have diligently followed along with the example code in this class to this point, make\nsure you comment out the line that sets the render mode only draw when dirty, otherwise OpenGL\nrotates the shape only one increment and then waits for a call to [requestRender()](/reference/android/opengl/GLSurfaceView#requestRender()) from the [GLSurfaceView](/reference/android/opengl/GLSurfaceView) container: \n\n### Kotlin\n\n```kotlin\nclass MyGLSurfaceView(context: Context) : GLSurfaceView(context) {\n\n init {\n ...\n // Render the view only when there is a change in the drawing data.\n // To allow the triangle to rotate automatically, this line is commented out:\n // renderMode = GLSurfaceView.RENDERMODE_WHEN_DIRTY\n }\n}\n```\n\n### Java\n\n```java\npublic class MyGLSurfaceView(Context context) extends GLSurfaceView {\n ...\n // Render the view only when there is a change in the drawing data.\n // To allow the triangle to rotate automatically, this line is commented out:\n //setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);\n}\n```\n\nUnless you have objects changing without any user interaction, it's usually a good idea have this\nflag turned on. Be ready to uncomment this code, because the next lesson makes this call applicable\nonce again."]]