A generic rendering system

J. Dollner, K. Hinrichs
2002 IEEE Transactions on Visualization and Computer Graphics  
We describe the software architecture of a rendering system that follows a pragmatic approach to integrating and bundling the power of different lowlevel rendering systems within an object-oriented framework. The generic rendering system provides higher-level abstractions to existing rendering systems and serves as a framework for developing new rendering techniques. It wraps the functionality of several, widely used rendering systems, defines a unified, object-oriented application programming
more » ... nterface, and provides an extensible, customizable apparatus for evaluating and interpreting hierarchical scene information. As a fundamental property, individual features of a specific rendering system can be integrated into the generic rendering system in a transparent way. The system is based on a state machine, called engine, which operates on rendering components. Four major categories of rendering components constitute the generic rendering system: shapes represent geometries; attributes specify properties assigned to geometries and scenes; handlers encapsulate rendering algorithms, and techniques represent evaluation strategies for rendering components. As a proof of concept, we have implemented the described software architecture by the Virtual Rendering System which currently wraps OpenGL, Radiance, POV Ray, and RenderMan. This section discusses related work. We briefly summarize the characteristics of standard rendering systems and analyze the major limitations of their software architecture. Rendering Systems White-box rendering systems document their internal design and provide access to their implementation. In general, they are delivered as libraries or frameworks, which can be extended and redesigned. Black-box rendering systems, in contrast, hide their software architecture and can be used exclusively through a well-defined programming interface such as a scene description language. Gray-box rendering systems do not give full access to the system's design and implementation. In general, developers can extend at least some parts of a gray-box system, for example, by implementing derived classes. A detailed reference for object-oriented and component-oriented software engineering can be found in Szyperski [36] . Vision [32] provides an extensible white-box framework for implementing rendering techniques focusing on global illumination calculations. The Vision architecture completely separates geometry objects and their attribute objects using object-oriented design even at a low level in the system architecture [31] . In our work, the separation between geometric primitives and attributes has been extended: The generic rendering system provides a generic attribute management for handling rendering-system dependent and rendering-technique dependent attribute types. In addition, we separate rendering algorithms from shape classes and attribute classes. Furthermore, we provide a generic concept for evaluating scene graphs. GRAMS [11], an object-oriented white-box rendering framework, appears to be the first system explicitly supporting different rendering techniques (e.g., real-time rendering, ray-tracing). It distinguishes between a rendering layer and a graphics layer. This separation ensures that new functionality can be added to a layer without altering the other layer. The GRAMS architecture separates rendering algorithms from geometric primitives. Rendering algorithms are selected for a target low-level rendering system using rendering efficiency as criterion [12] . The generic rendering system extends the separation towards algorithms evaluating attributes and multi-pass rendering techniques. Generic3D [4] defines an extensible, object-oriented white-box rendering library. It consists of a collection of classes which can be combined and subclassed to implement application-specific rendering systems, so called customized graphics kernels. Generic uses OpenGL for real-time rendering, but does not support any other third-party rendering system; it is intended as a framework for implementing new rendering systems. The BOOGA project [1] develops a white-box component-based software architecture for graphics applications. The system defines three layers, a basis layer, a framework layer, and a component layer. The system provides a high degree of extensibility because each layer can be extended independently using inheritance or template instantiation. For example, the evaluation strategy for scene graphs is based on the visitor design pattern and implemented by so called renderer components. OpenInventor [33] represents a sophisticated object-oriented rendering library for interactive 3D graphics designed as a gray-box system. It has introduced the classical concept of a scene graph, which has been adopted by many other systems (e.g., Java3D). As a common characteristic, order and arrangement of rendering primitives in the scene graph reflect the order in which rendering primitives are sent through the rendering pipeline. OpenInventor concentrates on real-time rendering and does not support other low-level rendering systems or rendering techniques (e.g., photorealistic and non-photorealistic rendering). Java 3D [35], a gray-box rendering library, defines classes for graphical attributes and geometric objects focusing on real-time computer graphics. Java 3D's high-level constructs (e.g., scene graph, view model based on physical body and physical environment, geometry compression, spatial sound etc.) are designed for constructing virtual worlds and are well suited for interactive 3D graphics. Java 3D defines a core set of shapes but does not permit one to add new types of shapes unless they are
doi:10.1109/2945.998664 fatcat:fpdnzm3cpraubpskblyf6ehspu