OpenGL ES

Koleksiyonlar ile düzeninizi koruyun İçeriği tercihlerinize göre kaydedin ve kategorilere ayırın.

Android, Açık Grafik Kitaplığı ile yüksek performanslı 2D ve 3D grafik desteği sunar (OpenGL®), özellikle de OpenGL ES API. OpenGL, Google Haritalar API'larını kullanan belirtir 3D grafik işleme donanımı için standart yazılım arayüzü. OpenGL ES, OpenGL’nin bir çeşididir Gömülü cihazlar için tasarlanmış teknik özellikler. Android, OpenGL ES'nin çeşitli sürümlerini destekler API:

• OpenGL ES 2.0 - Bu API spesifikasyonu, Android 2.2 (API düzeyi 8) ve sonraki sürümler tarafından desteklenir.
• OpenGL ES 3.0 - Bu API spesifikasyonu, Android 4.3 (API düzeyi 18) ve sonraki sürümler tarafından desteklenir.
• OpenGL ES 3.1 - Bu API spesifikasyonu, Android 5.0 (API düzeyi 21) ve sonraki sürümler tarafından desteklenir.
• OpenGL ES 3.2 - Bu API spesifikasyonu, Android 7.0 (API düzeyi 24) ve sonraki sürümler tarafından desteklenir.

Dikkat: Android platform sürümü ne olursa olsun, bir cihaz cihaz üreticisi aşağıdaki koşullardan birini sağlamadığı sürece OpenGL ES 3.0 API’yi birkaç örnek verelim. Manifest dosyasında OpenGL ES 3.0 gereklidir, bu sürümün mevcut olduğundan emin olabilirsiniz cihaz üzerinde. Daha alt düzey bir sürümün gerekli olduğunu belirtirseniz ancak Varsa 3.0 özelliklerini kullanmak istiyorsanız çalışma zamanında kontrol etmeniz gerekir. cihazın hangi OpenGL sürümünü desteklediğini görebilirsiniz. Nasıl yapıldığını Bunun için Opening ES sürümünü kontrol etme konusuna bakın.

Not: Android, OpenGL ES 1.0 ve 1.1'i destekler, ancak API'nin bu sürümleri desteği sonlandırılmıştır ve modern uygulamalar tarafından kullanılmamalıdır.

Not: Android çerçevesi tarafından sağlanan özel API, J2ME JSR239 OpenGL ES API'sine benzer. ama aynı değil. J2ME JSR239 spesifikasyonu hakkında bilginiz varsa için de geçerlidir.

Ayrıca bakın:

• OpenGL ES ile grafikleri görüntüleme
• OpenGL ES
• OpenGL ES 2.x spesifikasyonu
• OpenGL ES 3.x spesifikasyonu

Temel bilgiler

Android, OpenGL'yi hem çerçeve API'si hem de Yerel Geliştirme aracılığıyla destekler Kit (NDK). Bu konu, Android çerçevesi arayüzlerine odaklanmaktadır. Daha fazla bilgi için NDK için Android NDK'ya bakın.

Android çerçevesinde tasarım ve değişiklik yapmanıza olanak tanıyan iki temel sınıf vardır. OpenGL ES API içeren grafik: GLSurfaceView ve GLSurfaceView.Renderer. Hedefiniz Android uygulamanızda OpenGL kullanmaksa Bu sınıfları bir etkinliğe nasıl uygulayacağınızı anlamak ilk hedefiniz olmalıdır.

GLSurfaceView

Bu sınıf, aşağıdakileri kullanarak nesneleri çizebileceğiniz ve değiştirebileceğiniz bir View sınıfıdır: OpenGL API çağrıları ve işlevi bir SurfaceView ile benzerdir. Tekliflerinizi otomatikleştirmek ve optimize etmek için bu sınıfı, GLSurfaceView örneğinin bir örneğini oluşturup Renderer. Ancak, resim çekmek isterseniz dokunmatik ekran etkinlikleri varsa GLSurfaceView sınıfını OpenGL eğitim dersinde gösterildiği gibi dokunma işleyicilerini uygulayın, Dokunma etkinliklerine yanıt verme.

GLSurfaceView.Renderer

Bu arayüz, GLSurfaceView aracında grafik çizmek için gerekli yöntemleri tanımlar. Bu arayüzün uygulanmasını, ayırın ve şunu kullanarak GLSurfaceView örneğinize ekleyin: GLSurfaceView.setRenderer().

