QNX Core Graphics Technology

QNX Core Graphics is an excellent library for creating and implementation application user interfaces on hardware that cannot support the overhead of a full windowing system. It provides the services needed to support interfaces ranging from the smallest 2D environment to full-featured 3D environments.

Features supported by QNX Core Graphics include:

• integration with graphics device layering facilities
• 2D hardware acceleration, where supported by the GPU
• 3D hardware acceleration, where supported by the GPU
• multi-buffering for flicker-free animations

Applications built with QNX Core Graphics typically use a variety of components, including:

• the QNX Graphics Framework, which provides a framework for creating 2D application user interfaces without the overhead of a full windowing system
• OpenGL ES for 3D interfaces
• an input manager for mouse and keyboard management
• the font rendering system
• the image rendering library

The architecture allows applications to render directly to hardware, making them faster and more responsive in an embedded environment where resources are limited.

QNX Graphics Framework

The QNX Graphics Framework (GF) is perfect for embedded environments, where it can be used as the basic graphics layer for:

• simple, full screen interfaces
• complex windowing systems with multiple application GUIs
• a porting layer for existing user interfaces

The GF provides applications direct access to graphics drivers, and hardware acceleration where possible.

Multiple threads and applications

While the GF is intended for full screen application user interfaces, it can handle multiple threads and multiple applications — including GF applications running alongside QNX® Photon microGUI® applications.

2D API

QNX Core Graphics includes a the GF's comprehensive 2D API library. This API supports key 2D graphics capabilities, such as drawing, rendering, layering, alphablending, association of drawing surfaces to contexts, and so on.

OpenGL ES

QNX Core Graphics supports the OpenGL ES 1.0 specification, a well-defined subset of OpenGL designed for 3D graphics in embedded applications. The QNX Neutrino implementation of OpenGL ES supports the Common profile and EGL platform interface layers.

Client/server

The GF implements a client/server model:

• The server manages device resources (such as memory and layers) and hardware access.
• The client (GF application) renders directly to the hardware.

Clients can obtain a lock to ensure that only one thread or application has access to the hardware at a time.

The server provides robustness by catching abnormal client termination, cleaning up resources after termination, and reviving the shared mutex if it was held by an abnormally terminated client.

The server includes a monitor process that brokers client access to hardware, allocates video memory, and handles application termination (both normal and abnormal) by releasing allocated memory and, if necessary, locked hardware. This monitor is invisible to GF clients — all interactions are handled internally by the library.

Third-party frameworks

Third-party or existing in-house graphics frameworks for underlying features perfroming tasks such as 2D and 3D drawing, or provided image and font support can easily use QNX Core Graphics. Developers only need to create simple wrapper routines to abstract the drawing operations for QNX Core Graphics.

Example of an application built with QNX Core Graphics

The QNX composition manager is an OpenKODE-compliant lightweight composited windowing system that allows developers to merge the output of multiple windows and processes (Flash, native code applications, browsers) on to a single display — even with lower cost graphics controllers that don’t support hardware layering.

The QNX composition Manager supports hardware display layers and software-emulated display layers, and enables the easy creation of transparency holes in video and flash content.

QNX composition manager

Configurable loading

The QNX composition manager can be configured to use available compositing hardware so as to best meet the needs of a particular system. For example, on a system requiring frequent updates, it might be configured to maximize its use of layers available on a display controller, while on a system requiring less frequent updates it might use a 2D core to perform the same task.

Enabling the HMI

The QNX composition manager allows an HMI to interact with applications without manipulating the applications themselves, and without incurring any overhead from message passing.

An HMI can use OpenKODE extensions to receive events whenever a window is created, realized, or destroyed, or whenever properties for a given window are changed. The API enables the HMI to change the properties of any application's window, giving it complete control over the layout of the display, without directly interacting with the application.

The lists below identify key features supported by QNX Core Graphics.

2D graphic primitives

• rectangles, polylines, polygons, blitting
• alpha, chroma and raster operations
• accelerated alpha-maps

3D support

• OpenGL® ES API Common Profile version 1.0 — floating point and fixed point libraries Images
• BMP, GIF, JPEG and PNG formats
• smooth resizing and scaling

Fonts

• TrueType
• Adobe Type 1 and Type 2
• Bitstream™ Stroke Fonts (including Chinese and Japanese)

Font options

• anti-aliasing
• rotations
• borders and outlines
• international fonts (UTF-8)
• scalable fonts
• hinting and kerning

Video capture API

• up/down hardware scaling
• RGB and YUV formats

Layering API

Where supported by hardware:

• drawing surface to layer association
• layer ordering
• on or off for individual layers
• alphablending and chromacolor between layers
• source and destination viewport sizing and scaling, and panning control

Binaries

• OpenGL ES libraries
• 2D libraries
• software-only OpenGL ES libraries, providing 3D support for graphics chips that have no 3D hardware acceleration
• the QNX composition manager
• image loading library supporting multiple image formats
• font libraries
• sample applications pre-compiled for testing 2D and 3D graphics

Documentation

• Graphics Framework developer's guide
• OpenGL ES 1.0 documentation set
• Font Fusion API document

Sample source code

• 2D samples — draw rectangle, load and display image, load and display text, etc.
• 3D samples — vertex arrays, texture maps, etc.
• layer control — turn on/off layer, change chromacolor, etc.

Hardware acceleration

Hardware-accelerated graphics drivers are used wherever possible, for both 2D and 3D graphics. When hardware acceleration is not supported, QNX Core Graphics provides appropriate software fallback routines.

Drivers

• Fujitsu Coral B/P/PA graphics driver
• Fujitsu Carmine graphics driver
• Intel Extreme2 (855GM) graphics
• VESABios graphics driver for x86, VESA-compliant graphics controllers
• VMware graphics driver for QNX VMware sessions

Additional graphics drivers are provided in individual BSPs (Board Support Packages).

System requirements

• QNX SDP 6.4.0 or more recent, on X86, PPC, SH4 and ARM target systems.
• QNX Momentics® IDE 6.3.0 or more recent

Optional

• QNX Core Graphics windowing system requires a license for each runtime if it is distributed with a customer product.

Developers working with QNX® Core Graphics technology can use combinations of displays, layers, surfaces and contexts to build very complex screens from simple applications

2D trend graph with touch screen

Example of a 2D application built with QNX Core Graphics

 

• 2D monitor display with touch screen and using high speed trend graphs.

 

2D map

The 2D navigation example below shows a graphics environment that supports four layers. Three layers are being used: one for 2D map display, one for menu/touch screen and another for warning messages. The developer may choose to build this type of screen as one complete program or as three separate programs. Proper use of chromakey and alphablending enable the visibility between the layers.

Example of a 2D application built with QNX Core Graphics

A four-layer 2D navigation system using alpha-blending to display menus and emergency notices.

 

3D map

Adding 3D is simple as developing an OpenGL ES program and either replacing the 2D program with the 3D upgrade or running the OpenGL ES program on the same layer as 2D (split screen).

Example of a 3D application built with QNX Core Graphics

A 3D map application built with QNX Core Graphics and the OpenGL ES API.

 

Adding a web browser becomes as simple as starting the QNX® Photon microGUI® on a graphic layer, then running a custom web browser application developed with the QNX web browser technology development kit.

Example of a split screen application built with QNX Core Graphics

A kiosk information system built with QNX Core Graphics and the OpenGL ES API.