इस पेज का अनुवाद Cloud Translation API से किया गया है.

OpenGL ES

Android में ओपन ग्राफ़िक लाइब्रेरी के साथ बेहतर परफ़ॉर्मेंस वाले 2D और 3D ग्राफ़िक्स जोड़े जा सकते हैं (OpenGL®), खास तौर पर, OpenGL ES API. OpenGL एक क्रॉस-प्लैटफ़ॉर्म ग्राफ़िक्स एपीआई है यह तय करता है कि 3D ग्राफ़िक्स प्रोसेसिंग हार्डवेयर के लिए मानक सॉफ़्टवेयर इंटरफ़ेस. OpenGL ES, OpenGL का एक फ़्लेवर है एम्बेड किए गए डिवाइसों के लिए खास जानकारी. Android, OpenGL ES के कई वर्शन के साथ काम करता है एपीआई:

OpenGL ES 2.0 - एपीआई की यह खास जानकारी, Android 2.2 (एपीआई लेवल 8) और इसके बाद वाले वर्शन पर काम करती है.
OpenGL ES 3.0 - एपीआई की यह खास जानकारी, Android 4.3 (एपीआई लेवल 18) और उसके बाद वाले वर्शन पर काम करती है.
OpenGL ES 3.1 - एपीआई की यह खास जानकारी, Android 5.0 (एपीआई लेवल 21) और उसके बाद वाले वर्शन पर काम करती है.
OpenGL ES 3.2 - एपीआई की यह खास जानकारी, Android 7.0 (एपीआई लेवल 24) और उसके बाद वाले वर्शन पर काम करती है.

चेतावनी: Android प्लैटफ़ॉर्म का वर्शन चाहे जो भी हो, डिवाइस पर OpenGL ES 3.0 API को तब तक इस्तेमाल करना होगा, जब तक डिवाइस मैन्युफ़ैक्चरर लागू करने के लिए कहा जा सकता है. अगर मेनिफ़ेस्ट में यह बताया जाता है कि OpenGL ES 3.0 आवश्यक है, आप सुनिश्चित हो सकते हैं कि वह वर्शन मौजूद होगा डिवाइस पर. अगर आपने यह बताया है कि निचले लेवल का वर्शन ज़रूरी है, लेकिन 3.0 सुविधाएँ उपलब्ध होने पर उनका इस्तेमाल करना है, तो आपको रन टाइम पर जाकर देखना चाहिए देखें कि डिवाइस OpenGL के किस वर्शन पर काम करता है. यह जानने के लिए कि ऐसा करने के लिए, OpenGL ES वर्शन की जांच करना देखें.

ध्यान दें: Android में OpenGL ES 1.0 और 1.1 वर्शन शामिल हैं, लेकिन एपीआई के ये वर्शन इनके इस्तेमाल पर रोक लगा दी गई है और आधुनिक ऐप्लिकेशन इनका इस्तेमाल नहीं करना चाहिए.

ध्यान दें: Android फ़्रेमवर्क से मिला खास एपीआई, J2ME JSR239 OpenGL ES API के जैसा है, लेकिन समान नहीं है. अगर आपको J2ME JSR239 के स्पेसिफ़िकेशन के बारे में जानकारी है, तो अलग-अलग वर्शन.

यह भी देखें

बुनियादी बातें

Android, अपने फ़्रेमवर्क एपीआई और नेटिव डेवलपमेंट, दोनों की मदद से OpenGL के साथ काम करता है किट (एनडीके). यह विषय, Android फ़्रेमवर्क के इंटरफ़ेस पर फ़ोकस करता है. इस बारे में ज़्यादा जानकारी पाने के लिए NDK, Android NDK देखें.

Android फ़्रेमवर्क में दो बुनियादी क्लास हैं, जिनकी मदद से नया वर्शन बनाया जा सकता है और उसमें बदलाव किया जा सकता है OpenGL ES API वाले ग्राफ़िक: GLSurfaceView और GLSurfaceView.Renderer. अगर आपका लक्ष्य अपने Android ऐप्लिकेशन में OpenGL का इस्तेमाल करना है, आपका पहला मकसद यह समझना होना चाहिए कि किसी गतिविधि में इन क्लास को कैसे लागू किया जाता है.

GLSurfaceView

यह क्लास एक View है, जहां आप ऑब्जेक्ट ड्रॉ करने और उनमें बदलाव करने के लिए, इनका इस्तेमाल कर सकते हैं OpenGL API कॉल और SurfaceView की तरह ही काम करता है. Google Analytics 4 पर माइग्रेट करने के लिए, इस क्लास को GLSurfaceView का इंस्टेंस बनाकर और अपने Renderer. हालांकि, अगर आपको डिजिटल विज्ञापन से टचस्क्रीन इवेंट बनाने के लिए, आपको GLSurfaceView क्लास को टच लिसनर को लागू कर सकते हैं, जैसा कि OpenGL ट्रेनिंग लेसन में दिखाया गया है. टच इवेंट का जवाब देना.

GLSurfaceView.Renderer

इस इंटरफ़ेस में, GLSurfaceView में ग्राफ़िक बनाने के लिए ज़रूरी तरीकों के बारे में बताया गया है. आपको इस इंटरफ़ेस को लागू करने के लिए क्लास को अलग करें और इसका इस्तेमाल करके उसे अपने GLSurfaceView इंस्टेंस में अटैच करें GLSurfaceView.setRenderer().

GLSurfaceView.Renderer इंटरफ़ेस के लिए ज़रूरी है कि आप नीचे दिए गए तरीके अपनाएं:

