OpenGL ES: คืออะไร สถาปัตยกรรม และการประยุกต์ใช้

OpenGL ES คืออะไร?

OpenGL ES (Open Graphics Library for Embedded Systems) คือชุดย่อยของ API OpenGL บนเดสก์ท็อปที่ปรับให้เหมาะกับอุปกรณ์โมบายล์ คอนโซลเกม และระบบฝังตัว ข้อกำหนดนี้พัฒนาโดยกลุ่ม Khronos Group และมีให้ใช้ฟรีสำหรับผู้ผลิตทั้งหมด ต่างจาก OpenGL บนเดสก์ท็อป OpenGL ES จะลบคุณสมบัติเก่าของไปป์ไลน์แบบตายตัว เหลือไว้เพียงไปป์ไลน์เชเดอร์ที่ตั้งโปรแกรมได้ — ซึ่งช่วยลดการใช้พลังงานและทำให้ไดรเวอร์ง่ายขึ้น

พื้นที่การใช้งานหลักของ OpenGL ES คือการเรนเดอร์กราฟิกแบบเรียลไทม์ API นี้ใช้ในเกมโมบายล์ (Unity, Unreal Engine) แอปพลิเคชันนำทาง โซลูชัน AR ที่ใช้ ARCore และ ARKit รวมถึงอินเทอร์เฟสระบบ Android และ iOS ตามข้อมูลของ StatCounter, 2026 สัดส่วนของอุปกรณ์ที่รองรับ OpenGL ES 3.0+ เกิน 92% ในกลุ่มสมาร์ทโฟนที่ใช้งานอยู่

ข้อได้เปรียบหลักของ OpenGL ES คือความเข้ากันได้ข้ามแพลตฟอร์ม แอปพลิเคชันเดียวกันที่เขียนด้วย OpenGL ES สามารถทำงานบน Android, iOS, Linux และ Windows โดยมีการเปลี่ยนแปลงน้อยมาก ทำให้ API นี้เป็นตัวเลือกที่เหมาะสมที่สุดสำหรับโปรเจกต์ที่กำหนดเป้าหมายหลายแพลตฟอร์มโดยไม่ต้องเขียนเอ็นจินกราฟิกใหม่

ไปป์ไลน์แบบตายตัวเทียบกับที่ตั้งโปรแกรมได้

เวอร์ชันแรกๆ ของ OpenGL (ก่อน 2.0) ใช้ไปป์ไลน์แบบตายตัว — ชุดขั้นตอนการประมวลผลจุดยอดและพิกเซลที่กำหนดไว้ล่วงหน้า นักพัฒนาสามารถกำหนดค่าพารามิเตอร์ได้เท่านั้น: ตำแหน่งแหล่งกำเนิดแสง คุณสมบัติวัสดุ เมทริกซ์การแปลง ไปป์ไลน์ที่ตั้งโปรแกรมได้ ซึ่งเปิดตัวใน OpenGL ES 2.0 ได้แทนที่ขั้นตอนตายตัวด้วยเชเดอร์ — โปรแกรมขนาดเล็กที่ทำงานบน GPU ซึ่งทำให้นักพัฒนาควบคุมการเรนเดอร์เรขาคณิตได้อย่างสมบูรณ์

การเปลี่ยนไปใช้ไปป์ไลน์ที่ตั้งโปรแกรมได้เป็นการปฏิวัติวงการกราฟิกโมบายล์ นักพัฒนาสามารถสร้างเอฟเฟกต์ซับซ้อนได้: PBR (การเรนเดอร์ตามหลักฟิสิกส์), เงาไดนามิก, การประมวลผลภายหลัง และ HDR ไปป์ไลน์แบบตายตัวต้องการโค้ดน้อยกว่า แต่ไม่อนุญาตให้สร้างสไตล์ภาพที่เป็นเอกลักษณ์ เกมโมบายล์สมัยใหม่ทำงานบนไปป์ไลน์ที่ตั้งโปรแกรมได้อย่างสมบูรณ์

สถาปัตยกรรม OpenGL ES: ไปป์ไลน์การเรนเดอร์

ไปป์ไลน์กราฟิก ของ OpenGL ES ประกอบด้วยหลายขั้นตอนต่อเนื่องกัน แต่ละขั้นตอนแปลงข้อมูลนำเข้าตามเส้นทางจากจุดยอดไปยังพิกเซลบนหน้าจอ การทำความเข้าใจสถาปัตยกรรมไปป์ไลน์มีความสำคัญอย่างยิ่งต่อการเพิ่มประสิทธิภาพการเรนเดอร์บนอุปกรณ์โมบายล์ที่มีงบประมาณด้านพลังงานและความร้อนจำกัด

