יצירה של סביבת OpenGL ES

כדי לצייר גרפיקה באמצעות OpenGL ES באפליקציה ל-Android, צריך ליצור את המאגר בשבילם. אחת הדרכים הישירות יותר לעשות זאת היא להטמיע GLSurfaceView וגם GLSurfaceView.Renderer. א' GLSurfaceView הוא מאגר תצוגה לגרפיקה שצולמה באמצעות OpenGL ו GLSurfaceView.Renderer קובע מה מצויר בתצוגה הזו. אפשר לקבל מידע נוסף מידע על הכיתות האלה זמין ב-OpenGL ES המדריך למפתחים.

GLSurfaceView הוא רק דרך אחת לשילוב הגרפיקה של OpenGL ES תרגום מכונה. היא בחירה סבירה אם רוצים להציג גרפיקה במסך מלא או במסך כמעט מלא. מפתחים שרוצים לשלב את הגרפיקה של OpenGL ES בחלק קטן מהפריסות שלהם כדאי לקרוא את TextureView. עבור מפתחי 'עשה זאת בעצמך', אפשרית ליצירת תצוגת OpenGL ES באמצעות SurfaceView, אבל זה דורש ולכתוב עוד קצת קוד נוסף.

בשיעור הזה מוסבר איך להשלים הטמעה מינימלית של GLSurfaceView ושל GLSurfaceView.Renderer באופן פשוט פעילות באפליקציות.

הצהרה על שימוש ב-OpenGL ES במניפסט

כדי שהאפליקציה תוכל להשתמש ב-OpenGL ES 2.0 API, צריך להוסיף את הפרטים הבאים הצהרה למניפסט:

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

אם האפליקציה שלך משתמשת בדחיסת טקסטורה, עליך גם להצהיר אילו פורמטים של דחיסה שהאפליקציה שלך תומכת בה, כך שהיא מותקנת רק במכשירים תואמים.

<supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" />
<supports-gl-texture android:name="GL_OES_compressed_paletted_texture" />

למידע נוסף על פורמטים של דחיסת טקסטורה, אפשר לעיין מדריך למפתחים של OpenGL.

יצירת פעילות עבור הגרפיקה של OpenGL ES

באפליקציות ל-Android שמשתמשות ב-OpenGL ES יש פעילויות כמו כל אפליקציה אחרת ממשק משתמש. ההבדל העיקרי הוא מה שאתה מכניס בפריסה עבור פעילות. באפליקציות רבות שמאפשרות שימוש ב-TextView, ב-Button וב-ListView, באפליקציה שמשתמשת ב-OpenGL ES, אפשר מוסיפים גם GLSurfaceView.

בדוגמת הקוד הבאה מוצגת הטמעה מינימלית של פעילות המשתמשת ב- GLSurfaceView כתצוגה הראשית:

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);
    }
}

הערה: ל-OpenGL ES 2.0 נדרש Android בגרסה 2.2 (רמת API 8) ואילך, לכן חשוב לוודא שפרויקט Android שלכם מטרגט את ממשק ה-API הזה ואילך.

פיתוח אובייקט GLSurfaceView

GLSurfaceView היא תצוגה מיוחדת שבה אפשר לצייר OpenGL ES גרפי. הוא לא עושה הרבה כשלעצמו. השרטוט של האובייקטים נשלט בפועל GLSurfaceView.Renderer שהגדרת בתצוגה הזו. למעשה, הקוד הוא כל כך דק, עד שתתפתו לדלג על הרחבת האובייקט ופשוט ליצור מודל GLSurfaceView, אבל אין לעשות את זה. צריך להרחיב את הכיתה הזו בעוד כדי לתעד אירועי מגע, שמפורטים בקטע תגובה למגע אירועים.

הקוד החיוני לGLSurfaceView הוא מינימלי, לכן כדי לעיתים קרובות פשוט צרו כיתה פנימית בפעילות שמשתמשת בה:

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);
    }
}

תוספת אופציונלית אחת נוספת להטמעה של GLSurfaceView היא להגדיר במצב העיבוד כדי לשרטט את התצוגה רק כאשר מתבצע שינוי בנתוני השרטוט באמצעות 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);

ההגדרה הזו מונעת שרטוט מחדש של המסגרת GLSurfaceView עד קוראים לפונקציה requestRender(), יעיל עבור האפליקציה לדוגמה הזו.

יצירת מחלקה של כלי רינדור

ההטמעה של המחלקה GLSurfaceView.Renderer או של כלי הרינדור, בתוך אפליקציה שמשתמשת ב-OpenGL ES, זה מתחיל להיות מעניין. הכיתה הזו אמצעי בקרה של מה שמשורטט בGLSurfaceView שאליו הוא משויך. יש שלוש שיטות בכלי רינדור, שמערכת Android מפעילה כדי להבין מה איך לצייר על GLSurfaceView:

• onSurfaceCreated() – בוצעה קריאה פעם אחת כדי להגדיר את סביבת OpenGL ES בתצוגה.
• onDrawFrame() – שיחה עבור כל אחד מהם לשרטט מחדש את התצוגה.
• onSurfaceChanged() – תתבצע שיחה אם הגיאומטריה של התצוגה משתנה, לדוגמה, כשכיוון המסך של המכשיר משתנה.

הנה הטמעה בסיסית מאוד של כלי לרינדור OpenGL ES, שלא עושה רק ציור רקע שחור ב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);
    }
}

זה הכול! דוגמאות הקוד שלמעלה יוצרות אפליקציה פשוטה ל-Android מציגה מסך שחור באמצעות OpenGL. אמנם הקוד הזה לא עושה שום דבר מעניין, ביצירת הכיתות האלה, הכנתם את היסודות הדרושים כדי להתחיל לשרטט אלמנטים גרפיים OpenGL.

הערה: כשמשתמשים ב-OpengGL ES 2.0 APIs, השיטות האלה מכילות פרמטר GL10. בחתימות של השיטה נעשה שימוש חוזר בממשקי ה-API בגרסה 2.0 כדי לשמור את קוד ה-framework של Android לפשוט יותר.

אם אתם מכירים את ממשקי ה-API של OpenGL ES, עכשיו אתם יכולים להגדיר את האפשרות OpenGL ES את הסביבה באפליקציה שלך ולהתחיל לשרטט גרפיקה. עם זאת, אם אתם צריכים עוד קצת עזרה עם OpenGL, אז עברו לשיעורים הבאים כדי לקבל עוד כמה רמזים.