onSurfaceCreated(): सिस्टम इसे कॉल करता है विधि को एक बार, GLSurfaceView बनाते समय. कार्रवाई करने के लिए यह तरीका अपनाएं ऐसी कार्रवाइयाँ जिन्हें सिर्फ़ एक बार करना ज़रूरी है. जैसे, OpenGL एनवायरमेंट पैरामीटर सेट करना या OpenGL ग्राफ़िक ऑब्जेक्ट शुरू कर रहे हैं.
onDrawFrame(): सिस्टम इस तरीके को GLSurfaceView के हर फिर से ड्रॉ पर कॉल करता है. इस विधि का उपयोग इसके लिए प्राथमिक निष्पादन बिंदु के रूप में करें ग्राफ़िक ऑब्जेक्ट बनाने (और फिर से बनाने) के लिए किया जा सकता है.
onSurfaceChanged(): सिस्टम इस तरीके का इस्तेमाल तब करता है, जब GLSurfaceView की ज्यामिति बदलती है. इसमें GLSurfaceView के साइज़ या डिवाइस की स्क्रीन की दिशा में भी बदलाव शामिल हैं. उदाहरण के लिए, सिस्टम इस तरीके का इस्तेमाल तब किया जाता है, जब डिवाइस पोर्ट्रेट से लैंडस्केप ओरिएंटेशन में बदल जाता है. इस तरीके का इस्तेमाल वह GLSurfaceView कंटेनर में हुए बदलावों के मुताबिक काम करता है.

OpenGL ES पैकेज

GLSurfaceView और GLSurfaceView.Renderer का इस्तेमाल करके OpenGL ES के लिए कंटेनर व्यू बनाने के बाद, नीचे दी गई क्लास का इस्तेमाल करके OpenGL API को कॉल करना:

OpenGL ES 2.0 एपीआई क्लास
- android.opengl.GLES20 - यह पैकेज आपको इंटरफ़ेस को OpenGL ES 2.0 पर चलाते हैं और यह Android 2.2 (एपीआई लेवल 8) से शुरू होने वाले वर्शन के लिए उपलब्ध है.
OpenGL ES 3.0/3.1/3.2 एपीआई पैकेज
- android.opengl - यह पैकेज OpenGL ES 3.0/3.1 का इंटरफ़ेस उपलब्ध कराता है क्लास. वर्शन 3.0, Android 4.3 (एपीआई लेवल 18) के साथ उपलब्ध है. वर्शन 3.1 उपलब्ध है Android 5.0 (एपीआई लेवल 21) से शुरू करना होगा. वर्शन 3.2, Android 7.0 (एपीआई) के साथ उपलब्ध है लेवल 24).
  - GLES30
  - GLES31
  - GLES31Ext (Android एक्सटेंशन पैक)
  - GLES32

अगर आप अभी OpenGL ES के साथ कोई ऐप्लिकेशन बनाना शुरू करना चाहते हैं, तो OpenGL ES के साथ ग्राफ़िक दिखाना क्लास.

OpenGL की ज़रूरी शर्तों के बारे में जानकारी

यदि आपका ऐप्लिकेशन ऐसे OpenGL सुविधाओं का उपयोग करता है जो सभी डिवाइस पर उपलब्ध नहीं हैं, तो आपको AndroidManifest.xml में ये ज़रूरी शर्तें फ़ाइल से लिए जाते हैं. OpenGL मेनिफ़ेस्ट के सबसे आम एलानों के बारे में यहां बताया गया है:

OpenGL ES वर्शन की ज़रूरी शर्तें - अगर आपके ऐप्लिकेशन के लिए किसी खास इसका वर्शन OpenGL ES में, आपको अपने मेनिफ़ेस्ट में इन सेटिंग को जोड़कर, उस ज़रूरत का एलान करना होगा नीचे दी गई जानकारी देखें.
OpenGL ES 2.0 के लिए:
```

<uses-feature android:glEsVersion="0x00020000" android:required="true" />
```
इस एलान को जोड़ने पर, Google Play आपके ऐप्लिकेशन पर पाबंदी लगा देता है. OpenGL ES 2.0 समर्थन नहीं करने वाले डिवाइस पर इंस्टॉल किया गया है. अगर आपका ऐप्लिकेशन खास तौर पर ऐसे डिवाइस जो OpenGL ES 3.0 का समर्थन करते हैं, तो आप इसे अपने मेनिफ़ेस्ट में भी तय कर सकते हैं:

OpenGL ES 3.0 के लिए:
```

<uses-feature android:glEsVersion="0x00030000" android:required="true" />
```
OpenGL ES 3.1 के लिए:
```

<uses-feature android:glEsVersion="0x00030001" android:required="true" />
```
OpenGL ES 3.2 के लिए:
```

<uses-feature android:glEsVersion="0x00030002" android:required="true" />
```
ध्यान दें: OpenGL ES 3.x API, 2.0 API के साथ पुराने सिस्टम के साथ काम करता है. इसका मतलब है कि इसे आपके ऐप्लिकेशन में OpenGL ES को लागू करने के साथ-साथ किया जा सकता है. OpenGL की घोषणा करके अगर आपने मेनिफ़ेस्ट में ES 2.0 API को ज़रूरी शर्त के तौर पर शामिल किया है, तो उस एपीआई वर्शन को डिफ़ॉल्ट के तौर पर इस्तेमाल किया जा सकता है. 3.x API की उपलब्धता के बारे में और फिर OpenGL ES 3.x सुविधाओं का उपयोग करें डिवाइस पर यह सुविधा काम करती है. इसके साथ काम करने वाले OpenGL ES वर्शन की जांच करने के बारे में ज़्यादा जानकारी के लिए: डिवाइस में, OpenGL ES वर्शन की जांच करना देखें.
टेक्सचर कंप्रेस करने की ज़रूरी शर्तें - अगर आपका ऐप्लिकेशन टेक्सचर का इस्तेमाल करता है कंप्रेशन फ़ॉर्मैट का इस्तेमाल नहीं करता है, तो आपको अपनी मेनिफ़ेस्ट फ़ाइल में उन फ़ॉर्मैट के बारे में बताना होगा जिन पर आपका ऐप्लिकेशन काम करता है <supports-gl-texture> का इस्तेमाल करके. उपलब्ध टेक्सचर कंप्रेशन के बारे में ज़्यादा जानकारी के लिए के फ़ॉर्मैट के लिए, टेक्सचर कंप्रेस करने से जुड़ी सहायता देखें.
अपने मेनिफ़ेस्ट में टेक्सचर कंप्रेस करने की ज़रूरत के बारे में बताने से, आपका ऐप्लिकेशन उपयोगकर्ताओं को नहीं दिखेगा ऐसे डिवाइसों के साथ काम करता है जो आपके बताए गए कम से कम किसी एक कंप्रेशन टाइप पर काम नहीं करते. ज़्यादा के लिए टेक्सचर कंप्रेस करने के लिए, Google Play फ़िल्टर करने की सुविधा कैसे काम करती है, इस बारे में ज़्यादा जानकारी के लिए, <supports-gl-texture> दस्तावेज़ का, Google Play और टेक्सचर कंप्रेशन फ़िल्टर करने की सुविधा वाला सेक्शन.

