SGi Windows NT Toolbox
|Download Files|



Fahrenheit: Defining the Future of Graphics

By Shawn Hopwood, Group Manager, Graphics APIs, Product Marketing, and
      Anatole Gordon, Developer Readiness Group

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.

Fahrenheit model enables use of FLM, FSG, and OpenGL in a
single application

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:

SGI API technology 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.