OpenGL ES: nima, arxitekturasi va qo'llanilishi

OpenGL ES nima?

OpenGL ES (Open Graphics Library for Embedded Systems) — mobil qurilmalar, o'yin konsollari va o'rnatilgan tizimlar uchun moslashtirilgan desktop OpenGL API ning kichik to'plamidir. Spetsifikatsiya Khronos Group konsorsiumi tomonidan ishlab chiqiladi va barcha ishlab chiqaruvchilar uchun bepul. Desktop OpenGL dan farqli o'laroq, OpenGL ES sobit konveyerning eskirgan funksiyalarini olib tashlaydi, faqat dasturlashtiriladigan shader konveyerini qoldiradi — bu energiya sarfini kamaytiradi va drayverlarni soddalashtiradi.

OpenGL ES ning asosiy qo'llanish sohasi — real vaqt rejimida grafika renderlash. API mobil o'yinlarda (Unity, Unreal Engine), navigatsiya ilovalarida, ARCore va ARKit asosidagi AR yechimlarida, shuningdek Android va iOS tizim interfeyslarida ishlatiladi. StatCounter, 2026 ma'lumotlariga ko'ra, faol smartfonlar orasida OpenGL ES 3.0+ qo'llab-quvvatlovchi qurilmalarning ulushi 92% dan oshadi.

OpenGL ES ning asosiy afzalligi — ko'p platformalilik. OpenGL ES da yozilgan bir xil ilova minimal o'zgarishlar bilan Android, iOS, Linux va Windows da ishlashi mumkin. Bu API ni grafik dvigatelni qayta yozmasdan ko'plab platformalarga mo'ljallangan loyihalar uchun optimal tanlov qiladi.

Sobit vs dasturlashtiriladigan konveyer

OpenGL ning dastlabki versiyalari (2.0 dan oldin) sobit konveyerdan — cho'qqi va pikselni qayta ishlashning oldindan belgilangan bosqichlari to'plamidan foydalangan. Dasturchi faqat parametrlarni sozlashi mumkin edi: yorug'lik manbalarining joylashuvi, materiallarning xususiyatlari, transformatsiya matritsalari. OpenGL ES 2.0 da joriy qilingan dasturlashtiriladigan konveyer sobit bosqichlarni shaderlar bilan — GPU da bajariladigan kichik dasturlar bilan almashtirdi. Bu dasturchilarga geometriyani ko'rsatish ustidan to'liq nazorat berdi.

Dasturlashtiriladigan konveyerga o'tish mobil grafikada inqilob bo'ldi. Dasturchilar murakkab effektlarni amalga oshirish imkoniyatiga ega bo'ldilar: PBR (Physically Based Rendering), dinamik soyalar, post-ishlov va HDR. Sobit konveyer kamroq kod talab qilgan, lekin noyob vizual uslublarni yaratishga imkon bermagan. Zamonaviy mobil o'yinlar to'liq dasturlashtiriladigan konveyerda ishlaydi.

OpenGL ES arxitekturasi: renderlash konveyeri

Grafik konveyer OpenGL ES bir necha ketma-ket bosqichlardan iborat, har biri kirish ma'lumotlarini cho'qqilardan ekrandagi piksellargacha o'zgartiradi. Konveyer arxitekturasini tushunish, cheklangan energiya va issiqlik byudjetiga ega mobil qurilmalarda renderlash samaradorligini optimallashtirish uchun juda muhimdir.

Birinchi bosqich — cho'qqi shaderi — har bir cho'qqini mustaqil qayta ishlaydi. Bu bosqichda transformatsiyalar qo'llaniladi: modelning lokal fazosidan dunyo fazosiga, keyin kamera fazosiga va nihoyat, kesish fazosiga (clip space) o'tish. Transformatsiyalar MVP (Model-View-Projection) uniform-matritsalari orqali beriladi, ular kamera yoki ob'ektlar harakati paytida har kadrda yangilanadi.

