Runs on all platforms

Redsdk is natively supporting 32bit or 64bit operating systems.

Redsdk runs on all Windows platforms:
• Windows 2000
• Windows XP 32bit
• Windows XP 64bit
• Windows Vista 32bit
• Windows Vista 64bit

Redsdk runs on all x86 based Linux platforms:
• Fedora 32bit
• Fedora 64bit
• Other Linux distributions are certified on demand

Redway3d can consider a MacOS portage based on customer's request. Contact us for more details.

Load balancing

Redsdk computes all images based on the available processing power. Redsdk is able to leverage all parts of a computer:

• Single or multi-GPU configurations (SLI or Crossfire)
• As many CPU cores as available thanks to multi-threading.

Real-time 2d and 3d renderings can be calculated on the GPU or on the CPU, as specified by the application. Photo-realistic images are calculated on the CPU and accelerated by a GPU when available and specified to do so.

Therefore, on most modern computers that are equipped with multi-core CPUs and at least one graphics card, Redsdk is able to show impressive rendering performances.

Leverages all available GPU acceleration

Redsdk takes advantage of all available GPU acceleration when a graphics accelerator is available in the host computer.

Supported graphics accelerators include:
• NVIDIA® Quadro FX 1000 & up
• NVIDIA® GeForce FX & up
• NVIDIA® GeForce 6, 7, 8 & up
• AMD-ATI Radeon 9500 & up
• AMD-ATI Radeon X, HD 2000, 3000, 4000
• AMD-ATI FireGL X
• AMD-ATI FireGL V 3000 & up
• INTEL® Integrated graphics series: GMA 3000 & GMA X3000 (GMA = Graphics Media Accelerator)

Redsdk runs in CPU mode with all rendering features available when no graphics accelerator is available.

Advanced lighting

Redsdk delivers a set of built-in per-pixel lighting models:

Ambient
• Lambert
• Phong
• Blinn
• Anisotropic (BRDF)

In addition to that, several other shaders complete the base lighting toolbox:
• Vertex color
• Environmental cube mapping (with dynamic cube maps updates)
• Contour detection
• Image filtering
• Text rendering
• Cartoon shading
• Etc…

Redsdk delivers a programmable shading pipeline that can be used to integrate any existing shader or to create new ones using existing shading languages (ARB, GLSL) or from the shading code generated by 3rd parties tools (Render Monkey, CG Fx, …)

The Redsdk integrated rendering pipeline offers a hierarchical rendering pass compositing system that can be used for the rendering of complex shading trees, with no limit in rendering depth, as well as un unlimited number of lights.

Redsdk provides many built-in light models:
• Ambient lights
• Point (although called omni) lights
• Spot lights
• Directional lights
• Beam lights
• True area omni or spot lights (based on area sampling)

Advanced shadowing

Redsdk integrates different kinds of shadowing techniques that can be divided in two categories: real-time (hardware GPU based) and ray-tracer based.

Real-time shadow maps are available for all kind of lights. Redsdk renders different kind of shadow maps:
• Colored shadows
• Alpha masked shadows
• Soft or blurry shadow maps (using variable size Gaussian blur kernel filters). Soft shadow maps greatly increase the quality and realism of the resulting image while still rendered interactively.

Ray-tracer based shadows are available for all kinds of lights. Redsdk’s ray-tracer delivers different kinds of shadow casting methods:
• Transparent object colored shadows
• Colored shadows
• Alpha masked shadows
• Centric or directional shadows (sharp shadows)
• True soft area shadows through area sampling

Real-time shadow maps with masking are displayed in the top image and ray-traced area shadows including colored shadows in the bottom image.

Scene graph

Redsdk uses an advanced scene graph description of the data to be visualized. Multiple instances of a reference geometry are managed thanks to the Direct Acyclic Graph (DAG) paradigm.

Redsdk offers the necessary functions to control the amount of memory used by the GPU by loading or unloading data from the GPU.

Layers are available for materials, geometries, lighting and ray-tracing properties. Layers are visualization filters used to control the scope of every rendering pass and engine algorithm.

Redsdk delivers all useful and usual base rendering primitives:
• Meshes
• Lines
• Cloud of points
• Unicode texts, rendered in 2d or 3d, based on textured quads, lines or triangular meshes

