QuickDraw 3D

Last updated

Mac OS Scrapbook version 7.5.2 (1996), showing a QuickDraw-3D-based 3D model Scrapbook Quickraw 3D model.png
Mac OS Scrapbook version 7.5.2 (1996), showing a QuickDraw-3D-based 3D model

QuickDraw 3D, or QD3D for short, is a 3D graphics API developed by Apple Inc. (then Apple Computer, Inc.) starting in 1995, originally for their Macintosh computers, but delivered as a cross-platform system. [1]

Contents

QD3D was separated into two layers. A lower level system known as RAVE (Rendering Acceleration Virtual Engine) provided a hardware abstraction layer with functionality similar to Direct3D or cut-down versions of OpenGL like MiniGL. On top of this was an object-oriented scene graph system, QD3D proper, which handled model loading and manipulation at a level similar to OpenGL++. [2] The system also supplied a number of high-level utilities for file format conversion, and a standard viewer application for the Mac OS.

QD3D had little impact in the computer market, both as a result of Apple's beleaguered position in the mid-1990s, as well as several fateful decisions made by the design team about future changes in the 3D hardware market that did not come true. Apple abandoned work on QD3D after Steve Jobs took over in 1998, and announced that future 3D support on Mac OS would be based on OpenGL.

OpenGL in the 1990s

The canonical 3D API of the 1990s was OpenGL. This had been written by SGI and initially closely matched the capabilities of their workstation systems, operating as a hardware abstraction layer. The OpenGL API consisted mostly of state-setting instructions for setting up drawing modes like the paint color or camera position, and system for sending geometry into the system, normally as meshes of triangles. The combination of these instructions was saved into a display list which was then rendered to produce the output.

OpenGL lacked many features that are needed to produce a complete 3D program. Saving and loading geometry data, collecting that data into groups to produce model objects, and the control of state was all left to the programmer. This was considered to be an advantage in an era when performance was limited and direct control over these sorts of functions was a route to improved performance.

However, this lack of high-level functionality did make it more difficult to quickly write simple programs, as well as leading to a lack of interoperability. A number of efforts started to provide standardized higher level APIs, like OpenGL++ and (later) Fahrenheit, which handled many of the more common bookkeeping tasks like loading geometry from files and providing a display. These standardized scene graph systems meant the programmer only had to provide the GUI for the program.

While OpenGL is mostly low-level, it did include some higher-level concepts that were only really used on SGI systems. This led to another series of APIs that removed these features to make it easier to implement on common hardware. The best known of these is MiniGL, which is not a separate API, but simply a list of those functions in OpenGL that are guaranteed to be supported across all hardware, thus ensuring that a program limiting itself to those calls will run with maximum performance.

QD3D

QD3D was designed from the start to operate on computers with considerably less power than workstations. This led to a concerted effort to cleanly separate the upper and lower layers of the API, with the lower-level RAVE system being closer to MiniGL from the start. This had the advantage of providing a clean and minimal API that could be more easily ported to different hardware.

Since only RAVE needed to be ported, the upper layer APIs could be made as complex as desired, and the QD3D system included a complete scene graph, a standardized model file format, 3DMF, and even basic GUI objects that utilized them. To write a simple application in QD3D, the programmer only had to include a few libraries and then place the GUI elements in their program using ResEdit or similar tools.

Additional functionality included a "plug-in" rendering system, which allowed an application to render a scene in a variety of styles. Without changing the model or their code, developers could render the same scene interactively or (with suitable plug-ins) using methods such as ray-tracing or phong shading.

The QD3D API was an object-like system based on pure-C code. The various structures were carefully constructed to contain pointers to other important objects. Objects knew all the drawing state they needed, thereby eliminating code that would normally be needed when developing under OpenGL.

On the downside, QD3D's layering introduced performance issues. For instance, the system stored and automatically set state for every object before drawing. This made development much easier, but also made the performance drop in a way the developer had no direct control over. Those applications demanding performance over ease of programming could instead choose to use the RAVE layer directly.

Another area of concern is that the scene graph was hidden from view, and considerable improvements in rendering performance can be made by carefully "culling" the graph to remove those objects that are not in view. Although later releases of QD3D gained the ability to automatically perform visibility culling (based on the grouping of objects in the scene graph), OpenGL's lack of support for this feature typically forced developers to implement it from the start.

Switch to OpenGL

Good low-level 3D performance relies not only on the programmer to provide efficient models, but high-quality drivers for the hardware as well. Although RAVE was designed to be cross-platform, only hardware developers which supported Mac (ATI, NVIDIA, and 3dfx) produced drivers for it. This left any comparison between QD3D and alternative APIs one-sided, as outside of the Mac QD3D was forced to fall back to a software RAVE implementation.