ड्रॉ किए गए ऑब्जेक्ट के लिए निर्देशांक मैप करना

Android डिवाइस पर ग्राफ़िक दिखाने की बुनियादी समस्याओं में से एक यह है कि उनकी स्क्रीन अलग-अलग तरह के साइज़ और आकार हो सकते हैं. OpenGL एक वर्ग, एक जैसा निर्देशांक सिस्टम अपनाता है और डिफ़ॉल्ट रूप से, खुशी से उन कोऑर्डिनेट को आपकी आम तौर पर नॉन-स्क्वेयर स्क्रीन पर ऐसे ड्रॉ करता है जैसे कि वह पूरी तरह से स्क्वेयर हो.

पहला डायग्राम. डिफ़ॉल्ट OpenGL कोऑर्डिनेट सिस्टम (बाएं) जिसे किसी सामान्य Android पर मैप किया गया है डिवाइस की स्क्रीन (दाएं).

ऊपर दिए गए उदाहरण में, एक समान निर्देशांक सिस्टम दिखाया गया है, जिसका मानना है कि OpenGL फ़्रेम पर और देखना कि ये निर्देशांक किसी सामान्य डिवाइस की स्क्रीन पर लैंडस्केप ओरिएंटेशन में कैसे मैप होते हैं दाईं ओर. इस समस्या को हल करने के लिए, OpenGL प्रोजेक्शन मोड और कैमरा व्यू को इस पर लागू किया जा सकता है निर्देशांकों को बदल सकते हैं, ताकि किसी भी डिसप्ले पर आपके ग्राफ़िक ऑब्जेक्ट का सही अनुपात हो.

प्रोजेक्शन और कैमरा व्यू लागू करने के लिए, प्रोजेक्शन मैट्रिक्स और कैमरा व्यू बनाना होता है मैट्रिक्स को शामिल करना है और उन्हें OpenGL रेंडरिंग पाइपलाइन पर लागू करना है. प्रोजेक्शन मैट्रिक्स ताकि वे Android डिवाइस स्क्रीन पर सही ढंग से मैप हों. कैमरा व्यू मैट्रिक्स ऐसा बदलाव करता है जो आंख की किसी खास जगह से ऑब्जेक्ट को रेंडर करता है.

OpenGL ES 2.0 और इसके बाद के वर्शन में प्रोजेक्शन और कैमरा व्यू

ES 2.0 और 3.0 API में, आप पहले मैट्रिक्स मेंबर जोड़कर प्रोजेक्शन और कैमरा व्यू लागू करते हैं आपके ग्राफ़िक्स ऑब्जेक्ट के वर्टेक्स शेडर तक पहुँच सकते हैं. इस मैट्रिक्स सदस्य को जोड़ने के बाद, अपने ऑब्जेक्ट के लिए प्रोजेक्शन और कैमरा व्यू मैट्रिक्स जनरेट करें और लागू करें.

वर्टेक्स शेडर में मैट्रिक्स जोड़ें - व्यू प्रोजेक्शन मैट्रिक्स के लिए वैरिएबल बनाएं और इसे शेडर की पोज़िशन के मल्टीप्लायर के तौर पर शामिल करें. नीचे दिए गए वर्टेक्स शेडर के उदाहरण में कोड, शामिल किए गए uMVPMatrix सदस्य से आपको प्रोजेक्शन और कैमरे से देखने की सुविधा लागू करने की अनुमति मिलती है इस शेडर का इस्तेमाल करने वाले ऑब्जेक्ट के कोऑर्डिनेट पर, मैट्रिक्स को वैल्यू के तौर पर जोड़ा जाता है.
Kotlin
```
private val vertexShaderCode =

    // This matrix member variable provides a hook to manipulate
    // the coordinates of objects that use this vertex shader.
    "uniform mat4 uMVPMatrix;   \n" +

    "attribute vec4 vPosition;  \n" +
    "void main(){               \n" +
    // The matrix must be included as part of gl_Position
    // Note that the uMVPMatrix factor *must be first* in order
    // for the matrix multiplication product to be correct.
    " gl_Position = uMVPMatrix * vPosition; \n" +

    "}  \n"
```
Java
```
private final String vertexShaderCode =

    // This matrix member variable provides a hook to manipulate
    // the coordinates of objects that use this vertex shader.
    "uniform mat4 uMVPMatrix;   \n" +

    "attribute vec4 vPosition;  \n" +
    "void main(){               \n" +
    // The matrix must be included as part of gl_Position
    // Note that the uMVPMatrix factor *must be first* in order
    // for the matrix multiplication product to be correct.
    " gl_Position = uMVPMatrix * vPosition; \n" +

    "}  \n";
```
ध्यान दें: ऊपर दिया गया उदाहरण, सिंगल ट्रांसफ़ॉर्मेशन मैट्रिक्स को परिभाषित करता है वर्टेक्स शेडर में सदस्य हों, जिसमें आप कंबाइंड प्रोजेक्शन मैट्रिक्स और कैमरा व्यू लागू करते हैं मैट्रिक्स. अपने ऐप्लिकेशन की ज़रूरतों के आधार पर, हो सकता है कि आप अलग प्रोजेक्शन निर्धारित करना चाहें आपके वर्टेक्स शेडर में मैट्रिक्स और कैमरा देखने वाले मैट्रिक्स के सदस्य, ताकि आप उन्हें बदल सकें स्वतंत्र रूप से काम करता है.
शेडर मैट्रिक्स को ऐक्सेस करना - अपने वर्टेक्स शेडर में हुक बनाने के बाद, प्रोजेक्शन और कैमरा व्यू लागू करें, फिर आप प्रोजेक्शन लागू करने के लिए उस वैरिएबल को ऐक्सेस कर सकते हैं और कैमरा देखने के आव्यूह. नीचे दिया गया कोड, मैट्रिक्स को ऐक्सेस करने के लिए, GLSurfaceView.Renderer को लागू करने के onSurfaceCreated() तरीके में बदलाव करने का तरीका बताता है ऊपर दिए गए वर्टेक्स शेडर में तय किया गया वैरिएबल.
Kotlin
```
override fun onSurfaceCreated(gl: GL10, config: EGLConfig) {
    ...
    muMVPMatrixHandle = GLES20.glGetUniformLocation(program, "uMVPMatrix")
    ...
}
```
Java
```
public void onSurfaceCreated(GL10 unused, EGLConfig config) {
    ...
    muMVPMatrixHandle = GLES20.glGetUniformLocation(program, "uMVPMatrix");
    ...
}
```