Redsdk is able to share geometrical data coming from another source without duplicating it, greatly improving the system scalability and performances. Redsdk’s rendering pipeline is highly customizable; entry points are opened at different stages of the culling process enabling the integration of users custom culling algorithms (PVS, occlusion culling, LODs or scene dependent algorithms).

Viewport interaction tools

Redsdk delivers several packaged tools and rendering features that increase the visual feedback and overall productivity in the viewport of a data creation tool, while modeling, editing scene data or during the scene setup.

First, Redsdk’s picking tool with a selection area is a must have for the selection of small entities in a graphics representation: lines, points, texts and mesh elements are easily selected.

Redsdk returns immediately all information on all selected elements: scene graph paths identifying object instances, selected elements, distance sorting of the picked results, etc…

Thanks to its real-time edge and contour rendering shaders, hidden line removal (HLR) rendering is performed in full real-time, even on the largest assemblies. HLR and edge rendering (for example for selection and highlighting) add the necessary information over raw geometry for all data interaction tasks in an edition tool.

Redsdk is able to render per-pixel correct transparencies in real-time. Compared to traditional hardware rendering techniques that are not accurate and usually slow, the rendering of exact transparencies improves the visual feedback needed to understand complex assemblies with overlapping parts.

Finally, thanks to the integrated “all-in-one” Redsdk rendering technology, all rendering tasks (2d, 3d, real-time and / or ray-traced) can be performed “in context” in a single working window, thus saving space on the working screen and improving the host application efficiency, providing an immediate and integrated feedback.

Application tools

Redsdk runs in any multiple windows or screens rendering application. In each rendering window, any number of cameras can be layered, each with its own scene graph resulting in an unconstrained organization of a window’s contents. All graphics data in all cameras, windows and sreens are shared to maintain an optimal memory footprint for the whole application.

Redsdk can although use windows of an existing application and add its own rendering code over an existing code. This is detailed in the ‘smooth integration workflow’ paragraph later on.

On the right, a .NET integration sample distributed with Redsdk.

Full HDR rendering pipeline

Unlike common 3d rendering engines that render all images with 8 bits values for each R, G, B, A component, Redsdk is able to render all images with 32 bits floating point values for each component.

This result in a greater image quality and no more blending artifacts that otherwise appear with the limited 8 bits display precision.

This 32 x 4 = 128 bits floating point display is available for GPU accelerated renderings on all GPUs (even the oldest supported graphics cards) and of course for all CPU based renderings.

On the right side picture, a real-time ambient occlusion dome mapping without HDR being enabled, showing blending artifacts. The same ambient occlusion dome with HDR enabled, at the same real-time performance.

Volume rendering

Redsdk’s API offers all the necessary tools to implement any kind of volume visualization algorithm. 3d textures using all existing hardware formats can be loaded by Redsdk directly on the GPU for a hardware accelerated rendering.

For example, slice based display techniques can easily be implemented, as demonstrated in Redsdk’s tutorials. Then custom shaders can render any kind of lighting equation applied to volume data sets.

On the left: navigation in real-time in a CT scan data cube using a slice based rendering technique and a luminance to color transfer function table (LUT) to visualize bones and tissues.

Ray-tracing

Redsdk’s GPU accelerated ray-tracer is a patented technology.

By default, Redsdk will use any available GPU to reduce all ray-traced image calculation time. However, Redsdk’s ray-tracer is able to fully run on a computer that has no graphics card.

Ray-tracer effects include:
• True reflection & refraction effects based on material properties, including bumpiness and Fresnel based energy conservation rules
• All kind of shadows, ray-traced hard or soft shadows can be generated for all kind of lights. True area sampling is available
• Real-time ray-traced transparency. While running in GPU mode, per-pixel exact transparencies can be calculated in real-time
• Glossy material rendering effects: true fuzzy reflections and refractions effects are possible and greatly improve the image quality

Redsdk’s ray-tracer is 100% dynamic: every object in a scene can be moved and can be freely modified. There’s no performance penalty for an update of the ray-tracer acceleration structure.

Scalability

Redsdk is using cutting edge performance technology available from the GPU and from the CPU world. As a result, Redsdk is able to load massive geometrical models and display them in real-time.

Up to 60 million unique triangles can be rendered in real-time with per-pixel lighting and effects on common graphics cards with 1Gb of memory. Many more triangles can be displayed if geometry instances are used in the scene.

Redsdk is able to share its source data with an external source. This means that it can be integrated within an existing application without duplicating any existing data that has to be kept alive already.

