About OpenGL ES

最新推荐文章于 2024-10-01 22:11:45 发布

ColorPaper

最新推荐文章于 2024-10-01 22:11:45 发布

阅读量951

点赞数

分类专栏： iPhone游戏开发文章标签： application reference concurrency animation performance ios

iPhone游戏开发专栏收录该内容

21 篇文章 0 订阅

订阅专栏

About OpenGL ES

The Open Graphics Library (OpenGL) is used for visualizing 2D and 3D data. It is a multipurpose open-standard graphics library that supports applications for 2D and 3D digital content creation, mechanical and architectural design, virtual prototyping, flight simulation, video games, and more. OpenGL allows application developers to configure a 3D graphics pipeline and submit data to it. Vertices are transformed and lit, assembled into primitives, and rasterized to create a 2D image. OpenGL is designed to translate function calls into graphics commands that can be sent to underlying graphics hardware. Because this underlying hardware is dedicated to processing graphics commands, OpenGL drawing is typically very fast.

OpenGL for Embedded Systems (OpenGL ES) is a simplified version of OpenGL that eliminates redundant functionality to provide a library that is both easier to learn and easier to implement in mobile graphics hardware.

At a Glance

Apple provides implementations of both OpenGL ES 1.1 and OpenGL ES 2.0:

OpenGL ES 1.1 implements a well-defined fixed-function pipeline. The fixed-function pipeline implements a traditional lighting and shading model that allows each stage of the pipeline to be configured to perform specific tasks, or disabled when its functionality is not required.
OpenGL ES 2.0 shares many functions in common with OpenGL ES 1.1, but removes all functions that target the fixed-function vertex and fragment pipeline stages. Instead, it introduces new functions that provide access to a general-purpose shader-based pipeline. Shaders allow you to author custom vertex and fragment functions that are executed directly on the graphics hardware. With shaders, your application can more precisely and more clearly customize the inputs to the pipeline and the computations that are performed on each vertex and fragment.

OpenGL ES is a C-based, Platform-Neutral API

Because OpenGL ES is a C-based API, it is extremely portable and widely supported. As a C API, it integrates seamlessly with Objective-C based Cocoa Touch applications. The OpenGL ES specification does not define a windowing layer; instead, the hosting operating system must provide functions to create an OpenGL ES rendering context, which accepts commands, and a framebuffer, where the results of any drawing commands are written to.

Relevant Chapters: “OpenGL ES on iOS,” “Configuring OpenGL ES Contexts”

OpenGL ES is Integrated into Core Animation

Core Animation is fundamental to iOS graphics, and that includes OpenGL ES content that your application delivers to the screen. When you develop an OpenGL ES application, your OpenGL ES content is rendered to a special Core Animation layer, known as a CAEAGLLayer object. The images you render using OpenGL ES are stored in the CAEAGLLayer. Core Animation composites these images with content in other layers and delivers the final image to the screen.

Relevant Chapters: “Drawing With OpenGL ES”

Framebuffer Objects are Always the Rendering Destination

The OpenGL ES specification assumes there are two kinds of framebuffers: system-provided framebuffers and framebuffer objects. A system framebuffer is allocated using an API provided by the host operating system, and connects to the screen or windowing environment. In contrast, framebuffer objects target offscreen rendering and fully supported within the OpenGL ES specification. iOS only uses framebuffer objects; rather than create a separate system framebuffer, iOS extends the OpenGL ES API to allow a framebuffer object to be allocated so that its contents are shared with Core Animation.

Relevant Chapters: “Drawing With OpenGL ES”

Functionality May Vary on Different Devices

iOS devices support a variety of graphics processors with varying capabilities. Some devices support both OpenGL ES 1.1 and OpenGL ES 2.0; older devices only support OpenGL ES 1.1. Even devices that support the same version of OpenGL ES may have different capabilities depending on the version of iOS and the underlying graphics hardware. Apple offers many OpenGL ES extensions to provide new capabilities to your applications.

To allow your application to run on as many devices as possible and to ensure compatibility with future devices and iOS versions, your application must always test the capabilities of the underlying OpenGL ES implementation at run time, disabling any features that do not have the required support from iOS.

Relevant Chapters: “Configuring OpenGL ES Contexts,” “Determining OpenGL ES Capabilities,” “Platform Notes”

Applications Require Additional Performance Tuning

Graphics processors are parallelized devices optimized for graphics operations. To get great performance in your application, you must carefully design your application to feed data and commands to OpenGL ES so that the graphics hardware runs in parallel with your application. A poorly tuned application forces either the CPU or the GPU to wait for the other to finish processing commands.

You should design your application to efficiently use the OpenGL ES API. Once you have finished building your application, use Instruments to fine tune your application’s performance. If your application is bottlenecked inside OpenGL ES, use the information provided in this guide to optimize your application’s performance.

Xcode 4 provides new tools to help you improve the performance of your OpenGL ES applications.

Relevant Chapters: “OpenGL ES Application Design Guidelines,” “Best Practices for Working with Vertex Data,” “Best Practices for Working with Texture Data,” “Best Practices for Shaders,” “Tuning Your OpenGL ES Application,” “Platform Notes”

OpenGL ES May Not Be Used in Background Applications

Applications that are running in the background may not call OpenGL ES functions. If your application accesses the graphics processor while it is in the background, it is automatically terminated by iOS. To avoid this, your application should flush any pending commands previously submitted to OpenGL ES prior to being moved into the background and avoid calling OpenGL ES until it is moved back to the foreground.

Relevant Chapters: “Implementing a Multitasking-aware OpenGL ES Application”

OpenGL ES Places Additional Restrictions on Multithreaded Applications

Designing applications to take advantage of concurrency can be useful to help improve your application’s performance. If you intend to add concurrency to an OpenGL ES application, you must ensure that the application does not access the same context from two different threads at the same time.

Relevant Chapters: “Concurrency and OpenGL ES”

How to Use This Document

If you are new to OpenGL ES or iOS development, begin by reading “OpenGL ES on iOS,” which provides an overview of the architecture of OpenGL ES and how it integrates into iOS. Read the remaining chapters in order.

Experienced iOS developers should focus on reading “Drawing With OpenGL ES” to learn new details about how to integrate OpenGL ES into your application as well as how to correctly implement your rendering loop. Then, read “OpenGL ES Application Design Guidelines” to dig deeper into how to design efficient OpenGL ES applications. “Platform Notes” provides more detailed information on the available hardware and software available to your application.

Prerequisites

Before attempting to create an OpenGL ES application, you should already be familiar with views, and how views interact with Core Animation. See View Programming Guide for iOS.

Although this document introduces important OpenGL ES concepts, it is not a tutorial or a reference for the OpenGL ES API. To learn more about creating OpenGL ES applications, consult the references below.