OpenGL ES एनवायरमेंट बनाना

अपने Android एप्लिकेशन में OpenGL ES के साथ ग्राफ़िक बनाने के लिए, आपको एक देखें कंटेनर. ऐसा करने का एक ज़्यादा आसान तरीका यह है कि GLSurfaceView और GLSurfaceView.Renderer. ऐप्लिकेशन GLSurfaceView OpenGL और से बनाए गए ग्राफ़िक्स के लिए एक व्यू कंटेनर है GLSurfaceView.Renderer उस व्यू में ड्रॉ की जाने वाली चीज़ों को कंट्रोल करता है. Reader Revenue Manager को सेट अप करने के बारे में इन क्लास के बारे में ज़्यादा जानने के लिए, OpenGL ES देखें डेवलपर गाइड देखें.

GLSurfaceView, OpenGL ES ग्राफ़िक्स को शामिल करने का बस एक तरीका है का इस्तेमाल करें. फ़ुल-स्क्रीन या करीब-करीब पूरी स्क्रीन वाले ग्राफ़िक्स व्यू के लिए, यह विकल्प सही है. जो डेवलपर अपने लेआउट के छोटे हिस्से में OpenGL ES ग्राफ़िक्स शामिल करना चाहते हैं TextureView को देखें. असल में, इसे खुद करने वाले डेवलपर के लिए, यह SurfaceView का इस्तेमाल करके OpenGL ES व्यू बनाया जा सकता है. हालांकि, इसके लिए ज़रूरी है में से एक अतिरिक्त कोड लिखने में मदद करता है.

इस लेसन में बताया गया है कि 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 ग्राफ़िक के लिए कोई गतिविधि बनाएं

OpenGL ES का इस्तेमाल करने वाले Android ऐप्लिकेशन में ठीक उसी तरह की गतिविधियां होती हैं जैसे किसी दूसरे ऐप्लिकेशन में यूज़र इंटरफ़ेस पर काम करता है. अन्य ऐप्लिकेशन से मुख्य अंतर यह है कि आप अपने ऐप्लिकेशन के लेआउट में गतिविधि. हालांकि, कई ऐप्लिकेशन में 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 (एपीआई लेवल 8) या इसके बाद का वर्शन होना ज़रूरी है, इसलिए, पक्का करें कि आपका Android प्रोजेक्ट, एपीआई या उसके बाद के लेवल को टारगेट करता हो.

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 API का इस्तेमाल करते समय, हो सकता है कि इन तरीकों में GL10 पैरामीटर क्यों होता है. Android फ़्रेमवर्क कोड को बनाए रखने के लिए, इन तरीकों के सिग्नेचर को 2.0 एपीआई के लिए फिर से इस्तेमाल किया जाता है आसान.

अगर आपको OpenGL ES API के बारे में जानकारी है, तो अब आपके पास OpenGL ES सेट अप करने का विकल्प है एनवायरमेंट की जानकारी पाएं और ग्राफ़िक बनाना शुरू करें. हालांकि, अगर आपको OpenGL के साथ शुरू किया है, कुछ और संकेतों के लिए अगले लेसन पर जाएं.