GLSurfaceView.Renderer arayüzü, aşağıdaki yöntemleri kullanabilirsiniz:

• onSurfaceCreated(): Sistem bunu çağırır yöntemini bir kez kullanın, GLSurfaceView. Aşağıdaki yöntemi kullanarak yalnızca bir kez yapılması gereken işlemlerdir. Örneğin, OpenGL ortam parametrelerini ayarlamak veya OpenGL grafik nesnelerini başlatma.
• onDrawFrame(): Sistem, GLSurfaceView dosyasının her yeniden çekilmesinde bu yöntemi çağırır. Bu yöntemi (ve yeniden çizmeyi) deneyin.
• onSurfaceChanged(): GLSurfaceView boyutunun veya cihaz ekranının yönündeki değişiklikler de dahil olmak üzere, GLSurfaceView geometrisi değiştiğinde sistem bu yöntemi çağırır. Örneğin, sistem bu yöntemi kullanabilirsiniz. Bu yöntemi şu amaçlarla kullanabilirsiniz: GLSurfaceView kapsayıcısındaki değişikliklere uyum sağlayın.

OpenGL ES paketleri

GLSurfaceView ve GLSurfaceView.Renderer kullanarak OpenGL ES için bir kapsayıcı görünümü oluşturduktan sonra, aşağıdaki sınıfları kullanarak OpenGL API'lerini çağırın:

• OpenGL ES 2.0 API Sınıfı
  • android.opengl.GLES20 - Bu paket şunları sağlar: arayüzünü OpenGL ES 2.0'a entegre eder ve Android 2.2 (API düzeyi 8) sürümünden itibaren kullanılabilir.
• OpenGL ES 3.0/3.1/3.2 API Paketleri
  • android.opengl - Bu paket, OpenGL ES 3.0/3.1 arayüzünü sağlar sınıflar. Sürüm 3.0, Android 4.3 (API düzeyi 18) sürümünden itibaren kullanılabilir. Sürüm 3.1 mevcut . Sürüm 3.2, Android 7.0 (API) sürümünden itibaren kullanıma sunulacaktır 24. düzey).
    • GLES30
    • GLES31
    • GLES31Ext (Android Uzantı Paketi)
    • GLES32

OpenGL ES ile hemen bir uygulama oluşturmaya başlamak istiyorsanız OpenGL ES ile grafikleri görüntüleme sınıfını kullanır.

OpenGL gereksinimlerini bildirme

Uygulamanız tüm cihazlarda bulunmayan OpenGL özelliklerini kullanıyorsa AndroidManifest.xml dosyanızda dosyası olarak kaydedebilirsiniz. En yaygın OpenGL manifestleri şunlardır:

• OpenGL ES sürüm gereksinimleri - Uygulamanız belirli bir sürümü aşağıdaki ayarları manifest dosyanıza aşağıda gösterilmiştir.

  OpenGL ES 2.0 için:

  <!-- Tell the system this app requires OpenGL ES 2.0. -->
  <uses-feature android:glEsVersion="0x00020000" android:required="true" />
  

  Bu beyanı eklediğinizde Google Play, uygulamanızın OpenGL ES 2.0'ı desteklemeyen cihazlarda yüklü olan uygulamalar. Uygulamanız yalnızca kullanıyorsanız, bunu manifest dosyanızda da belirtebilirsiniz:

  OpenGL ES 3.0 için:

  <!-- Tell the system this app requires OpenGL ES 3.0. -->
  <uses-feature android:glEsVersion="0x00030000" android:required="true" />
  

  OpenGL ES 3.1 için:

  <!-- Tell the system this app requires OpenGL ES 3.1. -->
  <uses-feature android:glEsVersion="0x00030001" android:required="true" />
  

  OpenGL ES 3.2 için:

  <!-- Tell the system this app requires OpenGL ES 3.2. -->
  <uses-feature android:glEsVersion="0x00030002" android:required="true" />
  

  Not: OpenGL ES 3.x API, 2.0 API ile geriye dönük uyumluluğa sahiptir, yani daha fazla uygulamanızda OpenGL ES ile esnek hale getirin. OpenGL’i bildirerek manifest dosyanıza bir gereklilik olarak ES 2.0 API'yi kullanıyorsanız bu API sürümünü varsayılan olarak kullanabilirsiniz. 3.x API'nin çalışma zamanında kullanılabilir olması için ve ardından desteklediğini de gösterir. tarafından desteklenen OpenGL ES sürümünü kontrol etme hakkında daha fazla bilgi için Opening ES sürümünü kontrol etme konusuna bakın.