ขั้นตอนแรก — เชเดอร์จุดยอด — ประมวลผลแต่ละจุดยอดอย่างอิสระ ในขั้นตอนนี้จะใช้การแปลง: การเปลี่ยนจากสเปซท้องถิ่นของโมเดลไปยังสเปซโลก จากนั้นไปยังสเปซกล้อง และสุดท้ายไปยังสเปซคลิป การแปลง ถูกกำหนดผ่านเมทริกซ์ยูนิฟอร์ม MVP (โมเดล-วิว-โปรเจกชัน) ซึ่งอัปเดตทุกเฟรมเมื่อกล้องหรือวัตถุเคลื่อนที่

หลังจากการประกอบพรีมิทีฟ (จุด เส้น สามเหลี่ยม) จะดำเนินการแรสเตอร์ — กระบวนการกำหนดว่าพรีมิทีฟแต่ละตัวครอบคลุมพิกเซลหน้าจอใด ตัวแรสเตอร์ สร้างเศษส่วน — พิกเซลที่อาจเกิดขึ้นพร้อมแอตทริบิวต์ที่ถูกประมาณค่าระหว่างกลาง (สี ปกติ พิกัด UV) จำนวนเศษส่วนขึ้นอยู่กับความละเอียดหน้าจอและพื้นที่ฉายของพรีมิทีฟโดยตรง

เชเดอร์เศษส่วนทำงานสำหรับแต่ละเศษส่วนที่สร้างขึ้น มันคำนวณสีพิกเซลสุดท้ายโดยคำนึงถึงพื้นผิว แหล่งกำเนิดแสง และวัสดุ ผลลัพธ์ของเชเดอร์เศษส่วนผ่านชุด การทดสอบต่อเศษส่วน: การทดสอบความลึกกำหนดว่าเศษส่วนมองเห็นได้หรือไม่ การทดสอบสเตนซิลจำกัดการเรนเดอร์ด้วยมาสก์ การผสมผสานผสมสีของเศษส่วนกับสีที่เขียนไว้แล้วในบัฟเฟอร์เฟรม

สถานะบริบทของ OpenGL ES

OpenGL ES ทำงานเป็น เครื่องสถานะ: การตั้งค่าทั้งหมด — เชเดอร์ปัจจุบัน พื้นผิวที่ผูกไว้ การทดสอบที่เปิดใช้งาน — ถูกเก็บไว้ในสถานะทั่วโลกของบริบท การเปลี่ยนสถานะผ่าน glEnable, glBindTexture หรือ glUseProgram ส่งผลต่อคำสั่งวาดทั้งหมดที่ตามมา การเปลี่ยนสถานะแต่ละครั้งทำให้เกิดโอเวอร์เฮดในไดรเวอร์ ดังนั้นการจัดกลุ่มการเรียกวาดตามสถานะจึงเป็นเทคนิคการเพิ่มประสิทธิภาพหลัก

เวอร์ชันของ OpenGL ES และความสามารถ

OpenGL ES 1.0 และ 1.1 (เปิดตัวในปี 2003–2004) อิงตามไปป์ไลน์แบบตายตัว รองรับการแปลง การทำพื้นผิว การให้แสง และการผสมผสาน แต่ไม่อนุญาตให้เขียนโปรแกรมเชเดอร์ API นี้ใช้ในโทรศัพท์มือถือรุ่นแรกและอุปกรณ์ที่ใช้ Symbian และ Windows Mobile ปัจจุบันเวอร์ชันเหล่านี้ถือว่าล้าสมัย — อุปกรณ์สมัยใหม่ไม่รองรับ

OpenGL ES 2.0 (2007) เปิดตัวไปป์ไลน์ที่ตั้งโปรแกรมได้พร้อมเชเดอร์จุดยอดและเศษส่วนใน GLSL ES เวอร์ชันนี้กลายเป็นมาตรฐานสำหรับ Android 2.2+ และ iOS 5+ และยังคงรองรับโดยอุปกรณ์ส่วนใหญ่ OpenGL ES 2.0 คือเวอร์ชันขั้นต่ำที่จำเป็นสำหรับ Unity, Unreal Engine และ Cocos2d-x บนแพลตฟอร์มโมบายล์