On the left side picture, around 100 million triangles in 200,000 locomotive parts are rendered at an interactive frame rate.

Material library

Redmaterials is a complete material library available aside from Redsdk. This material library contains pre-defined common materials that save a lot of setup time for all Redsdk users.

All materials in this library are available with different versions:
• Photo-realistic quality: this version uses all the advanced rendering capabilities delivered by Redsdk for the best rendering result
• Real-time quality: this version of the material displays in real-time while its still sensitive to all kind of lighting and shadowing effects that can be rendered by Redsdk

In addition to that, several materials are specifically designed for simulation needs: these materials are rendered on screen as fast as possible. It’s a performance / quality trade-off focused on 60 Hz display performances.

Many materials are available:
• Metals: aluminum, brass, chrome, copper, steel, titanium, etc …
• Plastics: PVC, carbon, etc …
• Pattern materials: stones, tiles, etc …
• Woods: cedar, cherry, oak, walnut, etc …
• Glass: generic glass with customizable IOR, color, etc …
• Fabrics: wool, linen, leather, alcantara, etc …

Smooth integration workflow

It’s a key strength of Redsdk as we deliver all needed tools to integrate Redsdk painlessly inside an existing 2d or 3d application. Redsdk is able to initialize itself from an existing application window, sharing resources and rendering context with it.

Therefore, Redsdk’s rendering code can be added to an existing rendering code: this means that the host application never has to be broken to integrate Redsdk. New rendering features can be integrated smoothly over the time without having to go to a major breaking migration step as Redsdk will co-exist with any existing solution for as long as needed.

Data sharing with an external model is although a key feature in this integration workflow as Redsdk can be setup based on existing data, without any duplication, thus greatly improving the scalability of the application.

File format

Redsdk proposes an optional file format called the ".red". This file format that has been designed for high performance data streaming and extensibility offers several interesting features to our customers:
• Can be integrated into another file format
• Multi-threaded loading resulting in a greater loading performance
• No startup latency on first frame
• Optimized lossless data compression schemas for each kind of data
• Data encryption
• Animation support
• Extensible chunk based architecture: users can add their own data containers into a .red file
• Cross platform
• Accurate loading progress indicator

Import your data

Redsdk does not deliver any file importer natively. However, thanks to its Redviewer DCC plug-in, any file format that can be loaded by Autodesk® 3dsMax® can be exported in “.red” toward Redsdk.

Then files of the following kind can be loaded inside Redsdk through 3dsMax®: 3DS, DWG, DXF, FBX, IGE, IGS, OBJ, WRL, STL, etc …

On the left, Redviewer toolbar and export option panel natively integrated in Autodesk® 3dsMax®.

Explore your data

Thanks to the REDExplorer add-on product, delivered with Redsdk, anyone can visualize .red files navigate inside large model assemblies, take snapshots, replay animations and make movies.

Some features of REDExplorer at a glance:
• Edit camera parameters
• Change lighting parameters: colors, intensities, shadowing, etc …
• Models can be freely merged and removed
• Replay animations
• Take snapshots
• Navigate in real-time in the viewport window
• Make high quality renderings in the film window

Programming features

Redsdk manages a set of functionalities enabling the developer to focus on added value tasks. The set of C++ classes that makes Redsdk is fully documented. There is no complicated hierarchy of classes and performance is achieved by paying attention to the application side.

Major programming features are:
• Fully documented object oriented code written in C++. 300 pages of "programming guide" describing all Redsdk concepts including 40 detailed tutorials with source code
• A complete "hardware reference guide" that lists all supported cards, recommended driver versions, known driver issues for each supported operating system and service pack
• A "high performance rendering guide" that give an insight on Redsdk’s internal rendering technology and that explains how to use Redsdk to reach an optimal rendering performances for a given application considering a given quality level
• Open architecture: custom memory allocators can be used, custom file management tools can be used, easy integration in a third-party or in-house application
• Multi-threaded engine
• Memory leak tracking and analysis tools
• Unicode

Redsdk test suite

Redsdk is always delivered with a Redsdk test suite for all Redway3d partners. Redsdk test suite is a set of automated rendering tests aiming at validating the behavior of Redsdk on a given platform.

The Redsdk test suite is also used by all GPU vendors for driver certification: NVIDIA®, AMD-ATI and INTEL®, thus providing a better driver stability for applications based on Redsdk.

The test suite although return rendering time measurements that can be used to estimate the overall performance of a given platform.