• Doku sıkıştırma gereksinimleri - Uygulamanız doku kullanıyorsa uygulamanızın desteklediği biçimleri manifest dosyanızda belirtmeniz gerekir. <supports-gl-texture> kullanılıyor. Kullanılabilen doku sıkıştırma hakkında daha fazla bilgi için Doku sıkıştırma desteği bölümüne bakın.

  Manifest'inizde doku sıkıştırması gereksinimlerini belirtirseniz uygulamanızı kullanıcılardan gizlersiniz beyan ettiğiniz sıkıştırma türlerinden en az birini desteklemeyen cihazlarla çalışın. Daha fazla doku sıkıştırma için Google Play filtrelemesinin nasıl çalıştığına ilişkin bilgiler için <supports-gl-texture> dokümanlarının Google Play ve doku sıkıştırma filtrelemesi bölümüne bakın.

Çizilen nesneler için koordinatları eşleme

Android cihazlarda grafikleri görüntülemedeki temel sorunlardan biri, ekranlarının boyut ve şekilde değişiklik gösterir. OpenGL’de kare, tek tip bir koordinat sistemi varsayılır ve varsayılan olarak büyük bir bu koordinatları, tam bir kareymiş gibi normalde kare olmayan ekranınıza çizer.

Şekil 1. Varsayılan OpenGL koordinat sistemi (solda) tipik bir Android cihazıyla eşlendi cihaz ekranına (sağ) dokunun.

Yukarıdaki çizimde, sistemdeki bir OpenGL çerçevesi için varsayılan tek tip koordinat sistemi sol ve bu koordinatların yatay yönde tipik bir cihaz ekranıyla nasıl eşleştiği tıklayın. Bu sorunu çözmek için OpenGL projeksiyon modlarını ve kamera görünümlerini Koordinatları dönüştürerek grafik nesnelerinizin tüm ekranlarda doğru oranlara sahip olmasını sağlayabilirsiniz.

Projeksiyon ve kamera görünümleri uygulamak için bir projeksiyon matrisi ve kamera görünümü oluşturursunuz ve bunları OpenGL oluşturma ardışık düzenine uygulayın. Projeksiyon matrisi, projeksiyon grafiklerinizin koordinatlarının Android cihaz ekranlarıyla doğru şekilde eşleşmesini sağlayın. Kamera görünümü matris, belirli bir göz konumundan nesneleri oluşturan bir dönüşüm oluşturur.

OpenGL ES 2.0 ve sonraki sürümlerde projeksiyon ve kamera görünümü

ES 2.0 ve 3.0 API'lerinde önce bir matris üyesi ekleyerek projeksiyon ve kamera görünümü uygularsınız tepe gölgeleriyle birlikte kullanabilirsiniz. Matrise bu üyeyi eklediğinizde, daha sonra projeksiyon ve kamera görüntüleme matrisleri oluşturup bunları nesnelerinize uygulayabilirsiniz.

1. Köşe gölgelendiricilerine matris ekle - Projeksiyon matrisini görüntüle için bir değişken oluşturun ve gölgelendiricinin konumunun bir çarpanı olarak ekleyin. Aşağıdaki örnekte köşe gölgelendiricide Paketinize dahil olan uMVPMatrix üyesi, projeksiyon ve kamera ile görüntüleme uygulamanıza olanak tanır. bu gölgelendiriciyi kullanan nesnelerin koordinatlarına matrisler ekler.

   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";
   

   Not: Yukarıdaki örnekte tek bir dönüşüm matrisi tanımlanmaktadır birleşik bir projeksiyon matrisi ve kamera görünümü uyguladığınız köşe gölgelendiricinin üyesi matristir. Başvuru gereksinimlerinize bağlı olarak ayrı projeksiyonlar tanımlayabilirsiniz. köşe gölgelendiricilerinizde matris ve kamera görüntüleme matrisi üyelerini değiştirebilirsiniz. bağımsız olarak değiştirebilirsiniz.

2. Gölgelendirici matrisine erişme: Köşe gölgelendiricilerinizde bir kanca oluşturduktan sonra projeksiyon ve kamera görünümü uyguladığınızda, projeksiyonu uygulamak ve matrislerini kullanabilirsiniz. Aşağıdaki kod, matrise erişmek için GLSurfaceView.Renderer uygulamasının onSurfaceCreated() yönteminin nasıl değiştirileceğini gösterir değişkenine eklenmelidir.

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