Primitivlar (nuqtalar, chiziqlar, uchburchaklar) yig'ilgandan so'ng rasterizatsiya amalga oshiriladi — har bir primitiv ekranning qaysi piksellarini qoplashini aniqlash jarayoni. Rasterizator interpolyatsiya qilingan atributlar (rang, normallar, UV koordinatalari) bilan fragmentlar — potentsial piksellarni yaratadi. Fragmentlar soni to'g'ridan-to'g'ri ekran o'lchamiga va primitiv proyeksiyasining maydoniga bog'liq.

Fragment shaderi yaratilgan har bir fragment uchun bajariladi. U teksturalar, yorug'lik manbalari va materiallarni hisobga olgan holda pikselning yakuniy rangini hisoblaydi. Fragment shaderining chiqishida bir qator per-fragment testlari o'tkaziladi: depth test fragmentning ko'rinadiganligini aniqlaydi; stencil test renderlashni niqob bo'yicha cheklaydi; blending fragment rangini kadr buferida allaqachon yozilgan rang bilan aralashtiradi.

OpenGL ES konteksti holatlari

OpenGL ES holat mashinasi (state machine) sifatida ishlaydi: barcha sozlamalar — joriy shader, bog'langan teksturalar, faol testlar — kontekstning global holatida saqlanadi. glEnable, glBindTexture yoki glUseProgram orqali holatni o'zgartirish barcha keyingi chizish buyruqlariga ta'sir qiladi. Har bir holat o'zgarishi drayverda qo'shimcha yuk keltirib chiqaradi, shuning uchun draw chaqiruvlarini holat bo'yicha guruhlash asosiy optimallashtirish usulidir.

OpenGL ES versiyalari va ularning imkoniyatlari

OpenGL ES 1.0 va 1.1 (2003–2004 yillarda chiqarilgan) sobit konveyerga asoslangan edi. Ular transformatsiya, teksturalash, yoritish va blending ni qo'llab-quvvatlagan, ammo shaderlarni dasturlashga ruxsat bermagan. API Symbian va Windows Mobile asosidagi dastlabki mobil telefonlar va qurilmalarda ishlatilgan. Bugungi kunda bu versiyalar eskirgan hisoblanadi — zamonaviy qurilmalar ularni qo'llab-quvvatlamaydi.

OpenGL ES 2.0 (2007) GLSL ES tilida cho'qqi va fragment shaderlari bilan dasturlashtiriladigan konveyerni joriy qildi. Bu versiya Android 2.2+ va iOS 5+ uchun standartga aylandi va bugungi kungacha qurilmalarning katta ko'pchiligi tomonidan qo'llab-quvvatlanadi. OpenGL ES 2.0 — Unity, Unreal Engine va Cocos2d-x ni mobil platformalarda ishlatish uchun zarur bo'lgan minimal versiya.

OpenGL ES 3.0 (2012) bir nechta muhim imkoniyatlarni qo'shdi: bir nechta render nishonlari (MRT), transform feedback, instancing, ETC2/EAC orqali ixtiyoriy formatdagi teksturalar. Renderlash samaradorligi draw chaqiruvlari sonining kamayishi hisobiga 2.0 versiyasiga nisbatan 30–50% ga oshdi. OpenGL ES 3.1 (2014) hisoblash shaderlari (compute shaders) va buferlar bilan atom operatsiyalarini joriy qildi — bu GPU da nafaqat grafik, balki hisoblash vazifalarini (post-ishlov, mato simulyatsiyasi, fizika hisoblari) bajarishga imkon berdi.

OpenGL ES 3.2 (2015) — spetsifikatsiyaning so'nggi versiyasi — tesselatsiya va geometriya shaderlari, shuningdek kengaytirilgan float-teksturalar to'plami va blend rejimlarini qo'shdi. 2016 yilda zamonaviyroq Vulkan ning chiqarilishiga qaramay, OpenGL ES 3.2 mavjud kodning ulkan bazasi va ilovalarni platformalar o'rtasida ko'chirishning soddaligi tufayli dolzarb API bo'lib qolmoqda.

OpenGL ES da shaderlar: GLSL va dasturlashtiriladigan konveyer