As OpenGL gained traction on Windows (often credited to id Software, who championed the API over D3D), hardware developers were increasingly designing future hardware against the future feature set planned for Microsoft's D3D. Through its extension mechanism OpenGL was able to track these changes relatively easily, while RAVE's feature set remained relatively fixed.

At the Macworld Expo in January 1999, Apple announced that neither QuickDraw 3D nor RAVE would be included in Mac OS X. The company laid off the development staff in June 1999[ citation needed ], replacing the in-house technology with OpenGL after buying a Mac implementation and key staff from Conix Enterprises.

After Apple withdrew support for QD3D, an open source implementation of the QD3D API was developed externally. Known as Quesa, this implementation combines QD3D's higher level concepts with an OpenGL renderer. As well as cross-platform hardware acceleration, this library also allows the use of the QD3D API on platforms never supported by Apple (such as Linux). The latest update is from 2023. [3]

Applications

Among hundreds of applications published employing RAVE are:

See also

Related Research Articles

<span class="mw-page-title-main">DirectX</span> Collection of multimedia related APIs on Microsoft platforms

Microsoft DirectX is a collection of application programming interfaces (APIs) for handling tasks related to multimedia, especially game programming and video, on Microsoft platforms. Originally, the names of these APIs all began with "Direct", such as Direct3D, DirectDraw, DirectMusic, DirectPlay, DirectSound, and so forth. The name DirectX was coined as a shorthand term for all of these APIs and soon became the name of the collection. When Microsoft later set out to develop a gaming console, the X was used as the basis of the name Xbox to indicate that the console was based on DirectX technology. The X initial has been carried forward in the naming of APIs designed for the Xbox such as XInput and the Cross-platform Audio Creation Tool (XACT), while the DirectX pattern has been continued for Windows APIs such as Direct2D and DirectWrite.

<span class="mw-page-title-main">OpenGL</span> Cross-platform graphics API

OpenGL is a cross-language, cross-platform application programming interface (API) for rendering 2D and 3D vector graphics. The API is typically used to interact with a graphics processing unit (GPU), to achieve hardware-accelerated rendering.

Carbon was one of two primary C-based application programming interfaces (APIs) developed by Apple for the macOS operating system. Carbon provided a good degree of backward compatibility for programs that ran on Mac OS 8 and 9. Developers could use the Carbon APIs to port (“carbonize”) their “classic” Mac applications and software to the Mac OS X platform with little effort, compared to porting the app to the entirely different Cocoa system, which originated in OPENSTEP. With the release of macOS 10.15 Catalina, the Carbon API was officially discontinued and removed, leaving Cocoa as the sole primary API for developing macOS applications.

In computing, cross-platform software is computer software that is designed to work in several computing platforms. Some cross-platform software requires a separate build for each platform, but some can be directly run on any platform without special preparation, being written in an interpreted language or compiled to portable bytecode for which the interpreters or run-time packages are common or standard components of all supported platforms.

Direct3D is a graphics application programming interface (API) for Microsoft Windows. Part of DirectX, Direct3D is used to render three-dimensional graphics in applications where performance is important, such as games. Direct3D uses hardware acceleration if it is available on the graphics card, allowing for hardware acceleration of the entire 3D rendering pipeline or even only partial acceleration. Direct3D exposes the advanced graphics capabilities of 3D graphics hardware, including Z-buffering, W-buffering, stencil buffering, spatial anti-aliasing, alpha blending, color blending, mipmapping, texture blending, clipping, culling, atmospheric effects, perspective-correct texture mapping, programmable HLSL shaders and effects. Integration with other DirectX technologies enables Direct3D to deliver such features as video mapping, hardware 3D rendering in 2D overlay planes, and even sprites, providing the use of 2D and 3D graphics in interactive media ties.

<span class="mw-page-title-main">Scene graph</span>

A scene graph is a general data structure commonly used by vector-based graphics editing applications and modern computer games, which arranges the logical and often spatial representation of a graphical scene. It is a collection of nodes in a graph or tree structure. A tree node may have many children but only a single parent, with the effect of a parent applied to all its child nodes; an operation performed on a group automatically propagates its effect to all of its members. In many programs, associating a geometrical transformation matrix at each group level and concatenating such matrices together is an efficient and natural way to process such operations. A common feature, for instance, is the ability to group related shapes and objects into a compound object that can then be manipulated as easily as a single object.

Fahrenheit was an effort to create a unified high-level API for 3D computer graphics to unify Direct3D and OpenGL. It was designed primarily by Microsoft and SGI and also included work from an HP-MS joint effort.