3. Projeksiyon ve kamera görüntüleme matrisleri oluşturun - Projeksiyonu oluşturun ve grafik nesnelere uygulanacak matrisleri görüntülemek. Aşağıdaki örnek kodda, değişiklik yapma onSurfaceCreated() ve onSurfaceChanged() yöntemi kamera görünümü matrisi oluşturmak için GLSurfaceView.Renderer uygulaması ve cihazın ekran en boy oranına göre projeksiyon matrisi.

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

4. Projeksiyon ve kamera görüntüleme matrislerini uygulayın - Projeksiyonu uygulamak ve matrisleri çarpıp tepe noktasına yerleştirip tepe noktasına gölgelendir. Aşağıdaki örnek kod, GLSurfaceView.Renderer uygulamasının onDrawFrame() yöntemini, yukarıdaki kodda oluşturulan projeksiyon matrisini ve kamera görünümünü OpenGL tarafından oluşturulacak nesnelerdir.

   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 ile projeksiyon ve kamera görünümünün nasıl uygulanacağına ilişkin tam bir örnek için Opening ES ile grafikleri görüntüleme bölümüne bakın sınıfını kullanır.

Yüzleri şekillendirme ve kavisleri çekme

OpenGL'de bir şeklin yüzü, üç boyutlu görünümde üç veya daha fazla noktayla tanımlanan bir yüzeydir boşluk oluşturur. Üç veya daha fazla üç boyutlu nokta kümesinin (OpenGL'de köşelere denir) ön yüzü vardır ve bir arka yüz. Hangi yüzün ön, hangisinin arka olduğunu nereden biliyorsunuz? Güzel soru. İlgili içeriği oluşturmak için kullanılan kıvrımla, yani bir şeklin noktalarını tanımladığınız yönüyle ilgilidir.

Şekil 1. Bir koordinat listesi görseli saat yönünün tersine çizim sırası.

Bu örnekte, üçgenin noktaları bir saat yönünün tersine çevirmesini sağlar. Bu koordinatların çizilme sırası, sarmal kuvvetini tanımlar şeklin yönünü seçin. Varsayılan olarak, OpenGL'de saat yönünün tersine çizilen yüz ön yüzü. Şekil 1'de gösterilen üçgen, nesnenin ön yüzüne bakacağınız şekilde tanımlanmıştır şekil (OpenGL tarafından yorumlandığı şekliyle) ve diğer taraf da arka yüzdür.

Bir şeklin hangi yüzünün ön yüzü olduğunu bilmek neden önemlidir? Bu sorunun cevabı, OpenGL’nin yaygın olarak kullanılan ve yüz seçme adlı bir özelliğidir. Yüz silme, OpenGL için bir seçenektir Bu, oluşturma ardışık düzeninin bir arka yüzü yoksaymasını (hesaplamamasını veya çizim yapmamasını) sağlayan bellek ve işleme döngüleri hakkında bilgi edindiniz:

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

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

Şekillerinizin hangi taraflarının durduğunu bilmeden yüz seçme özelliğini kullanmaya çalışırsanız sonra, OpenGL grafikleriniz biraz ince görünür veya hiç görünmez. Bu nedenle, OpenGL şekillerinizin koordinatlarını her zaman saat yönünün tersine çizim düzeninde tanımlayın.

Not: Bir OpenGL ortamı, Search Ads 360'ta bulunan saat yönünün tersine çevirebilir, ancak bunu yapmak daha fazla kod gerektirir ve muhtemelen deneyimli OpenGL geliştiricileri ile çalışın. Yani öyle değil.

OpenGL sürümleri ve cihaz uyumluluğu

OpenGL ES 1.0 ve 1.1 API spesifikasyonları, Android 1.0'dan itibaren desteklenmektedir. OpenGL ES 1.0/1.1 API ile grafik programlama, 2.0 ve daha yüksek sürümler. OpenGL ES 2.0, Android 2.2 (API düzeyi 8) ile başlayan tüm Android cihazlarda desteklenir ve OpenGL ES ile geliştirilen yeni uygulamalar için önerilen en eski sürüm. OpenGL ES 3.0, şunu sağlayan cihazlarda Android 4.3 (API düzeyi 18) ve sonraki sürümlerle desteklenir: en iyi uygulamaları paylaşacağız. Android destekli cihazların göreli sayısı hakkında bilgi için sürümünü destekleyenler için aşağıdaki bkz. OpenGL ES sürüm kontrol paneli.