GLSL ES (OpenGL Shading Language for Embedded Systems) — vektorlar va matritsalar bilan ishlash uchun qo'shimcha turlarga ega C sintaksisiga asoslangan shader dasturlash tili. Har bir shader ilova ishga tushirish bosqichida GPU ning mashina kodiga kompilyatsiya qilinadigan dasturdir. CPU kodidan farqli o'laroq, shaderlar ommaviy-parallel bajariladi: minglab cho'qqi yoki fragment bir vaqtning o'zida qayta ishlanadi.

Cho'qqi shaderlari

Cho'qqi shaderi to'rning har bir cho'qqisini qayta ishlaydi. Uning asosiy vazifasi kirish pozitsiyasini MVP matritsasiga ko'paytirish orqali cho'qqining clip space dagi yakuniy pozitsiyasini hisoblashdir. Bundan tashqari, cho'qqi shaderi normallar, UV koordinatalari, ranglarni hisoblab, ularni varying o'zgaruvchilari orqali fragment shaderiga uzatishi mumkin. Cho'qqi shaderining har bir chaqiruvi mustaqil ishlaydi, bu GPU ga bir kadrda millionlab cho'qqilarni qayta ishlashga imkon beradi.

// OpenGL ES 3.0 uchun oddiy cho'qqi shaderi
#version 300 es
layout(location = 0) in vec4 a_position;
layout(location = 1) in vec3 a_normal;
layout(location = 2) in vec2 a_texCoord;

uniform mat4 u_mvpMatrix;

out vec3 v_normal;
out vec2 v_texCoord;

void main() {
    gl_Position = u_mvpMatrix * a_position;
    v_normal = mat3(u_mvpMatrix) * a_normal;
    v_texCoord = a_texCoord;
}

Fragment shaderlari

Fragment shaderi ekrandagi har bir pikselning rangini aniqlaydi. U cho'qqi shaderidan interpolyatsiya qilingan varying qiymatlarini qabul qiladi, bog'langan teksturalardan teksellarni tanlaydi va yoritishni qo'llaydi. To'g'ri yoritish uchun diffuse, specular va ambient komponentlarini hisoblash bilan Phong yoki Blinn-Phong modeli ishlatiladi. Fragment shaderining har bir chaqiruvi bitta pikselga to'g'ri keladi, shuning uchun umumiy chaqiruvlar soni ob'ektning ekrandagi proyeksiya maydoniga teng.

// OpenGL ES 3.0 uchun tekstura va yoritish bilan oddiy fragment shaderi
#version 300 es
precision mediump float;

in vec3 v_normal;
in vec2 v_texCoord;

uniform sampler2D u_texture;
uniform vec3 u_lightDir;

out vec4 fragColor;

void main() {
    vec4 texel = texture(u_texture, v_texCoord);
    vec3 normal = normalize(v_normal);
    float diffuse = max(dot(normal, u_lightDir), 0.0);
    fragColor = vec4(texel.rgb * diffuse, texel.a);
}

Yuqoridagi misolda fragment shaderi UV koordinatalari bo'yicha 2D teksturadan teksel tanlaydi, diffuse yoritishni normal va yorug'lik yo'nalishining skalyar ko'paytmasi sifatida hisoblaydi va teksel rangini yoritish intensivligiga ko'paytiradi. Mediump — mobil GPU larda fragment shaderlari uchun tavsiya etiladigan aniqlik: minimal energiya sarfi bilan yetarli sifatni ta'minlaydi.

Mobil loyihalarda OpenGL ES bilan ishlashni qanday boshlash mumkin

OpenGL ES bilan Android da ishlash uchun EGL kontekstini — grafik ko'rsatiladigan sirtni yaratish kerak. iOS da GLKit framework i tomonidan taqdim etiladigan EGL ga o'xshash EAGL qatlami ishlatiladi. Ikkala holatda ham ishga tushirish jarayoni oyna sirtini yaratish, kontekst atributlarini sozlash va joriy renderlash oqimiga bog'lashni o'z ichiga oladi.

// Android da OpenGL ES 3.0 ni ishga tushirish
class MyGLRenderer : GLSurfaceView.Renderer {