प्रॉजेक्शन और कैमरे के व्यू वाले आव्यूह बनाएं - प्रोजेक्शन जनरेट करें और ग्राफ़िक ऑब्जेक्ट लागू करने के लिए आव्यूह देखना. नीचे दिया गया उदाहरण कोड बदलाव करने का तरीका बताता है onSurfaceCreated() और onSurfaceChanged() तरीके से कैमरा व्यू मैट्रिक्स बनाने के लिए GLSurfaceView.Renderer लागू किया गया है और डिवाइस के स्क्रीन के पक्षानुपात पर आधारित प्रोजेक्शन मैट्रिक्स.

Kotlin

override fun onSurfaceCreated(gl: GL10, config: EGLConfig) {
    ...
    // Create a camera view matrix
    Matrix.setLookAtM(vMatrix, 0, 0f, 0f, -3f, 0f, 0f, 0f, 0f, 1.0f, 0.0f)
}

override fun onSurfaceChanged(gl: GL10, width: Int, height: Int) {
    GLES20.glViewport(0, 0, width, height)

    val ratio: Float = width.toFloat() / height.toFloat()

    // create a projection matrix from device screen geometry
    Matrix.frustumM(projMatrix, 0, -ratio, ratio, -1f, 1f, 3f, 7f)
}

Java

