Menambahkan gerakan
Tetap teratur dengan koleksi
Simpan dan kategorikan konten berdasarkan preferensi Anda.
Menggambar objek di layar adalah fitur yang cukup dasar pada OpenGL, tetapi Anda bisa melakukannya dengan
Class framework grafis Android, termasuk Canvas
dan
Drawable
objek. OpenGL ES menyediakan kemampuan tambahan untuk
memindahkan dan mengubah objek yang digambar dalam tiga dimensi atau dengan cara unik lainnya untuk membuat
pengalaman pengguna
yang menarik.
Dalam pelajaran ini, Anda mengambil langkah maju untuk menggunakan OpenGL ES dengan mempelajari cara menambahkan gerakan
menjadi bentuk dengan rotasi.
Memutar bentuk
Memutar objek gambar dengan OpenGL ES 2.0 relatif sederhana. Di perender, buat
matriks transformasi lain (matriks rotasi) dan kemudian menggabungkannya dengan proyeksi dan
matriks transformasi tampilan kamera:
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);
}
Jika segitiga tidak berputar setelah membuat perubahan ini, pastikan Anda telah menuliskan komentar
GLSurfaceView.RENDERMODE_WHEN_DIRTY
seperti yang dijelaskan di bagian berikutnya.
Mengaktifkan rendering berkelanjutan
Jika sudah rajin mengikuti kode contoh di kelas ini sampai saat ini, pastikan
pastikan Anda mengomentari baris yang menyetel mode render hanya menggambar jika kotor, jika tidak OpenGL
memutar bentuk hanya satu pertambahan, lalu menunggu panggilan ke requestRender()
dari container 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);
}
Kecuali jika Anda memiliki objek yang berubah tanpa interaksi pengguna, sebaiknya buat dahulu hal ini
tanda diaktifkan. Bersiaplah untuk menghapus tanda komentar pada kode ini, karena tutorial berikutnya akan membuat panggilan ini dapat diterapkan
sekali lagi.
Konten dan contoh kode di halaman ini tunduk kepada lisensi yang dijelaskan dalam Lisensi Konten. Java dan OpenJDK adalah merek dagang atau merek dagang terdaftar dari Oracle dan/atau afiliasinya.
Terakhir diperbarui pada 2025-07-27 UTC.
[[["Mudah dipahami","easyToUnderstand","thumb-up"],["Memecahkan masalah saya","solvedMyProblem","thumb-up"],["Lainnya","otherUp","thumb-up"]],[["Informasi yang saya butuhkan tidak ada","missingTheInformationINeed","thumb-down"],["Terlalu rumit/langkahnya terlalu banyak","tooComplicatedTooManySteps","thumb-down"],["Sudah usang","outOfDate","thumb-down"],["Masalah terjemahan","translationIssue","thumb-down"],["Masalah kode / contoh","samplesCodeIssue","thumb-down"],["Lainnya","otherDown","thumb-down"]],["Terakhir diperbarui pada 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."]]