    private val vertexShaderCode = "#version 300 es\n..."
    private val fragmentShaderCode = "#version 300 es\n..."

    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
        GLES30.glClearColor(0.1f, 0.1f, 0.2f, 1.0f)
        GLES30.glEnable(GLES30.GL_DEPTH_TEST)
    }

    override fun onDrawFrame(gl: GL10?) {
        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT or GLES30.GL_DEPTH_BUFFER_BIT)
        // bind VBO, set uniforms, draw elements
    }

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

Kontekst yaratilgandan so'ng dasturchi buferlarni sozlashi kerak: cho'qqi buferi (VBO) cho'qqi koordinatalari, normallar va UV ni o'z ichiga oladi; indeks buferi (EBO) uchburchaklarni hosil qilish uchun cho'qqilarni aylanib o'tish tartibini belgilaydi. VAO (Vertex Array Object) barcha atributlarning sozlamalarini bitta ob'ektda birlashtiradi, mesh larni almashtirishda API chaqiruvlari sonini kamaytiradi.

EGL kontekstini sozlash

EGL (Native Platform Graphics Interface) — OpenGL ES va oyna tizimi o'rtasidagi oraliq qatlam. Android da EGL chizish sirtini yaratish, framebuffer konfiguratsiyasini (rang chuqurligi, stencil, MSAA) tanlash va vsync bilan sinxronlashni boshqaradi. Odatiy konfiguratsiya 24 bitli depth buferi va 8 bitli stencil buferi bilan RGBA8888 ni talab qiladi. iOS da EGL rolini EAGL CAEAGLLayer bilan birgalikda bajaradi.

Mobil qurilmalarda OpenGL ES samaradorligini optimallashtirish bir necha asosiy amaliyotlarni o'z ichiga oladi. Ko'plab bir xil ob'ektlarni renderlash uchun instancing dan (glDrawArraysInstanced) foydalaning — bu draw chaqiruvlari sonini kamaytiradi. Tekstura hovuzlarini qo'llang va draw chaqiruvlari o'rtasida tekstura almashtirishdan saqlaning. Ob'ektlarni shader bo'yicha, keyin tekstura bo'yicha, so'ngra mesh bo'yicha tartiblang — bu ketma-ketlik kontekst holatini almashtirishni minimallashtiradi.

OpenGL ES vs Metal vs Vulkan

Metal — Apple dan past darajali grafik API, A7 chipidan boshlab iOS va macOS da mavjud. Metal minimal drayver qo'shimcha yuki bilan GPU ga to'g'ridan-to'g'ri kirishni ta'minlaydi, lekin faqat Apple qurilmalarida ishlaydi. WWDC 2024 ma'lumotlariga ko'ra, Metal bir xil uskunada ish vaqtida holat tekshiruvlari sonini kamaytirish orqali OpenGL ES ga nisbatan 40% gacha yuqori samaradorlikni ta'minlaydi.

Vulkan — Khronos Group tomonidan ishlab chiqilgan OpenGL ES ning ko'p platformali vorisi. Vulkan resurslarni aniq boshqarishdan foydalanadi: dasturchi o'zi xotira hovuzlarini ajratadi, buyruq buferlarini yaratadi va GPU ga kirishni sinxronlaydi. Bu samaradorlik ustidan maksimal nazorat beradi, ammo Vulkan ishga tushirish kodi OpenGL ES dan 3–4 baravar katta. Vulkan Android 7+ da AAA o'yinlar va talabchan grafikaga ega ilovalar uchun tavsiya etiladi.

OpenGL ES, Metal va Vulkan o'rtasidagi tanlov maqsadli platformalar va samaradorlik talablariga bog'liq. OpenGL ES ishlab chiqish tezligi muhim bo'lgan ko'p platformali loyihalar uchun eng yaxshi tanlov bo'lib qolmoqda. Metal maksimal samaradorlik bilan iOS/macOS ekotizimi uchun afzal. Vulkan — har bir millisekundlik kadr muhim bo'lgan va ishlab chiqish byudjeti past darajali optimallashtirishga sarmoya kiritishga imkon beradigan loyihalar uchun tanlov.