Features of tinySceneGraph
Realism
|
Image Processing
|
Render realistically looking scenes through the use of GLSL shaders and
multitexturing. Use up to eight texture units to simulate material layers,
utilise cube maps to simulate reflections, write GLSL shader to achieve
effects like bump- or displacement mapping. Build-in antialiasing
techniques improve image quality, both software and hardware antialiasing
is available, permanently or on idle.
More...
|
tinySG comes with an image processing framework, allowing to do
2D image manipulation anywhere in the render pipeline. The image
processor may manipulate textures, add post processing effects or
support blending operations and image distortions on powerwalls
or dome projections.
The image processor is customisable via xml files, so new effects
can be added without any recompilation.
More...
|
Volume Rendering
|
Raytracing
|
Volumetric datasets are common in medical applications, but may
also be used in simulation (e.g. fluids) or regular OpenGL scenes.
tinySG may read raw files and uses DevIL to import Dicom datasets
or 3D tiff files.
Datasets are treated as 3D textures. Volumes are sliced depending
on the cameras view, textured and blended together. Effects may
be added through GLSL shader nodes. Volume nodes support transfer
functions and arbitrary slice planes.
More...
|
tinySG collaborates with it's companion project, tinyRT, a multicore
raytracer. tinyRT may run in distributed mode, combining MPI and OpenMP
to use available cluster resources.
Both projects share the same scenegraph data structures to ease scene
updates and safe memory. tinyRT may serve as a toolkit to precalculate
ambient occlusion, bake shadow- or reflection textures or accelerate
collision detection.
More...
|
Distributed Rendering
|
Large Datasets & Render Performance
|
tinySG is multipipe-aware and thread-safe. It may use multiple GPUs to
increase render speed on a single display or drive multiple displays
like powerwalls.
tinySG is able to drive clusters. It offers two cluster layers, based on
Equalizer (TM) or MPI. The former focuses on generic OpenGL rendering,
while the latter is specialised on raytracing and dynamic resource allocation.
More...
|
Various scenegraph nodes of tinySG implement performance features. Group
nodes may cache subtrees in display lists, geometry nodes can switch to
VBOs, texture nodes use texture objects and are able to utilise PBOs.
The render traversers do frustum culling or may issue render calls using
state-optimised render buckets.
More...
|
Stereoscopic Rendering
|
Live 3D Streaming on the Web
|
Stereoscopic images can be created with various techniques and many
different data encodings. tinySG supports the classical ones, namely
frame-sequential stereo, interleaved stereo, anaglyphic stereo and
passive stereo.
This feature gives an overview on the mathematical background and
some guidance on how to generate interesting stereoscopic imagery.
More...
|
Bringing 3D datasets to the web is not an easy task. Datasets tend
to be large and are stored in a vast number of different file/data
formats.
Recent approaches with WebGL allow 3D rendering inside a compatible
browser, but bandwidth issues, client hardware power requirements
and security concerns remain. tinySG comes with a streaming server
that renders images on the server side according to navigation
commands from the client and sends the rendered frame sequence back
to the browser.
More...
|
Is there more to say?
Yes. In short, tinySG is/has
- Cross platform: tinySG builds on Windows XP, Windows7, Linux and Irix,
32bit or 64bit.
- Quiet fast. Other scenegraphs like OpenSceneGraph
or sceniX are still a bit faster than tinySG on the majority of scenes, but
the gap is getting close and sometimes even in favour for tinySG.
- csgEdit2. Modify your scenes, add effects, tune render performance. This tool
works at the bloody guts of tinySG.
- SDK/Module interface. Write your own importers and exporters, renderers, optimizers,
or whatever you may have in mind.
- Build-in stereo support through Equalizer: Quad-buffered, passive or anaglyphic
is available without any code change.
- csgBatch optimiser. Use this plugin to csgEdit to reorder, tune and optimise
the scenegraph structure to achieve higher frame rates.
tinySG's basic architecture
tinySG follows a module approach and strictly separates libraries from
applications and rendering code from data processing code. It introduces
as little dependencies to external libraries as possible, keeping the
build system simple. In fact, the only required external libraries
are glew
and boost::smartptr.
In addition, the
build system may be configured to use boost::threads and
OpenMP to parallelise the render code
and some algorithms. Finally, libcsg will also dynamically bind the
devIL image library at runtime
if found in the applications directory.
At the very bottom of the dependency graph are OpenGL and the GL wrangler
library, managing OpenGL extensions. On top, libcsg is the core of tinySG,
as it provides the scenegraph nodes, all the OpenGL-based render code as well
as basic functionality like picking, selections, node conversions or
animations.
libcsg's companion library, libcsgu, is a collection of utilities, offering
geometric algorithms like Catmull/Clark or N-Patch surface subdivision, scene
tree transformations like flatten transform, generic traversers, shadow
generation and texture baking, half-edge topologies, generic threading and
thread pools and finally a complete X window interface supporting multipipe
operations and event handling on Linux and Irix.
A bunch of loaders is implemented in another set of shared libraries, namely
basic support for tinySG native (I/O), vrml (I), OpenInventor (I/O), 3Dmax object (I),
Lightwave object (I) and Stanford Ply (O).
Applications sitting on top of these libraries include tinySG's scene editor,
csgEdit, a thin scene viewer, csgView, a command line renderer
inspired by perfly, csgfly, a cluster version of csgfly based on
Equalizer, as well as some
demo applications like the
San Jose Ball Machine or tinyPresenter.
Last but not least, tinySG comes with an SDK as the foundation for a number of
plugins, most importantly:
- assimp: csgEdit dynamically binds a model
loader based on assimp
if present in the application directory. This provides import capabilities for over
30 different 3D file formats.
- netCDF: A plugin
to import netCDF data and process it for different render techniques, like mesh
representations, color-coded texture data or particles.
- Voxeliser: This plugin converts any scene into a
voxels, stored in a
3D texture. It is the foundation for other modules, like particle collision
detection or
computational fluid dynamics.
- crtPlugin: The interface to
libcrt, the raytracer library on top of libcsg.
This plugin is able to hijack csgEdit's viewer windows and replace their OpenGL
rendering with it's own raytracing algorithms.
- Python bindings: A swig-generated layer on the SDK allows to animate
scenes or automise tasks using Python scripts.
- batchPlugin: A plugin providing batch driven scene tree optimisations,
node conversions, normal calculation and restripping/remeshing. Multicore-capable.
- plyExporter: Exports tinySG scenes to Stanford ply format.
|