Grafik gereksinimlerini dikkatlice değerlendirmeli ve API'yi seçmelisiniz en uygun olanı seçin. Daha fazla bilgi için bkz. OpenGL API sürümü seçme.

OpenGL ES 3.0 API ek özellikler ve 2.0 API'den daha iyi bir performans sağlar ve geriye dönük uyumluluğa da sahip. Bu, uygulama hedeflemenizi yazabileceğiniz ve OpenGL ES 2.0 ve varsa koşullu olarak OpenGL ES 3.0 grafik özelliklerini içerir. Örneğin, 3.0 API kullanılabilirliğini denetleme hakkında daha fazla bilgi için bkz. OpenGL ES sürümünü kontrol etme

Doku sıkıştırma desteği

Doku sıkıştırma, OpenGL uygulamanızın performansını önemli ölçüde artırarak Bu da bellek gereksinimlerini azaltır ve bellek bant genişliğini daha verimli bir şekilde kullanır. Android çerçevesi, aşağıdakileri içeren standart bir özellik olarak ETC1 sıkıştırma biçimini destekler. ETC1Util yardımcı program sınıfı ve etc1tool sıkıştırma aracı ( Android SDK'sı <sdk>/tools/). Android uygulaması örneği için doku sıkıştırma için Android SDK'daki CompressedTextureActivity kod örneğine bakın (<sdk>/samples/<version>/ApiDemos/src/com/example/android/apis/graphics/).

ETC1 biçimi, OpenGL ES 2.0 veya sonraki sürümleri destekleyen tüm Android cihazlar tarafından desteklenir.

Not: ETC1 doku sıkıştırma biçimi, şeffaflık (alfa kanalı). Uygulamanız şeffaflıklı dokular gerektiriyorsa hedef cihazlarınızda kullanılabilen diğer doku sıkıştırma biçimlerini araştırın. CEVAP ETC1 kullanarak alfa kanal dokularını oluşturma yöntemi, iki ETC1 doku nesnesini bağlamaktır: önce renk verileriyle, ikincisi ise alfa kanalı verileriyle, ardından da bu iki kanaldan elde edilen dokulara sahip değildir.

OpenGL ES kullanılırken ETC2/EAC doku sıkıştırma biçimlerinin kullanılabileceği garanti edilir 3.0 API. Bu doku biçimi, yüksek görsel kalitede mükemmel sıkıştırma oranları ve biçimi şeffaflığı da destekler (alfa kanalı).

Android cihazlar, ETC biçimlerinin dışında, cihaza göre ve OpenGL uygulamalarını geliştiriyor. Şu cihazlarda doku sıkıştırma desteğini araştırmalısınız: uygulamanızın hangi sıkıştırma türlerini kullanması gerektiğini belirlemek için hedeflediğiniz cihazları destek. Belirli bir cihazda hangi doku biçimlerinin desteklendiğini belirlemek için cihazı sorgulayın ve OpenGL uzantı adlarını inceleyin, tarafından desteklenen doku sıkıştırma biçimlerini (ve diğer OpenGL özelliklerini) olanak tanır. Yaygın olarak desteklenen bazı doku sıkıştırma biçimleri şunlardır:

• Uyarlanabilir Ölçeklenebilir Doku Sıkıştırma (ASTC): Doku sıkıştırma biçimi biçimlerin yerini alacak şekilde tasarlanmış olmalıdır. Farklı reklam biçimlerine yönelik destek sayesinde önceki biçimlerden daha esnek engelleyebilirsiniz.
  • GL_KHR_texture_compression_astc_ldr
  • GL_KHR_texture_compression_astc_hdr(yüksek dinamik aralık)
• S3TC (DXTn/DXTC) - S3 doku sıkıştırması (S3TC) için daha az yaygın olarak kullanılır. Bu biçim, 4 bit alfa veya 8 bit alfa kanalları. Bu biçimler, aşağıdaki OpenGL uzantısı ile temsil edilir ad:
  • GL_EXT_texture_compression_s3tc
  ziyaret edin. Bazı cihazlar yalnızca DXT1 biçim varyasyonunu destekler; bu sınırlı desteği aşağıdaki OpenGL uzantısı adı:
  • GL_EXT_texture_compression_dxt1

Aşağıdaki doku sıkıştırma biçimleri eski biçimler olarak kabul edilir ve önerilmez yeni uygulamalarda kullanılmak üzere:

• ATITC (ATC): ATI doku sıkıştırması (ATITC veya ATC), cihaz çok çeşitlidir ve olan ya da olmayan RGB dokuları için sabit hızda sıkıştırmayı destekler bir alfa kanalı. Bu biçim, çeşitli OpenGL uzantı adlarıyla temsil edilebilir. Örneğin:
  • GL_AMD_compressed_ATC_texture
  • GL_ATI_texture_compression_atitc
• PVRTC - PowerVR doku sıkıştırması (PVRTC) geniş bir ve alfa kanalı olsun ya da olmasın, piksel başına 2 bit ve 4 bit dokularını destekler. Bu biçim, aşağıdaki OpenGL uzantısı adıyla temsil edilir:
  • GL_IMG_texture_compression_pvrtc
• 3DC: 3DC doku sıkıştırması, bir alfa kanalına sahip RGB dokularını destekler. Bu biçim, aşağıdaki OpenGL ile temsil edilir uzantı adı:
  • GL_AMD_compressed_3DC_texture

Uyarı: Bu doku sıkıştırma biçimleri desteklenir. Bu biçimler için destek, üreticiye ve cihaza göre değişiklik gösterebilir. Örneğin, belirli bir cihazda hangi doku sıkıştırma biçimlerinin bulunduğunu belirleme hakkında bilgi için ele alacağız.

Not: Hangi doku sıkıştırması biçimine karar verdiğinize destekleyeceğinden, bunları manifest dosyanızda belirttiğinizden emin olun: <supports-gl-texture> Bu beyanın kullanılması Google Play gibi harici hizmetlere göre filtreleme yapılmasını sağlar. Böylece, Uygulamanız yalnızca uygulamanızın gerektirdiği biçimleri destekleyen cihazlara yüklenir. Ayrıntılar için bkz. OpenGL manifest beyanları.

OpenGL uzantılarını belirleme

OpenGL'nin uygulamaları, OpenGL ES API'ye yönelik uzantılar açısından Android cihaza göre değişir desteklenir. Bu uzantılar doku sıkıştırmaları içerir, ancak uzantıları eklemek için kullanılır.

Bir tarayıcıda hangi doku sıkıştırma biçimlerinin ve diğer OpenGL uzantılarının desteklendiğini belirlemek için oluşturabilirsiniz:

1. Hangi doku sıkıştırmasının oluşturulacağını belirlemek için hedef cihazlarınızda aşağıdaki kodu çalıştırın şu biçimler desteklenir:

   Kotlin

   var extensions = gl.glGetString(GL10.GL_EXTENSIONS)
   

   Java

   String extensions = gl.glGetString(GL10.GL_EXTENSIONS);
   

   Uyarı: Bu aramanın sonuçları cihaz modeline göre değişiklik gösterir. Siz yaygın olarak kullanılan sıkıştırma türlerini belirlemek için bu çağrıyı birkaç hedef cihazda yürütmelidir desteklenir.

2. olanak tanır.

Android Uzantı Paketi (AEP)

AEP, uygulamanızın yukarıdaki standart bir OpenGL uzantıları grubunu desteklediğinden emin olmanızı sağlar ve sonrası OpenGL 3.1 spesifikasyonunda açıklanan çekirdek küme. Bu uzantıları bir arada sunma cihazlar arasında tutarlı bir işlevsellik grubunu teşvik ederken geliştiricilerin de en yeni mobil GPU avantajlarından yararlanıyor.

AEP ayrıca resim, gölgelendirici depolama arabellekleri ve atomik sayaçlar parça gölgelendiricileridir.

Uygulamanızın AEP'yi kullanabilmesi için uygulamanın manifest dosyasında AEP'nin gerekli olduğunu beyan etmesi gerekir. Ayrıca, platform sürümünün de bunu desteklemesi gerekir.

AEP'de belirtilen ek özelliklerin tümü temel OpenGL ES 3.2'ye dahildir bakın. Uygulamanız OpenGL ES 3.2 gerektiriyorsa AEP'yi zorunlu kılmanıza gerek yoktur.

AEP şartını manifest dosyasında aşağıdaki gibi beyan edin:

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

Platform sürümünün AEP'yi desteklediğini doğrulamak için şunu kullanın: hasSystemFeature(String) yöntemi, başarılı Bağımsız değişken olarak FEATURE_OPENGLES_EXTENSION_PACK. Aşağıdaki kod snippet'i Bunun nasıl yapılacağına dair bir örnek gösterilmektedir:

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

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

Yöntem true değerini döndürürse AEP desteklenir.

AEP hakkında daha fazla bilgi için Khronos OpenGL ES Kayıt Defteri.

OpenGL ES sürümünü kontrol etme

Android cihazlarda OpenGL ES'nin çeşitli sürümleri mevcuttur. Her bir URL'yi belirtmek için manifest'inizde uygulamanızın gerektirdiği minimum API sürümüne sahip olmalı, aynı anda daha yeni bir API'daki özelliklerden de yararlanmak isteyebilirsiniz. Örneğin, OpenGL ES 3.0 API, API'nın 2.0 sürümü ile geriye dönük uyumluluğa sahip olduğundan, uygulamanızı OpenGL ES 3.0 özelliklerini kullanacak ancak 3.0 API kullanılamıyor.

uygulamanız, cihazdaki API'nin sürümünü kontrol etmelidir. Bunu iki şekilde yapabilirsiniz:

1. Daha üst düzey OpenGL ES bağlamı oluşturmaya çalışın (EGLContext) ve sonucu kontrol edin.
2. Minimum desteklenen bir OpenGL ES bağlamı oluşturun ve sürüm değerini kontrol edin.

Aşağıdaki örnek kod, EGLContext oluşturup sonucu kontrol ediyorum. Bu örnekte, OpenGL ES 3.0 sürümü:

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

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

Yukarıdaki createContext() yöntemi null döndürürse kodunuz bir OpenGL oluşturmalıdır ES 2.0 bağlamını kullanır ve yalnızca bu API'yi kullanmaya devam edersiniz.

Aşağıdaki kod örneği, minimum değer oluşturarak OpenGL ES sürümünün nasıl kontrol edileceğini gösterir desteklenen bağlamı göz önünde bulundurun ve ardından sürüm dizesini kontrol edin:

// 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.

// 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.

Bu yaklaşımda, cihazın daha üst düzey bir API sürümünü desteklediğini fark ederseniz minimum OpenGL ES bağlamını yok etmeli ve daha yüksek kullanılabilir API sürümü.

OpenGL API sürümü seçme

OpenGL ES sürüm 2.0 ve 3.0 sürümü, 3D oyunlar, görselleştirmeler ve kullanıcı arayüzleri oluşturmak için performans grafik arayüzleri. Grafikler OpenGL ES 2.0 ve 3.0 için programlama büyük ölçüde benzerdir; sürüm 3.0 bir üst kümeyi temsil eder yeni çıkan 2.0 API'ye göz atın. OpenGL ES 1.0/1.1 API için programlama ve OpenGL ES 2.0 ve 3.0 önemli ölçüde farklılık gösterir ve yeni uygulamalar için önerilmez. Geliştiriciler, şu API'leri kullanın:

• Cihaz Uyumluluğu - Geliştiriciler cihaz türlerini, Müşterilere sunulan Android sürümleri ve OpenGL ES sürümleri. Okuyucu Gelirleri Yöneticisi'ni hakkında daha fazla bilgi için OpenGL sürümlerine ve cihaz uyumluluğu bölümünü inceleyin.
• Doku Desteği: OpenGL ES 3.0 API, en iyi doku desteğini sunar ETC2 sıkıştırma biçiminin kullanılmasını garanti ettiği için, şeffaflık. 2.0 API uygulamaları ETC1 için destek sunar ancak bu doku biçimi şeffaflığı desteklemiyor. Sıkıştırılmış haliyle şeffaflığı uygulamak için dokular için iki ETC1 dokusu kullanmanız (renk ve alfa arasında bölünmüş) veya kaynak sağlamanız gerekiyor ve hedeflediğiniz cihazlar tarafından desteklenen diğer sıkıştırma biçimlerinden biri olabilir. Daha fazla bilgi için Doku sıkıştırma desteği bölümünü inceleyin.

Uyumluluk ve doku desteği, kaliteyi Sizce en iyi deneyimi sağlayacağını düşündüğünüz bir OpenGL API sürümü seçmeniz değer teslim eder.