OpenGL++ was a graphics library written in C++ that supported object-oriented data structures on top of the OpenGL 3D graphics system. The project started as the result of a partnership between SGI, IBM and Intel, and later, Digital Equipment Corporation. It was intended to provide a higher level API than the "bare metal" support of OpenGL, as well as being an implementation for Java3D. Work on OpenGL++ ended when SGI decided to partner with Microsoft instead, leading to the Fahrenheit project, which also died.

Open Inventor, originally IRIS Inventor, is a C++ object-oriented retained mode 3D graphics toolkit designed by SGI to provide a higher layer of programming for OpenGL. Its main goals are better programmer convenience and efficiency. Open Inventor exists as both proprietary software and free and open-source software, subject to the requirements of the GNU Lesser General Public License (LGPL), version 2.1.

Direct3D and OpenGL are both application programming interfaces (APIs) that can be used in applications to render 2D and 3D computer graphics. As of 2005, graphics processing units (GPUs) almost always implement one version of both of these APIs. Examples include: DirectX 9 and OpenGL 2 circa 2004; DirectX 10 and OpenGL 3 circa 2008; and most recently, DirectX 11 and OpenGL 4 circa 2011. GPUs that support more recent versions of the standards are backwards compatible with applications that use the older standards; for example, one can run older DirectX 9 games on a more recent DirectX 11-certified GPU.

<span class="mw-page-title-main">OpenSceneGraph</span>

OpenSceneGraph is an open-source 3D graphics application programming interface, used by application developers in fields such as visual simulation, computer games, virtual reality, scientific visualization and modeling.

<span class="mw-page-title-main">Software rendering</span> Generating images by computer software

Software rendering is the process of generating an image from a model by means of computer software. In the context of computer graphics rendering, software rendering refers to a rendering process that is not dependent upon graphics hardware ASICs, such as a graphics card. The rendering takes place entirely in the CPU. Rendering everything with the (general-purpose) CPU has the main advantage that it is not restricted to the (limited) capabilities of graphics hardware, but the disadvantage is that more transistors are needed to obtain the same speed.

<span class="mw-page-title-main">ATI Rage series</span> Series of video cards

The ATI Rage is a series of graphics chipsets developed by ATI Technologies offering graphical user interface (GUI) 2D acceleration, video acceleration, and 3D acceleration developed by ATI Technologies. It is the successor to the ATI Mach series of 2D accelerators.

Coin3D is a free and open-source implementation (library) of the Open Inventor API. Coin3D was originally developed and maintained as commercial software by the Norwegian company Kongsberg Oil & Gas Technologies. Coin3D, like Open Inventor, is a C++ object-oriented retained mode 3D graphics API used to provide a higher layer of programming for OpenGL. The API provides a number of common graphics rendering constructs to developers such as scene graphs to accomplish this. Coin3D is fully compatible with the Open Inventor API version 2.1. Coin3D can be used to drive advanced visualization solutions in a wide range of application domains such as geo-modelling, CAD, medical visualization, robotics and presentation.

Clutter is a discontinued GObject-based graphics library for creating hardware-accelerated user interfaces. Clutter is an OpenGL-based 'interactive canvas' library and does not contain any graphical control elements. It relies upon OpenGL (1.4+) or OpenGL ES for rendering,. It also supports media playback using GStreamer and 2D graphics rendering using Cairo.

<span class="mw-page-title-main">WebGL</span> JavaScript bindings for OpenGL in web browsers

WebGL is a JavaScript API for rendering interactive 2D and 3D graphics within any compatible web browser without the use of plug-ins. WebGL is fully integrated with other web standards, allowing GPU-accelerated usage of physics, image processing, and effects in the HTML canvas. WebGL elements can be mixed with other HTML elements and composited with other parts of the page or page background.

Game Sprockets is a collection of application programming interfaces (APIs) supporting gaming on the classic Mac OS. It consisted of four main parts, DrawSprocket, InputSprocket, SoundSprocket and NetSprocket, each providing a library of pre-rolled routines for common gaming tasks. SpeechSprocket was a relabelled version of the Speech Recognition Manager that provided speech recognition support, and QuickDraw 3D RAVE provided 3D hardware acceleration.

In computer science and visualization, a canvas is a container that holds various drawing elements. It takes its name from the canvas used in visual arts. It is sometimes called a scene graph because it arranges the logical representation of a user interface or graphical scene. Some implementations also define the spatial representation and allow the user to interact with the elements via a graphical user interface.

References

  1. ↑ "3 D: What Happened To Apple?". Bloomberg. September 25, 1995. Archived from the original on June 4, 2023.
  2. ↑ "The Covert Gaming Corner - Interview: Brian Greenstone, Part 2". June 25, 1999. Archived from the original on February 16, 2013.
  3. ↑ "jwwalker/Quesa README". GitHub . Retrieved June 4, 2023.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.