The Wayback Machine - http://web.archive.org/web/20050214015749/http://www.khronos.org:80/opengles/
Home Download a Spec
 OpenGL ES   OpenML   OpenVG   OpenMAX   News & Events   Members   Contact 
The Khronos Groups 3D, Images, Vector Graphics, Audio, Video, Media Primitives, I/O

   Home > OpenGL ES > Overview
Related Links

OpenGL ES Overview

What's New in v1.1

OpenGL ES Spec

OpenGL ES Licensing & Logos

OpenGL ES Presentations

OpenGL ES FAQ

OpenGL ES Message Boards

Become an Adopter

OpenGL ES Adopter Login

OpenGL ES Adopters List



OpenGL ES Paraphernalia

OpenGL ES Press Coverage
OpenGL ES Overview

OpenGL ES - The Standard for Embedded Accelerated 3D Graphics

OpenGL ES

OpenGL® ES is a royalty-free, cross-platform API for full-function 2D and 3D graphics on embedded systems - including handheld devices, appliances and vehicles. It is a well-defined subset of desktop OpenGL, creating a flexible and powerful low-level interface between software and graphics acceleration. OpenGL ES includes Common and Common-Lite profiles for floating-point and fixed-point systems and the EGL™ specification for portably binding to native windowing systems. OpenGL ES 1.1 emphasizes hardware acceleration of the API, while OpenGL ES 1.0 focuses on enabling software-only implementations. OpenGL ES 1.1 is fully backwards compatible with 1.0 - enabling easy porting of applications between the two versions of the API.

Download the OpenGL ES Specification

About OpenGL ES: Royalty free 2D/3D API consisting of well-defined subset profiles of OpenGL

OpenGL® ES is a low-level, lightweight API for advanced embedded graphics using well-defined subset profiles of OpenGL. It provides a low-level applications programming interface (API) between software applications and hardware or software graphics engines.

This standard 3D graphics API for embedded systems makes it easy and affordable to offer a variety of advanced 3D graphics and games across all major mobile and embedded platforms. Since OpenGL ES (OpenGL for Embedded Systems) is based on OpenGL, no new technologies are needed. This ensures synergy with, and a migration path to, full OpenGL -- the most widely adopted cross-platform graphics API.


Developer Advantages

  • Industry Standard and Royalty Free
    Anyone can download the OpenGL ES specification and implement and ship products based on OpenGL ES. With broad industry support, OpenGL ES is the only truly open, vendor-neutral, multi-platform embedded graphics standard. The standardized higher level of abstraction that it offers means developers can concentrate more on content and less on the minor code and platform details.
  • Small footprint & low power consumption
    The embedded space varies widely, ranging from 400Mhz PDAs with 64MB RAM to 50MHz mobile phones with 1 MB RAM. OpenGL ES is designed to accommodate these differences by requiring a minimum footprint with minimum data storage requirements, minimized instruction/data traffic, and is both integer and floating point friendly. For users this means smaller binaries to download that take up less storage on the device.
  • Seamless transition from software to hardware rendering
    Although the OpenGL ES specification defines a particular graphics processing pipeline, individual calls can be executed on dedicated hardware, run as software routines on the system CPU, or implemented as a combination of both dedicated hardware and software routines. This means that software developers can ship a conformant software 3D engine today, that lets applications and tools seamlessly transition over to using OpenGL ES hardware-acceleration in next generation devices.
  • Extensible & Evolving
    OpenGL ES allows new hardware innovations to be accessible through the API via the OpenGL extension mechanism and for the API to be easily updated. As extensions become widely accepted, they are considered for inclusion into the core OpenGL ES standard. This process allows OpenGL ES to evolve in a controlled yet innovative manner.
  • Easy to use
    Based on OpenGL, OpenGL ES is well structured with an intuitive design and logical commands.
  • Well-documented
    Because OpenGL ES is based on OpenGL, there are numerous relevant books, and a great deal of relevant sample code, making information about OpenGL ES inexpensive and easy to find. With the introduction of OpenGL ES, a developer can now write basically the same code for cell phones to supercomputers.



The OpenGL ES framework

  • Profiles:

    The OpenGL ES specification includes the definition of several profiles. Each profile is a subset of the OpenGL 1.5 specification plus some additional OpenGL ES-specific extensions. The OpenGL ES profiles are part of a wider family of OpenGL-derived application programming interfaces. As such, the profiles share a similar processing pipeline, command structure, and the same OpenGL name space. Where necessary, extensions are created to augment the existing OpenGL 1.5 functionality. OpenGL ES-specific extensions play a role in OpenGL ES profiles similar to that played by OpenGL ARB extensions relative to the OpenGL specification. OpenGL ES-specific extensions are either precursors of functionality destined for inclusion in future core profile revisions, or formalization of important but non-mainstream functionality. Each profile definition implies a distinct header file and link/runtime library defining the commands and tokens in the profile. To simplify maintenance a single superset header can be defined with appropriate conditional preprocessing directives to control the visibility of tokens and command prototypes. At run-time an application can determine which profile is running using the OpenGL version string query.

    Currently the specification consists of a total two profile definitions: the Common Profile, and the Safety Critical Profile.


    • The Common Profile is intended for consumer entertainment and related devices such as telephone handsets, PDAs, set-top boxes, game consoles, etc. It addresses the broadest range of the market including support for platforms with varying capability.
      • Minimum footprint full function 3D with texture-mapping
      • Good gaming platform
      • Implementable on cell phones

    • The Safety Critical Profile is intended for consumer and industrial applications where reliability and certifiability are the primary constraints.
      • Absolute minimum 3D to ease safety certifications
      • Used in avionics and automotive displays

  • Conformance

    Specifications are reviewed and revised on a yearly basis. To label an implementation as an OpenGL ES compliant implementation, the implementation must pass a set of conformance tests. The conformance test definitions are maintained as a separate part of the OpenGL ES documentation.

  • Extensions:

    OpenGL ES implementations may include extensions that add new features to the implementation. An OpenGL ES profile consists of two parts: a subset of the full OpenGL pipeline, and some extended functionality that is drawn from a set of OpenGL ES-specific extensions to the full OpenGL specification. Each extension is pruned to match the profile's command subset and added to the profile as either a core addition or a profile extension. Core additions differ from profile extensions in that the commands and tokens do not include extension suffixes in their names. Profile extensions are further divided into required (mandatory) and optional extensions. Required extensions must be implemented as part of a conforming implementation, whereas the implementation of optional extensions is left to the discretion of the implementor.

  • Platform Interface Layer - EGL:

    OpenGL ES also includes a specification of a common platform interface layer, called EGL. This layer is platform independent and may optionally be included as part of a vendor’s OpenGL ES distribution. The platform binding also has an associated conformance test. Alternatively, a vendor may choose to define their own platform-specific embedding layer.



