Fahrenheit represents an alliance aimed at leveraging the best
graphics minds and technologies within each respective company,
guaranteed to dramatically increase what is possible in graphics today and
well into the future.
But what exactly is Fahrenheit? What are the components and how will
they benefit you the developer? This article will help you gain
further understanding of the Fahrenheit project, including the background
information on the constituent APIs, some of the benefits that you can
realize by targeting these new technologies, recommendations on API
transition, and development timelines.
The Fahrenheit project comprises the following components:
- Fahrenheit Scene Graph API (FSG)
The most significant API in the Fahrenheit initiative,
this API builds on the services offered by the
rendering API (whether OpenGL®, D3D IM,
or
FLL). It offers a tree-like data structure in which a
scene can be described in terms of geometry,
textures, lighting, and so on. Applications that make
use of this layer are concerned with describing what
to draw rather than how to draw it. In addition to the
geometrical description of the scene it is possible to
provide high-level instructions to FSG indicating the
intent of the application. For example, it will be
possible to indicate to FSG that image quality is of
primary concern, or alternately that a fixed frame rate
is desired. It is expected that applications will see
tremendous performance gains when taking
advantage of the Fahrenheit Scene Graph API. FSG
is strongly influenced by SGI scene
graph technology as found in IRIS PerformerTM, Open
InventorTM, Cosmo3DTM, and OpenGL++.
- Fahrenheit Large Model Visualization API (FLM)
The FLM Visualization Extensions will be based on
technology from the SGI OpenGL
OptimizerTM API and complementary technology
from the Hewlett-Packard® DirectModel
API. FLM
will be an extension to the FSG that provides
functionality specific to the creation and
visualization of very large models, such as an entire
automobile, and understands many of the commonly
used CAD constructs such as NURBS, curved
surfaces, and the like.
- Fahrenheit Low-Level API (FLL)
This is a low-level rendering API providing a level of
abstraction from the graphics hardware. This level
typically deals with geometric primitives such as
points, lines, and triangles (polygons). Current APIs
that offer these services include OpenGL and D3D
IM. Applications that program to this rendering level
have to explicitly explain to the system how to draw
a scene in terms of the primitives that this layer
understands. FLL will replace D3D as the low-level
graphics API for Windows and will sit alongside
OpenGL.
Figure 1 illustrates how FLM, FSG, and
low-level APIs
such as OpenGL can be mixed for use in the same
application. For new applications, you can use high-level
toolkits for most of your work, but add direct low-level calls
when necessary for a specific feature. For existing
applications, this allows gradual adoption of FSG and FLM,
rather than forcing a complete application rewrite.
Figure 1: Fahrenheit model enables use of FLM, FSG, and OpenGL in a single
application
Schedule
SGI's and Microsoft's release strategy is based on a phased
approach. The first component to ship will be the
Fahrenheit Scene Graph. Developers can expect to see a beta version in the
first quarter of 1999 with a final release in the
second quarter. The Fahrenheit Large Model will track the schedule of the
Fahrenheit Scene Graph API and will be released
within weeks of Fahrenheit Scene Graph. The Fahrenheit Low-Level API will be
released in the year 2000; exact dates are not
yet available. Table 1 summarizes the present schedule for SGI's
upcoming APIs:
API |
Specification |
Beta |
First Release |
OpenGL 1.2 |
Now available1 |
TBD |
Fall 1998 |
FSG |
Summer 1998 |
Early 1999 |
Spring/Summer 1998 |
FLM |
FLL |
Spring 1999 |
Late 1999/Early 2000 |
Spring 2000 |
Table 1: API Schedule
1You can download the specification from
https://toolbox.sgi.com/toolbox/documents/OpenGL/opengldoc/glspec/opengl12.html
Benefits
The most important component of the Fahrenheit project is
the Fahrenheit Scene Graph API, which is also the first to be
released. FSG is being designed to support a wide range of
hardware configurations and application requirements, from
the real-time visualization of very large worlds on machines
with multiple processors and multiple graphics subsystems
to games and interactive applications running on personal
computers.
FSG is also designed to enable a new level of
standardization that allows for portability of features without
taking a lowest-common-denominator approach and without
sacrificing performance. It allows innovation through a
powerful extension mechanism that gives both software and
hardware developers unparalleled ability within the FSG
framework to extend, enhance, or re-implement
functionality of the FSG. The result is that advances in
graphics hardware will benefit applications that were not
specifically written to take advantage of them.
Standardization is provided without frustrating future
hardware and software innovation, benefiting both hardware
and software developers. In order for developers to
successfully leverage various kinds of hardware in today's
and tomorrow's complex environments, Fahrenheit will
provide the following:
- Abstraction
FSG enables ISVs to program to a level of
abstraction that gives them the freedom to focus on
the added value of their application, rather than
dealing with the minutiae of programming graphics
at the lower rendering level. Programmers can
specify what is to be drawn rather than how it is to be
drawn. For those programmers who need the control
available at the low level, there is still full access to it.
- Extensibility
FSG allows for selective replacement or
enhancement of the scene data contained within the
graph, as well as replacement or enhancement of the
scene graph actions. Replacement or enhancement of
scene graph functionality can be achieved in both
software and hardware, allowing optimizations not
possible at a lower layer API. FSG supports run-time
configuration and selection of extensions, allowing
application developers to get improved performance
on hardware released after their initial release. All
without requiring any application changes.
- Multiprocessing
FSG will be fully multiprocessing-ready, allowing
applications and problems to scale with the
capabilities of the hardware. FSG supports parallel
execution of multiple processes that can each access
and mutate the scene graph data independently. Best
of all, FSG will automatically make use of multiple
processors without requiring application
programmers to specifically write multiprocessing
code in their programs. Common tasks such as
culling, drawing, intersection testing, and database
paging traversals all automatically benefit from the
availability of multiple processors.
OpenGL: The Road Ahead
In addition to building the new Fahrenheit technologies
SGI and the OpenGL ARB will continue to
make heavy investments in advancing OpenGL. As a case in
point, on March 9th 1998, the OpenGL ARB ratified the
latest specification, OpenGL 1.2. The OpenGL 1.2
specification evolved with inputs from both ARB and
interested non-ARB parties. The philosophy of OpenGL is
to follow evolutionary trends in hardware. As such, the
process of enhancing OpenGL includes evaluating OpenGL
extensions and determining which ones are so widely used
and accepted, that they should be incorporated into the core
functionality of OpenGL. In the OpenGL 1.2 Specification,
eight extensions were brought into the core. For more
information on these extensions, refer to
"Announcing
the OpenGL 1.2 Specification"
(Developer
News, March/April 1998):
Note: This Web site requires a login ID and password,
which are distributed only to members of the Developer
Program. To find out how you can access this Web site, send
an e-mail to
devprogram@sgi.com.
SGI and the ARB expect to see OpenGL 1.2
implementations available across a wide variety of platforms
in Q4 98. Finally, SGI and Microsoft are
currently working on an OpenGL ICD (Installable Client
Driver) Device Driver Kit (DDK) for Windows 95/98 and
Windows NT®. This new driver kit will
allow PC IHVs to
easily create quality, high-performance OpenGL hardware
accelerators for the growing number of OpenGL based
graphics applications on the Windows platform. This DDK
will be available to graphics board and chip vendors in
July 1998.
Supporting Existing Graphics APIs
Over the years SGI has announced and created
a number of key graphics APIs aimed at various markets and
developer needs. These APIs include:
- Open Inventor
- IRIS Performer
- OpenGL Optimizer/Cosmo3D
- OpenGL++
Developers have come to rely quite heavily on the
availability of these technologies running on both UNIX and
Windows NT platforms. As we architect for the next
millennium and work with partners like Microsoft, SGI will continue to maintain and support these
technologies. In a case where an API is being phased out a
transition plan to ensure a smooth migration unto an
equivalent or more capable technology will be provided.
Below is a brief outline of the future of some of our
Graphics APIs.
Open Inventor
SGI will continue its maintenance of Open
Inventor throughout the development of Fahrenheit. Once
the Fahrenheit Scene Graph API is available, a development
effort will be undertaken to migrate those features that sit
above the Inventor scene graph (manipulators, viewers, and
the like) onto the new Fahrenheit Scene Graph API. As the
features and functionality of Open Inventor will be carried
over into a new Inventor, developers will be urged to
migrate their applications onto this new API. The existing
Open Inventor will be maintained until developers have
completed their transition to the new Inventor.
IRIS Performer
One of SGI most successful APIs, IRIS
Performer is primarily aimed at developers of real-time,
multiprocessed, interactive graphics applications running on
the Onyx family of graphics supercomputers. Application
areas include visual simulation (vis/sim) and location-based
entertainment (LBE). While a number of developers
currently using Performer will be able to migrate to the new
Fahrenheit Scene Graph API, and will be encouraged to do
so, SGI will continue to heavily invest in
enhancements to Performer in support of real-time
applications and the Onyx2 marketplace for the foreseeable
future.
OpenGL Optimizer/Cosmo3D
As evidenced by the latest release of OpenGL Optimizer 1.1
(June 9th, 1998), SGI will continue to make
significant investments in enhancing Optimizer. This
includes adding features in support of the CAD/CAM,
digital prototyping marketplace as well as migration onto
additional UNIX platforms such as SUN, HP and IBM.
Additionally, as a large portion of the Optimizer technology
will become the basis for the Fahrenheit Large Model
Visualization API, SGI will continue to evolve
the Optimizer/Cosmo3D to closely resemble the Fahrenheit
Large Model and Fahrenheit Scene Graph APIs. Thus,
developers are encouraged to continue using the Optimizer
technology as a bridge to the Fahrenheit technologies.
Cosmo3D will continue forward as the scene graph for
Optimizer. Subsequently, only those features necessary to
support Optimizer will be enhanced and maintained. SGI will not enhance the VRML oriented features of
Cosmo3D and do not recommend developers use Cosmo3D
as a general-purpose scene graph API. Developers using
Cosmo3D in this fashion are urged to migrate their
applications onto the Fahrenheit Scene Graph API once
available. The Cosmo3D/Optimizer combination will
continue to be maintained until developers have migrated to
the Fahrenheit Scene Graph API and the Fahrenheit Large
Model Visualization API.
OpenGL++
Last year SGI announced a scene graph
initiative with the OpenGL ARB known as OpenGL++. As
the Fahrenheit Scene Graph API will be based on SGI's original work with scene graph technology,
including those proposed for OpenGL++. SGI
will immediately cease its scene graph work with
OpenGL++. Henceforth all future SGI scene
graph development will focus on delivering the Fahrenheit
Scene Graph API.
Figure 2 illustrates how technology from SGI's
current APIs is being incorporated into Fahrenheit APIs:
Figure 2: SGI API technology being incorporated into Fahrenheit
APIs
Notes on Figure 2:
- Performer, Open Inventor, Cosmo3D, and OpenGL++ technology will serve as
the basis for FSG.
- Performer, ImageVision, and Open Inventor features will be incorporated
into the FSG and extensions to the FSG.
- Optimizer will serve as the basis for FLM.
Fahrenheit Platform Support
As announced, FSG and FLM will be supported on at least the following
platforms:
- SGI IRIX
- HP-UX
- Windows 95 and Windows 98
- Windows NT
Summary
Sixteen years ago, SGI embarked on a mission
of bringing the best graphics and visualization technologies
and products to the design, engineering and scientific
community. Fahrenheit represents a continuation of this
mission. In partnership with Microsoft, SGI
again begins a journey of defining the future of graphics.
Acknowledgments
For contributing their time and expertise to the writing and
review of this article, thanks are due to Mike Kelley,
Lynn Crilley, Ann LaGrone, Hank Shiffman, Chris Insinger,
and Brian Cabral.