OpenGL ES 3.0 (2012) เพิ่มความสามารถสำคัญหลายอย่าง: เป้าหมายการเรนเดอร์หลายรายการ (MRT), ฟีดแบ็กการแปลง, อินสแตนซิง, พื้นผิวรูปแบบใดก็ได้ผ่าน ETC2/EAC ประสิทธิภาพการเรนเดอร์เพิ่มขึ้น 30–50% เมื่อเทียบกับเวอร์ชัน 2.0 โดยลดจำนวนการเรียกวาด OpenGL ES 3.1 (2014) เปิดตัวเชเดอร์การคำนวณและการดำเนินการบัฟเฟอร์อะตอม — ทำให้สามารถทำงานบน GPU ไม่เพียงแต่งานกราฟิกแต่ยังรวมถึงงานคำนวณ (การประมวลผลภายหลัง การจำลองผ้า การคำนวณฟิสิกส์)

OpenGL ES 3.2 (2015) — เวอร์ชันล่าสุดของข้อกำหนด — เพิ่มเชเดอร์เทสเซลเลชันและเรขาคณิต รวมถึงชุดพื้นผิวทศนิยมและโหมดผสมผสานที่ขยายเพิ่ม แม้จะมีการเปิดตัว Vulkan ที่ทันสมัยกว่าในปี 2016 OpenGL ES 3.2 ยังคงเป็น API ที่เกี่ยวข้องเนื่องจากฐานโค้ดที่มีอยู่มหาศาลและความง่ายในการพอร์ตแอปพลิเคชันระหว่างแพลตฟอร์ม

เชเดอร์ใน OpenGL ES: GLSL และไปป์ไลน์ที่ตั้งโปรแกรมได้

GLSL ES (OpenGL Shading Language for Embedded Systems) คือภาษาโปรแกรมเชเดอร์ที่อิงตามไวยากรณ์ C โดยมีชนิดเพิ่มเติมสำหรับการทำงานกับเวกเตอร์และเมทริกซ์ เชเดอร์แต่ละตัวคือโปรแกรมที่ถูกคอมไพล์เป็นโค้ดเครื่อง GPU ในขั้นตอนเริ่มต้นแอปพลิเคชัน ต่างจากโค้ด CPU เชเดอร์ทำงานแบบขนานจำนวนมาก: จุดยอดหรือเศษส่วนหลายพันตัวถูกประมวลผลพร้อมกัน

เชเดอร์จุดยอด

เชเดอร์จุดยอด ประมวลผลแต่ละจุดยอดของเมช หน้าที่หลักคือการคำนวณตำแหน่งจุดยอดสุดท้ายในสเปซคลิปโดยการคูณตำแหน่งนำเข้าด้วยเมทริกซ์ MVP นอกจากนี้ เชเดอร์จุดยอดยังสามารถคำนวณปกติ พิกัด UV สี และส่งต่อไปยังเชเดอร์เศษส่วนผ่านตัวแปร varying การเรียกเชเดอร์จุดยอดแต่ละครั้งทำงานอย่างอิสระ ทำให้ GPU สามารถประมวลผลจุดยอดหลายล้านจุดต่อเฟรม

// Simple vertex shader for OpenGL ES 3.0
#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;
}

เชเดอร์เศษส่วน

เชเดอร์เศษส่วน กำหนดสีของแต่ละพิกเซลบนหน้าจอ มันรับค่า varying ที่ถูกประมาณค่าระหว่างกลางจากเชเดอร์จุดยอด สุ่มตัวอย่างเทกเซลจากพื้นผิวที่ผูกไว้ และใช้การให้แสง สำหรับการให้แสงที่ถูกต้อง จะใช้แบบจำลองฟองหรือบลินน์-ฟองพร้อมการคำนวณองค์ประกอบแบบกระจาย สะท้อนแสง และโดยรอบ การเรียกเชเดอร์เศษส่วนแต่ละครั้งสอดคล้องกับหนึ่งพิกเซล ดังนั้นจำนวนการเรียกทั้งหมดเท่ากับพื้นที่ฉายของวัตถุบนหน้าจอ

// Simple fragment shader with texture and lighting
#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);
}

ในตัวอย่างข้างต้น เชเดอร์เศษส่วนสุ่มตัวอย่างเทกเซลจากพื้นผิว 2D ด้วยพิกัด UV คำนวณการให้แสงแบบกระจายเป็นผลคูณจุดของปกติและทิศทางแสง และคูณสีเทกเซลด้วยความเข้มของการให้แสง Mediump คือความแม่นยำที่แนะนำสำหรับเชเดอร์เศษส่วนบน GPU โมบายล์: ให้คุณภาพเพียงพอโดยใช้พลังงานน้อยที่สุด

วิธีเริ่มทำงานกับ OpenGL ES ในโปรเจกต์โมบายล์