The OpenGL ES 1.0 Common Pipeline

OpenGL ES is a low-level API that enables the lightest weight interface between software and hardware, with well-proven specification of advanced graphics techniques from OpenGL.
Using the OpenGL 1.3 pipeline features as the basis, the OpenGL ES 1.0 pipeline includes:

  • Geometry Processing
    • Vertex Arrays
    • Points, Lines, Triangles
    • Matrix Stack
    • Viewport, DepthRange
    • Vertex Lighting
    • ShadeModel

  • Rasterization
    • Multisampling (optional)
    • Points & anti-aliased points
    • Lines & anti-aliased lines
    • Polygons
      Face Culling
    • PolygonOffset - fill mode

  • Texture Mapping
    • 2D Textures
    • Wrap repeat, edge_clamp
    • Compressed Texture
    • TexSubImage, CopyTexImage
    • Multitexture
    • RGBA pixel and packed pixel formats, L, LA
    • All Filters

  • Fragment Processing
    • Fog
    • Scissor Test
    • Alpha Test
    • Stencil Test (optional)
    • Depth Test (optional)
    • Blending
    • Logic Op
    • Dither

    • Framebuffer Operations/Miscellaneous
    • Clear
    • ReadPixels / Alpha Test / Dither
    • Flush/Finish
    • Hint
    • Get-static state (constants)


    What's New in OpenGL ES 1.1

    OpenGL ES 1.1 emphasizes hardware acceleration of the API, but is fully backwards compatible with 1.0. New features in OpenGL ES 1.1 provide enhanced functionality, improved image quality and optimizations to increase performance while reducing memory bandwidth usage to save power. These include:

    • OpenGL 1.5 as a reference - the specification is defined relative to the OpenGL 1.5 specification.

    • Buffer objects provide a mechanism that clients can use to allocate, initialize and render from memory. Buffer objects can be used to store vertex array and element index data.

    • Auto mipmap generation can offload the application from having to generate mip-levels. Hardware implementations can potentially accelerate auto mip-level generation especially for video textures or when rendering to texture. A texture is considered incomplete in OpenGL ES if the set of mipmap arrays are not specified with the same type. The check for completeness is done when a given texture is used to render geometry.

    • Enhanced texture processing including a minimum of two multi-textures and texture combiner functionality for effects such as bump-mapping and per-pixel lighting. All OpenGL 1.5 texture environments except for the texture crossbar are supported.

    • Vertex skinning functionality using the oes_matix_palette extension allows smooth animation of complex figures and geometries. The extension allow OpenGL ES to support a palette of matrices. The matrix palette defines a set of matrices that can be used to transform a vertex. The matrix palette is not part of the model view matrix stack

    • User-defined clip planes permit for efficient early culling of non-visible polygons -increasing performance and saving power

    • Enhanced point sprites and point sprite arrays provides a method for application to draw particles using points instead of quads. This enables efficient and realistic particle effects. The point sprites extension also allows an app to specify texture coordinates that are interpolated across the point instead of the same texture coordinate used by traditional GL points. The Point Size Array extension permits an array of point sizes instead of a fixed input point size and provides flexibility for applications to do particle effects.

    • Static and Dynamic state queries are supported for static and dynamic state explicitly supported in the profile. The supported GL state queries can be categorized into simple queries, enumerated queries, texture queries, pointer and string queries, and buffer object queries. This enables OpenGL ES to be used in a sophisticated, layered software environment

    • Draw Texture defines a mechanism for writing pixel rectangles from one or more textures to a rectangular region of the screen. This capability is useful for fast rendering of background paintings, bitmapped font glyphs, and 2D framing elements in games

    • New Core Additons and Profile Extensions for the Common and Common-Lite profiles add subsets of the OES byte coordinates, OES fixed - point, OES single precision and OES matrix get ES-specific extensions as core additions; OES - read format, OES compressed paletted texture, OES point size array and OES point sprite as required profile extensions; and OES matrix palette and OES draw texture as optional profile extensions.



    All contents copyright © 2004 Khronos Group. All rights reserved. All product
    names are trademarks or registered trademarks of their respective holders.