public void onSurfaceCreated(GL10 unused, EGLConfig config) {
    ...
    // Create a camera view matrix
    Matrix.setLookAtM(vMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
}

public void onSurfaceChanged(GL10 unused, int width, int height) {
    GLES20.glViewport(0, 0, width, height);

    float ratio = (float) width / height;

    // create a projection matrix from device screen geometry
    Matrix.frustumM(projMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
}

प्रेक्षपण और कैमरे देखने वाले आव्यूह लागू करें - प्रोजेक्शन लागू करने के लिए और कैमरा व्यू रूपांतरण, आव्यूहों को साथ में गुणा करें और फिर उन्हें शीर्ष में सेट करें शेडर. कोड का यह उदाहरण दिखाता है कि GLSurfaceView.Renderer को जोड़ने के लिए, onDrawFrame() तरीके में बदलाव कैसे किया जाता है ऊपर दिए गए कोड में बनाया गया प्रोजेक्शन मैट्रिक्स और कैमरा व्यू. इसके बाद, इन्हें ग्राफ़िक पर लागू करें ऑब्जेक्ट को OpenGL द्वारा रेंडर करने के लिए किया जाता है.
Kotlin
```
override fun onDrawFrame(gl: GL10) {
    ...
    // Combine the projection and camera view matrices
    Matrix.multiplyMM(vPMatrix, 0, projMatrix, 0, vMatrix, 0)

    // Apply the combined projection and camera view transformations
    GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, vPMatrix, 0)

    // Draw objects
    ...
}
```
Java
```
public void onDrawFrame(GL10 unused) {
    ...
    // Combine the projection and camera view matrices
    Matrix.multiplyMM(vPMatrix, 0, projMatrix, 0, vMatrix, 0);

    // Apply the combined projection and camera view transformations
    GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, vPMatrix, 0);

    // Draw objects
    ...
}
```

OpenGL ES 2.0 पर प्रोजेक्शन और कैमरा व्यू लागू करने के तरीके के पूरे उदाहरण के लिए, OpenGL ES के साथ ग्राफ़िक दिखाना लेख पढ़ें क्लास.

चेहरों को आकार देना और पंख लगाना

OpenGL में, आकार का चेहरा त्रि-आयामी में 3 या ज़्यादा बिंदुओं से परिभाषित सतह है स्पेस. तीन या उससे ज़्यादा थ्री-डाइमेंशन वाले पॉइंट के सेट (जिसे OpenGL में वर्टेक्स कहते हैं) का चेहरा सामने का होता है और पीछे का चेहरा दिख रहा हो. आपको कैसे पता चलेगा कि कौनसा चेहरा सामने का है और कौनसा पिछला हिस्सा? यह एक अच्छा सवाल है. कॉन्टेंट बनाने जवाब का विषय घुमावदार होने से है या वह उस दिशा से है जिसमें आप किसी आकार के बिंदु तय करते हैं.

पहला डायग्राम. निर्देशांक सूची का इलस्ट्रेशन जिसका अनुवाद जिसे घड़ी की उलटी दिशा में ड्रॉइंग बनाने के लिए इस्तेमाल किया जा सकता है.

इस उदाहरण में, त्रिभुज के बिंदु एक क्रम में तय किए गए हैं, ताकि वे घड़ी की उलटी दिशा में. जिस क्रम में ये निर्देशांक बनाए जाते हैं, वह घुमक्कड़ को परिभाषित करता है आकार के लिए दिशा तय करें. डिफ़ॉल्ट रूप से, OpenGL में, घड़ी की विपरीत दिशा में बनाया गया चेहरा होता है . पहली इमेज में दिखाए गए त्रिभुज को इस तरह से तय किया गया है कि आप आकार (जैसा कि OpenGL के मुताबिक बताया गया है) और दूसरी ओर पिछला चेहरा है.

यह जानना क्यों ज़रूरी है कि सामने वाला चेहरा कौनसा है? आपका जवाब सिर्फ़ OpenGL की आम तौर पर इस्तेमाल की जाने वाली सुविधा है, जिसे फ़ेस कलिंग कहते हैं. OpenGL का इस्तेमाल करके, चेहरे की फ़ोटो खींचने का टूल इस्तेमाल किया जा सकता है ऐसा वातावरण जो रेंडरिंग पाइपलाइन को किसी आकार, समय की बचत, मेमोरी और प्रोसेसिंग साइकल:

Kotlin

gl.apply {
    // enable face culling feature
    glEnable(GL10.GL_CULL_FACE)
    // specify which faces to not draw
    glCullFace(GL10.GL_BACK)
}

Java

// enable face culling feature
gl.glEnable(GL10.GL_CULL_FACE);
// specify which faces to not draw
gl.glCullFace(GL10.GL_BACK);

अगर आपको अपनी आकृतियों के बारे में पता नहीं है और आपको चेहरा पहचानने की सुविधा का इस्तेमाल करना है, तो आगे और पीछे, आपके OpenGL ग्राफ़िक्स थोड़े पतले दिखेंगे, या शायद बिलकुल भी दिखाई न दें. इसलिए, अपने OpenGL आकारों के निर्देशांकों को हमेशा घड़ी की विपरीत दिशा में आरेखण क्रम में परिभाषित करें.

ध्यान दें: OpenGL एनवायरमेंट सेट करके, हालांकि, ऐसा करने के लिए ज़्यादा कोड की ज़रूरत होती है और इससे भ्रम की स्थिति पैदा हो सकती है जब आपने उनसे सहायता मांगी, तो OpenGL डेवलपर का अनुभव रहा. इसलिए ऐसा न करें.

OpenGL वर्शन और डिवाइस पर काम करने की सुविधा

OpenGL ES 1.0 और 1.1 API की खास बातें, Android 1.0 और उसके बाद से काम करती हैं. OpenGL ES 1.0/1.1 API वाले ग्राफ़िक प्रोग्रामिंग, 2.0 वर्शन के मुकाबले काफ़ी अलग है और अपग्रेड किए गए वर्शन हैं. OpenGL ES 2.0, Android 2.2 (एपीआई लेवल 8) से शुरू होने वाले सभी Android डिवाइसों पर काम करता है. OpenGL ES के साथ डेवलप किए जा रहे नए ऐप्लिकेशन के लिए, सुझाया गया सबसे पुराना वर्शन. OpenGL ES 3.0, Android 4.3 (एपीआई लेवल 18) और इसके बाद के वर्शन के साथ काम करता है. यह सुविधा उन डिवाइसों पर काम करती है जो OpenGL ES 3.0 API को लागू करने की सुविधा जोड़ी गई. Android द्वारा चलने वाले डिवाइस की सापेक्ष संख्या के बारे में जानकारी के लिए जो OpenGL ES के दिए गए वर्शन का समर्थन करते हैं, तो OpenGL ES वर्शन का डैशबोर्ड.

आपको ग्राफ़िक से जुड़ी ज़रूरी शर्तों को ध्यान से देखना चाहिए और एपीआई चुनना चाहिए जो आपके ऐप्लिकेशन के लिए सबसे अच्छा काम करता है. ज़्यादा जानकारी के लिए, यह देखें OpenGL API का वर्शन चुनना.

OpenGL ES 3.0 API, 2.0 API के मुकाबले ज़्यादा सुविधाएं और बेहतर परफ़ॉर्मेंस देता है. पुराने सिस्टम के साथ भी काम करता है. इसका मतलब यह है कि आप संभावित रूप से अपना ऐप्लिकेशन लक्ष्यीकरण लिख सकते हैं OpenGL ES 2.0 और OpenGL ES 3.0 ग्राफ़िक की सुविधाओं के उपलब्ध होने पर, उन्हें शर्तों के साथ शामिल किया जाता है. इसके लिए 3.0 API की उपलब्धता के बारे में ज़्यादा जानने के लिए, यहां देखें OpenGL ES वर्शन की जाँच की जा रही है

टेक्सचर कंप्रेस करने की सुविधा

टेक्सचर कंप्रेस करने से, आपके OpenGL ऐप्लिकेशन की परफ़ॉर्मेंस काफ़ी बेहतर हो सकती है मेमोरी की ज़रूरतों को कम करती है और मेमोरी बैंडविड्थ के बेहतर इस्तेमाल को आसान बनाती है. Android फ़्रेमवर्क, ETC1 कंप्रेशन फ़ॉर्मैट को स्टैंडर्ड सुविधा के तौर पर सपोर्ट करता है. इसमें, ETC1Util यूटिलिटी क्लास और etc1tool कंप्रेशन टूल (यह Android SDK टूल, <sdk>/tools/ में उपलब्ध है). ऐसे Android ऐप्लिकेशन के उदाहरण के लिए जो टेक्सचर कंप्रेस करने के लिए, Android SDK टूल में CompressedTextureActivity कोड सैंपल देखें (<sdk>/samples/<version>/ApiDemos/src/com/example/android/apis/graphics/).

ETC1 फ़ॉर्मैट, OpenGL ES 2.0 या इसके बाद के वर्शन के साथ काम करने वाले सभी Android डिवाइसों पर काम करता है.

ध्यान दें: ETC1 टेक्सचर कंप्रेस करने का फ़ॉर्मैट, ऐसे टेक्सचर के साथ काम नहीं करता जिनमें पारदर्शिता (ऐल्फ़ा चैनल). अगर आपके ऐप्लिकशन को पारदर्शिता वाली बनावट की ज़रूरत है, तो आपको अपने लक्षित डिवाइस पर उपलब्ध अन्य टेक्सचर कंप्रेशन फ़ॉर्मैट की जांच करें. ऐप्लिकेशन ETC1 का इस्तेमाल करके ऐल्फ़ा चैनल टेक्सचर को रेंडर करने का तरीका, दो ETC1 टेक्सचर ऑब्जेक्ट बाइंड करना है: पहले कलर डेटा से और दूसरा ऐल्फ़ा चैनल डेटा से जोड़ा जाता है. इसके बाद, दोनों की वैल्यू को जोड़ा जाता है फ़्रैगमेंट शेडर में टेक्सचर तय करें.

OpenGL ES का इस्तेमाल करने पर, ETC2/EAC टेक्सचर कंप्रेशन फ़ॉर्मैट उपलब्ध होने की गारंटी देते हैं 3.0 एपीआई. यह टेक्सचर फ़ॉर्मैट, हाई विज़ुअल क्वालिटी के साथ बेहतरीन कंप्रेशन रेशियो की सुविधा देता है. साथ ही, प्रारूप पारदर्शिता (ऐल्फ़ा चैनल) का भी समर्थन करता है.

Android डिवाइसों पर, ETC फ़ॉर्मैट के अलावा, टेक्सचर कंप्रेस करने की सुविधा अलग-अलग तरह से काम करती है. यह अपने जीपीयू चिपसेट और OpenGL को लागू करना. आपको इस पर टेक्सचर कंप्रेशन सपोर्ट की जांच करनी चाहिए जिन डिवाइसों को आप टारगेट कर रहे हैं, ताकि यह तय किया जा सके कि आपके ऐप्लिकेशन को किस कंप्रेशन टाइप को चुनना चाहिए सहायता. यह तय करने के लिए कि किसी डिवाइस पर कौनसे टेक्सचर फ़ॉर्मैट काम करते हैं, आपको: डिवाइस के बारे में क्वेरी करें और OpenGL एक्सटेंशन के नाम देखें, जो यह पहचान करते हैं कि कौन से टेक्सचर कंप्रेशन फ़ॉर्मैट (और अन्य OpenGL सुविधाएं) डिवाइस. आम तौर पर इस्तेमाल किए जाने वाले टेक्सचर कंप्रेस करने के फ़ॉर्मैट यहां दिए गए हैं:

ज़रूरत के हिसाब से बड़े किए जा सकने वाले टेक्सचर कंप्रेशन (एएसटीसी) - टेक्सचर कंप्रेस करने का फ़ॉर्मैट जो पिछले फ़ॉर्मैट की जगह लागू होंगे. ये पिछले फ़ॉर्मैट के मुकाबले ज़्यादा सुविधाजनक होते हैं, क्योंकि ये अलग-अलग फ़ॉर्मैट के साथ काम करते हैं ब्लॉक साइज़.
- GL_KHR_texture_compression_astc_ldr
- GL_KHR_texture_compression_astc_hdr(ज़्यादा डाइनैमिक रेंज)
S3TC (DXTn/DXTC) - S3 टेक्सचर कंप्रेशन (S3TC) में कई फ़ॉर्मैट वैरिएशन (DXT1 से DXT5) तक. साथ ही, यह ज़्यादा बड़े पैमाने पर उपलब्ध नहीं है. यह फ़ॉर्मैट, आरजीबी टेक्सचर के साथ काम करता है 4-बिट ऐल्फ़ा या 8-बिट ऐल्फ़ा चैनल. ये फ़ॉर्मैट, OpenGL एक्सटेंशन के ज़रिए दिखाए जाते हैं नाम:
- GL_EXT_texture_compression_s3tc
कुछ डिवाइस केवल DXT1 प्रारूप विविधता का समर्थन करते हैं; इस सीमित सहायता का प्रतिनिधित्व निम्न OpenGL एक्सटेंशन नाम:
- GL_EXT_texture_compression_dxt1

नीचे दिए गए टेक्सचर कंप्रेशन फ़ॉर्मैट को लेगसी फ़ॉर्मैट माना जाता है. इनका सुझाव नहीं दिया जाता नए ऐप्लिकेशन में इस्तेमाल करने के लिए:

एटीआईटीसी (एटीसी) - एटीआई टेक्सचर कंप्रेस करने की सुविधा (एटीआईटीसी या एटीसी), दोनों डिवाइस कई तरह के होते हैं और आरजीबी टेक्सचर के लिए, तय दर को कंप्रेस करने की सुविधा मिलती है. ऐल्फ़ा चैनल. इस फ़ॉर्मैट को OpenGL एक्सटेंशन के कई नामों से दिखाया जा सकता है, उदाहरण के लिए:
- GL_AMD_compressed_ATC_texture
- GL_ATI_texture_compression_atitc
PVVRC - PowerVR टेक्सचर कंप्रेशन (PVRC) उपलब्ध है और अल्फ़ा चैनल के साथ या उसके बिना 2-बिट और 4-बिट प्रति पिक्सेल बनावट का समर्थन करता है. इस फ़ॉर्मैट को OpenGL एक्सटेंशन के इस नाम से दिखाया जाता है:
- GL_IMG_texture_compression_pvrtc
3DC - 3DC टेक्सचर कंप्रेशन (3DC) ऐसा फ़ॉर्मैट है जो आम तौर पर कम इस्तेमाल होता है अल्फ़ा चैनल के साथ RGB बनावट का समर्थन करता है. यह फ़ॉर्मैट, इस OpenGL से दिखाया जाता है एक्सटेंशन का नाम:
- GL_AMD_compressed_3DC_texture

चेतावनी: ये टेक्सचर कंप्रेशन फ़ॉर्मैट नहीं हैं सभी डिवाइसों पर उपलब्ध है. इन फ़ॉर्मैट के इस्तेमाल की सुविधा, मैन्युफ़ैक्चरर और डिवाइस के हिसाब से अलग-अलग हो सकती है. इसके लिए किसी विशिष्ट डिवाइस पर कौन से टेक्सचर कंप्रेशन फ़ॉर्मैट हैं, यह पता लगाने के बारे में जानकारी, देखें अगला सेक्शन देखें.

ध्यान दें: एक बार यह तय करने के बाद कि आपके किस टेक्सचर कंप्रेशन को फ़ॉर्मैट किया जाए ऐप्लिकेशन का समर्थन करेगा, तो सुनिश्चित करें कि आप इसका उपयोग कर अपने मेनिफ़ेस्ट में <supports-gl-texture> पर टैप करें. इस एलान का इस्तेमाल करने पर, Google Play जैसी बाहरी सेवाओं के हिसाब से फ़िल्टर करने की सुविधा चालू होती है. इससे, आपका ऐप्लिकेशन सिर्फ़ उन डिवाइसों पर इंस्टॉल किया जाता है जो आपके ऐप्लिकेशन के ज़रूरी फ़ॉर्मैट के साथ काम करते हैं. जानकारी के लिए, यह देखें OpenGL मेनिफ़ेस्ट का एलान.

OpenGL एक्सटेंशन तय करना

OpenGL ES API के एक्सटेंशन के हिसाब से, Android डिवाइस के हिसाब से OpenGL को लागू करने के तरीके अलग-अलग हो सकते हैं जो सहायता करते हैं. इन एक्सटेंशन में, टेक्सचर कंप्रेस करना शामिल है. हालांकि, आम तौर पर अन्य एक्सटेंशन एक्सटेंशन को OpenGL सुविधा सेट के लिए बनाया गया है.

यह निर्धारित करने के लिए कि कौन से टेक्सचर कंप्रेशन फ़ॉर्मैट और अन्य OpenGL एक्सटेंशन ख़ास डिवाइस:

किस टेक्सचर कंप्रेशन का पता लगाने के लिए, अपने टारगेट डिवाइसों पर यहां दिया गया कोड चलाएं ये फ़ॉर्मैट इस्तेमाल किए जा सकते हैं:
Kotlin
```
var extensions = gl.glGetString(GL10.GL_EXTENSIONS)
```
Java
```
String extensions = gl.glGetString(GL10.GL_EXTENSIONS);
```
चेतावनी: इस कॉल के नतीजे डिवाइस के मॉडल के हिसाब से अलग-अलग होते हैं! आपने लोगों तक पहुंचाया मुफ़्त में कई लक्ष्य डिवाइस पर इस कॉल को चलाना ज़रूरी है, ताकि यह पता लगाया जा सके कि कंप्रेशन के किस तरह के डिवाइस आम तौर पर इस्तेमाल किए जाते हैं समर्थित हैं.
इस तरीके के आउटपुट की समीक्षा करके यह पता करें कि OpenGL एक्सटेंशन पर कौन-कौनसे एक्सटेंशन काम करते हैं डिवाइस.

Android एक्सटेंशन पैक (AEP)

AEP यह पक्का करता है कि आपका ऐप्लिकेशन ऊपर दिए गए OpenGL एक्सटेंशन के मानक सेट के साथ काम करता हो और आगे OpenGL 3.1 स्पेसिफ़िकेशन में बताया गया कोर सेट है. इन एक्सटेंशन को एक साथ पैकेजिंग करना इससे सभी डिवाइसों पर एक जैसी सुविधाओं का इस्तेमाल किया जा सकता है. साथ ही, डेवलपर को मोबाइल जीपीयू डिवाइस के सबसे नए क्रॉप का फ़ायदा मिलता है.

एईपी इमेज, शेडर स्टोरेज बफ़र, और ऐटॉमिक काउंटर के लिए काम करता है. फ़्रैगमेंट शेडर.

आपके ऐप्लिकेशन को एईपी का इस्तेमाल करने के लिए, ऐप्लिकेशन के मेनिफ़ेस्ट में यह बताना ज़रूरी है कि एईपी ज़रूरी है. इसके अलावा, प्लैटफ़ॉर्म वर्शन पर यह सुविधा काम करनी चाहिए.

एईपी में बताई गई सभी अतिरिक्त सुविधाएं, OpenGL ES 3.2 के बेस में शामिल हैं स्पेसिफ़िकेशन. अगर आपके ऐप्लिकेशन को OpenGL ES 3.2 की ज़रूरत नहीं है, तो आपको AEP की ज़रूरत नहीं होगी.

मेनिफ़ेस्ट में एईपी की ज़रूरी शर्तों का एलान इस तरह करें:

<uses-feature android:name="android.hardware.opengles.aep"
              android:required="true" />

प्लैटफ़ॉर्म वर्शन, AEP के साथ काम करता है या नहीं, इसकी पुष्टि करने के लिए hasSystemFeature(String) तरीका इस्तेमाल किया जा रहा है तर्क के तौर पर FEATURE_OPENGLES_EXTENSION_PACK. यह कोड स्निपेट उदाहरण के तौर पर, यह तरीका बताया गया है:

Kotlin

var deviceSupportsAEP: Boolean =
        packageManager.hasSystemFeature(PackageManager.FEATURE_OPENGLES_EXTENSION_PACK)

Java

boolean deviceSupportsAEP = getPackageManager().hasSystemFeature
     (PackageManager.FEATURE_OPENGLES_EXTENSION_PACK);

अगर यह तरीका सही है, तो AEP का इस्तेमाल किया जा सकता है.

एईपी के बारे में ज़्यादा जानकारी के लिए, Kranos OpenGL ES Registry पर जाएं.

OpenGL ES वर्शन की जांच करना

Android डिवाइसों पर, OpenGL ES के कई वर्शन उपलब्ध हैं. आप आपके ऐप्लिकेशन के लिए ज़रूरी एपीआई का कम से कम वर्शन आपके मेनिफ़ेस्ट में हो, लेकिन साथ ही, हो सकता है कि आप नए एपीआई की सुविधाओं का भी फ़ायदा लेना चाहें. उदाहरण के लिए, OpenGL ES 3.0 API, API के 2.0 वर्शन के साथ पुराने सिस्टम के साथ काम करता है. इसलिए, आपको अपने ऐप्लिकेशन को इस तरह लिखें कि वह OpenGL ES 3.0 सुविधाओं का इस्तेमाल करे, लेकिन वापस 2.0 API पर चला जाए, अगर 3.0 एपीआई उपलब्ध नहीं है.

OpenGL ES की सुविधाओं का इस्तेमाल करने से पहले, ऐप्लिकेशन मेनिफ़ेस्ट फ़ाइल अपलोड करते हैं, तो आपके ऐप्लिकेशन को डिवाइस पर उपलब्ध API के वर्शन की जाँच करनी चाहिए. ऐसा करने के लिए, इन दो में से किसी एक तरीके का इस्तेमाल किया जा सकता है:

उच्च-स्तरीय OpenGL ES संदर्भ (EGLContext) बनाने की कोशिश करें और नतीजा देखें.
कम से कम काम करने वाला OpenGL ES संदर्भ बनाएं और वर्शन की वैल्यू की जांच करें.

नीचे दिए गए उदाहरण कोड में, OpenGL ES के उपलब्ध वर्शन की जांच करने का तरीका बताया गया है EGLContext और नतीजा देखा जा रहा है. इस उदाहरण में, यूआरएल की जांच करने का तरीका बताया गया है OpenGL ES 3.0 वर्शन:

Kotlin

private const val EGL_CONTEXT_CLIENT_VERSION = 0x3098
private const val glVersion = 3.0
private class ContextFactory : GLSurfaceView.EGLContextFactory {

    override fun createContext(egl: EGL10, display: EGLDisplay, eglConfig: EGLConfig): EGLContext {

        Log.w(TAG, "creating OpenGL ES $glVersion context")
        return egl.eglCreateContext(
                display,
                eglConfig,
                EGL10.EGL_NO_CONTEXT,
                intArrayOf(EGL_CONTEXT_CLIENT_VERSION, glVersion.toInt(), EGL10.EGL_NONE)
        ) // returns null if 3.0 is not supported
    }
}

Java

private static double glVersion = 3.0;

private static class ContextFactory implements GLSurfaceView.EGLContextFactory {

  private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;

  public EGLContext createContext(
          EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {

      Log.w(TAG, "creating OpenGL ES " + glVersion + " context");
      int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, (int) glVersion,
              EGL10.EGL_NONE };
      // attempt to create a OpenGL ES 3.0 context
      EGLContext context = egl.eglCreateContext(
              display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
      return context; // returns null if 3.0 is not supported;
  }
}

अगर ऊपर दिखाया गया createContext() तरीका शून्य दिखाता है, तो आपके कोड को OpenGL बनाना चाहिए उसके बजाय, ES 2.0 कॉन्टेक्स्ट का इस्तेमाल करें. इसके बाद, सिर्फ़ उसी एपीआई का इस्तेमाल किया जाएगा.

नीचे दिए गए कोड उदाहरण में, OpenGL ES वर्शन की जांच करने का तरीका बताया गया है. इसके लिए, पहले समर्थित संदर्भ चुनें और फिर वर्शन स्ट्रिंग की जाँच करें:

Kotlin

// Create a minimum supported OpenGL ES context, then check:
gl.glGetString(GL10.GL_VERSION).also {
    Log.w(TAG, "Version: $it")
}
 // The version format is displayed as: "OpenGL ES <major>.<minor>"
 // followed by optional content provided by the implementation.

Java

// Create a minimum supported OpenGL ES context, then check:
String version = gl.glGetString(GL10.GL_VERSION);
Log.w(TAG, "Version: " + version );
// The version format is displayed as: "OpenGL ES <major>.<minor>"
// followed by optional content provided by the implementation.

इस तरीके से, अगर आपको लगता है कि डिवाइस, एपीआई के बाद वाले वर्शन के साथ काम करता है, तो आपको को कम से कम OpenGL ES संदर्भ को मिटाना होगा और बेहतर संदर्भ के साथ नया संदर्भ बनाना होगा उपलब्ध एपीआई वर्शन.

OpenGL API वर्शन चुनना

OpenGL ES वर्शन 2.0 और वर्शन 3.0, दोनों ही बेहतर सुविधाएं देते हैं 3D गेम, विज़ुअलाइज़ेशन और यूज़र इंटरफ़ेस बनाने के लिए परफ़ॉर्मेंस ग्राफ़िक इंटरफ़ेस. ग्राफ़िक OpenGL ES 2.0 और 3.0 के लिए प्रोगेमिंग काफ़ी हद तक एक जैसी है. इसमें वर्शन 3.0, सुपरसेट को दिखाता है 2.0 एपीआई का इस्तेमाल किया जा सकता है. OpenGL ES 1.0/1.1 API बनाम OpenGL ES के लिए प्रोग्रामिंग 2.0 और 3.0 में बहुत ज़्यादा अंतर है और नए ऐप्लिकेशन के लिए इसका सुझाव नहीं दिया जाता है. डेवलपर को Family Link की मदद से अपना डेवलपमेंट शुरू करने से पहले, इन बातों पर ध्यान देना चाहिए ये एपीआई:

डिवाइस के साथ काम करता है या नहीं - डेवलपर को डिवाइस के टाइप पर ध्यान देना चाहिए, ग्राहकों के लिए उपलब्ध Android वर्शन और OpenGL ES वर्शन. Reader Revenue Manager को सेट अप करने के बारे में सभी डिवाइसों पर OpenGL की सुविधा के बारे में जानने के लिए, OpenGL वर्शन और डिवाइस के साथ काम करने की सुविधा सेक्शन में देखें.
टेक्सचर से जुड़ी सहायता - OpenGL ES 3.0 API, टेक्सचर के लिए सबसे अच्छी तरह काम करता है कंप्रेशन क्योंकि यह ETC2 कंप्रेशन फ़ॉर्मैट की उपलब्धता की गारंटी देता है, जो पारदर्शिता. हालांकि, 2.0 एपीआई लागू करने की वजह से, ETC1 के साथ काम करने की सुविधा मिलती है. यह बनावट प्रारूप पारदर्शिता का समर्थन नहीं करता है. कंप्रेस की गई रिपोर्ट के साथ पारदर्शिता लागू करने के लिए टेक्सचर के लिए, आपको दो ETC1 टेक्सचर (रंग और ऐल्फ़ा के बीच अलग) का इस्तेमाल करना होगा या संसाधन उपलब्ध कराने होंगे आपके टारगेट किए जा रहे डिवाइसों पर चलने वाले दूसरे कंप्रेशन फ़ॉर्मैट में. ज़्यादा जानकारी के लिए, टेक्सचर कंप्रेस करने से जुड़ी सहायता देखें.

साथ काम करने की सुविधा और टेक्सचर सपोर्ट से, आपके कॉन्टेंट पर असर पड़ सकता है लेने का विकल्प चुनते हैं, तो आपको उस आधार पर OpenGL API वर्शन चुनना चाहिए कि आपको सबसे अच्छा अनुभव मिलता है को भी बनाए रखता है.