The Fahrenheit Architecture
Fahrenheit is a collaborative engineering project between
SGI and Microsoft for the creation of a
complete, high-performance graphics architecture.
Fahrenheit will provide consumer and professional
application developers the ability and technology to easily
create powerful, next- generation graphics applications on
and across UNIX(R) and Windows(R) platforms.
The Fahrenheit project comprises the following three
components:
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(R) and D3D Immediate Mode
(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 and their properties that
this layer understands. FLL will replace Direct3D as the
low-level graphics API for Windows, sitting next
to OpenGL.
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, etc. 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. FSG is strongly influenced by SGI
scene graph technology as found in Performer(TM), Open
Inventor(TM), Cosmo3D(TM), and OpenGL++.
Fahrenheit Large Model Visualization API (FLM)
The FLM Visualization Extensions will be based on
technology from the SGI OpenGL Optimizer(TM)
API and complementary technology from HP's DirectModel API.
FLM will be an extension to the FSG that provides
functionality specific to the visualization of very large
models, such as an entire automobile, and understands many
of the commonly used CAD constructs such as NURBS, curved
surfaces, etc. As a direct result of this new relationship
Microsoft has agreed to discontinue its plans to deliver
DirectModel as an API.
Figure 1: Fahrenheit Architecture.
Fahrenheit Scene Graph API Features
Abstraction
FSG enables ISVs to program to a level of abstraction that
gives them the freedom to focus on their application
value-add, 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 the low level.
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 that is released after their
software is released 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 the
application programmer 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.
The Fahrenheit Schedule
SGI and Microsoft have elected to release
Fahrenheit components in a phased approach. Fahrenheit
Scene Graph will be the first component to ship. Developers
can expect to see a beta version in Q1 '99 with a final
release in Q2 '99. 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 will be released in the year 2000,
exact dates are not yet available.
Figure 2. Fahrenheit Schedule. (Note. Quarters based on
calendar year)