ในการทำงานกับ OpenGL ES บน Android จำเป็นต้องสร้างบริบท EGL — พื้นผิวที่ใช้เรนเดอร์กราฟิก บน iOS จะใช้ชั้น EAGL (คล้าย EGL) ที่ให้โดยเฟรมเวิร์ก GLKit ในทั้งสองกรณี กระบวนการเริ่มต้นรวมถึงการสร้างพื้นผิวหน้าต่าง การกำหนดค่าแอตทริบิวต์บริบท และการผูกกับเธรดการเรนเดอร์ปัจจุบัน

// OpenGL ES 3.0 initialization on Android
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)
    }
}

หลังจากสร้างบริบท นักพัฒนาต้องตั้งค่าบัฟเฟอร์: บัฟเฟอร์จุดยอด (VBO) ประกอบด้วยพิกัดจุดยอด ปกติ และ UV; บัฟเฟอร์ดัชนี (EBO) กำหนดลำดับการ遍历จุดยอดเพื่อสร้างสามเหลี่ยม VAO (Vertex Array Object) รวมการกำหนดค่าแอตทริบิวต์ทั้งหมดเป็นวัตถุเดียว ลดจำนวนการเรียก API เมื่อเปลี่ยนเมช

การตั้งค่าบริบท EGL

EGL (Native Platform Graphics Interface) คือชั้นกลางระหว่าง OpenGL ES และระบบหน้าต่าง บน Android EGL จัดการการสร้างพื้นผิวการเรนเดอร์ การเลือกการกำหนดค่าเฟรมบัฟเฟอร์ (ความลึกสี สเตนซิล MSAA) และการซิงโครไนซ์กับ vsync การกำหนดค่าทั่วไปขอ RGBA8888 พร้อมบัฟเฟอร์ความลึก 24 บิตและบัฟเฟอร์สเตนซิล 8 บิต บน iOS บทบาทของ EGL ดำเนินการโดย EAGL ร่วมกับ CAEAGLLayer

การเพิ่มประสิทธิภาพ OpenGL ES บนอุปกรณ์โมบายล์รวมถึงแนวทางปฏิบัติสำคัญหลายประการ ใช้ อินสแตนซิง (glDrawArraysInstanced) สำหรับการเรนเดอร์วัตถุที่เหมือนกันหลายชิ้น — ซึ่งลดจำนวนการเรียกวาด ใช้พูลพื้นผิวและหลีกเลี่ยงการเปลี่ยนพื้นผิวระหว่างการเรียกวาด จัดเรียงวัตถุตามเชเดอร์ จากนั้นตามพื้นผิว จากนั้นตามเมช — ลำดับนี้ลดการเปลี่ยนสถานะบริบท

OpenGL ES เทียบกับ Metal เทียบกับ Vulkan

Metal คือ API กราฟิกระดับต่ำจาก Apple พร้อมใช้งานบน iOS และ macOS ตั้งแต่ชิป A7 Metal ให้การเข้าถึง GPU โดยตรงโดยมีโอเวอร์เฮดไดรเวอร์น้อยที่สุด แต่ทำงานบนอุปกรณ์ Apple เท่านั้น ตามข้อมูลของ WWDC 2024 Metal ให้ประสิทธิภาพสูงกว่า OpenGL ES บนฮาร์ดแวร์เดียวกันถึง 40% โดยลดการตรวจสอบสถานะในรันไทม์

Vulkan คือผู้สืบทอดข้ามแพลตฟอร์มของ OpenGL ES พัฒนาโดย Khronos Group Vulkan ใช้การจัดการทรัพยากรแบบชัดแจ้ง: นักพัฒนาจัดสรรพูลหน่วยความจำ สร้างบัฟเฟอร์คำสั่ง และซิงโครไนซ์การเข้าถึง GPU ซึ่งให้การควบคุมประสิทธิภาพสูงสุด แต่โค้ดเริ่มต้นของ Vulkan มีขนาดใหญ่กว่า OpenGL ES 3–4 เท่า Vulkan แนะนำสำหรับเกม AAA และแอปพลิเคชันกราฟิกที่ต้องการสูงบน Android 7+

การเลือกระหว่าง OpenGL ES, Metal และ Vulkan ขึ้นอยู่กับแพลตฟอร์มเป้าหมายและข้อกำหนดด้านประสิทธิภาพ OpenGL ES ยังคงเป็นตัวเลือกที่ดีที่สุดสำหรับโปรเจกต์ข้ามแพลตฟอร์มที่ความเร็วในการพัฒนาสำคัญ Metal เหมาะสมกับระบบนิเวศ iOS/macOS ที่มีประสิทธิภาพสูงสุด Vulkan คือตัวเลือกสำหรับโปรเจกต์ที่ทุกมิลลิวินาทีต่อเฟรมมีความสำคัญและงบประมาณการพัฒนาอนุญาตให้ลงทุนในการเพิ่มประสิทธิภาพระดับต่ำ