RenderMonkey™ Toolsuite - IDE Features
Application Design and Philosophy
Real-time high performance
shaders are at the heart of all new visual
effects and they will continue to be the foundation of an amazing
graphical experience for the future. The RenderMonkey IDE has been
created to fill the need for shader content creation tools in a
coherent environment—flexible and powerful for programmers, yet familiar
and intuitive for artists. With the introduction of the DirectX, OpenGL and OpenGL
ES high level shading languages, the complexity of real-time shaders has increased. The
rapid evolution of the shading capabilities of graphics hardware had caused an
explosion in the the amount of shader content necessary for real-time graphics
projects, fueling the need for a powerful real-time shader IDE. The RenderMonkey
environment not only allows easy shader prototyping and development, but also
provides a mechanism for managing the shaders and all of the associated visual
resources in a single environment.
Standard Graphics APIs
The RenderMonkey IDE enables shader production on any hardware
supporting standard graphics APIs—the latest release of the RenderMonkey IDE provides integrated support for DirectX 9.1, OpenGL 2.0, and OpenGL ES 2.0.
Programmers and Artists
RenderMonkey has been designed to meet the needs of programmers and artists,
allowing both to collaborate on shader effects. Separate interfaces exist
in RenderMonkey for programming by technical shader developers as well as
purely visual modification by non-technical
artists. RenderMonkey allows anyone interested in creating shaders
to dive straight into the shader creation process.
The program allows the structure of an effect, including the body of the shader
and all assets, to be visualized
in a tree structure. Users
can view the gradual build-up
of an effect by examining individual
rendering passes in the application’s rendering windows or by dynamically
the contents of all renderable textures. RenderMonkey enables quick
debugging of shaders via interactive output of intermediate results computed
by the shader. This can be particularly useful in teaching environments
where visualizing an intermediate result is fundamental to understanding.
RenderMonkey has been chosen by several universities to teach shader technology
The application includes a variety of convenient features which give programmers
fine control over their development environment. Optimization
hints are included to aid in the analysis of shader performance,while both
artists and programmers have access to familiar and intuitive GUI widgets for
interactively editing parameters to shaders. The visual results of these modifications
viewable on the integrated rendering preview window.
Integrating Into Existing Production Pipelines
RenderMonkey makes adoption of shader technology easier for both developers and
artists, providing easy integration into existing workflows and the ability to
customize desired components to suit the needs for any production. Studios using
RenderMonkey can rapidly prototype shader effects in the early stages of a project,
enabling key visual effect decisions to be made sooner, and thereby improving
final look of any product with minimal impact on schedules.
RenderMonkey can be easily customized and integrated into any
developer’s regular workflow through the use of the RenderMonkey SDK. The application ships with a standard
set of plug-in examples and also contains a plug-in wizard, enabling easy creation
of custom components. The SDK gives developers full access to the entire run-time
database of shader data. The SDK is written in standard C++ with all of the necessary
components for plug-in development. It also provides libraries for user interface
widget creation to allow developers to maintain the look and feel of the application
significant effort into UI development.
For each shading language supported by RenderMonkey,
there is an associated shader editor with user-customizable
syntax highlighting. Users can customize
text editing settings, such as font, keyword colors
and tab inserting / spacing via the shader editor preferences.
The shader editors provide users with integrated
compilation error reporting - mapping errors to the corresponding line
in the source code.
The DirectX shader editors also aid shader development with a set of convenient optimization
Use Engine-driven Shader Parameters in RenderMonkey
Edit Shader Parameters Using Convenient GUI Widgets
Developers must use engine parameters in
shaders in order to write shader-based effects for any real-world
application. Frequently used engine-driven parameters are,
for example, transformation matrices, time, random numbers etc. RenderMonkey
provides a number of predefined variables that allow this engine
specific behaviour to be replicated in RenderMonkey. To simplify
integration, the names of the predefined variables can be customized
match those used in the engine. Support is included for nearly 80 different
engine-driven parameters, such as a full set of transformation matrices (including
inverse and transpose matrices), mouse parameters, randomly generated variables,
camera parameters, geometric object data etc. By default, the RenderMonkey
semantics match the variable annotations for the latest version of the Microsoft
FX file format (0.8)
| All shader parameters in RenderMonkey
can be edited using intuitive
GUI widgets associated with the parameter type. The users
can edit colors using a color wheel widget, scalar, and vector
variables with convenient numeric sliders, modify texture / sampler
states while previewing texture surfaces associated with those
texture stages and many more.
Advanced Feature Set for DirectX Effect Creation
RenderMonkey version 1.71 supports the latest version of DirectX 9.1 and includes support for all available shader models. Developers can create effects that use multiple render target support, which allows
for a variety of interesting algorithms, such as deferred shading, to be used.
Each draw call in a DirectX effect of RenderMonkey can output to up to 4 separate
render targets at a time (Note that you must use shader model 2.0 or higher
for this functionality).
Additionally, developers can set up any back
buffer and depth / stencil buffer formats for rendering, specify
multisampling type for the rendered effect and control
color and default camera settings.
Shader programmers can also use HLSL
include files for DirectX shader development. RenderMonkey ships with
a set of useful library functions that developers can use in their shader
development (HLSL include files “RmInclude.h” and “RmMath.h” located
in the directory UserData/HLSLIncludes). Developers can set up the
include path in the style similar to the Visual Studio
project include path.
RenderMonkey ships with a .FX file
format exporter. This supports the latest version of the Microsoft Standard
.FX annotations (0.8). The exporter minimizes name space collisions for easier
compilation and integration of effects. RenderMonkey also outputs appropriate
UI annotations for each RenderMonkey variable and associated parameters (such
as min/max clamping bounds for scalars, etc), thus allowing better integration with the Maya preview plug-in shipped with the latest Microsoft DirectX 9.1 SDK for XNA preview pipeline.
Generate New Look-Up Tables and Geometric Objects to Suit Your Needs
The RenderMonkey IDE provides standard plug-ins for procedural texture
generation. Programmers and artists can specify functions in HLSL to procedurally
generate 2D textures, cube maps and volume textures. The newly generated textures
can be previewed dynamically via the texture
preview mechanism and/or saved to file for later use. This allows very easy
creation of texture look-up
tables for any effect. RenderMonkey also allows users to save the contents
of any renderable texture to file at any point. Thus anything rendered in the
preview window can also be saved as a look-up texture or for any other additional
purpose (such as shader debugging).
Similarly, RenderMonkey provides several plug-ins for geometry
object generation. Users can generate any basic geometric
shapes using modifiable parameters. The generated objects can
also be saved (in the .X file format) for later use. RenderMonkey
allows automatic generation
of edge quads for any model. This can be used for shadow
volume generation or for fur fins.
|To generate a procedural texture or
geometry model, the user selects from a list of available generator
plug-ins and specifies parameters for the plug-in. The data can
be saved to either texture or model files via the "Save…" menu
for each node. If the user doesn't save procedurally generated
data, its parameters (for example, texture shader or geometry parameters)
are saved along with the node and the data will be regenerated
upon workspace load.
Procedural geometry and texture data is available for use for DirectX, OpenGL and OpenGL ES workspaces.
Shaders and Performance Tuning
Interactive preview with full error reporting
| The DirectX, OpenGL, and OpenGL ES preview windows respond immediately to any changes to the database while rendering effects. This means
that editing any shader parameter instantly modifies rendering
in the preview window, making it very easy to iterate on the effect’s
look and feel.
|The preview window also provides automatic
error reporting for any invalid or missing resources
required to render the current effect. Examples of this type
of error include: rendering an effect which has a constant not
bound correctly to a RenderMonkey variable node; attempts to
render using an invalid stream map, missing geometry objects
or textures, invalid render target.
For these errors, an error message is displayed in both the output window and
also overlaid on the preview window. The example image shown on the left displays
an error because a geometry object is missing for one of the draw calls.
RenderMonkey also initializes renderable textures
to green to notify the developer if they are used before being primed,
therefore contain garbage information.
Know What the
Algorithm is Actually Doing – Easy Ways to Determine When Things
There are many different ways to debug
a shader algorithm in RenderMonkey. The simplest way is to just output
a desired quantity as resulting color to the preview window (for example,
view vector as
colors). The interactivity of RenderMonkey’s shader development and preview
pipeline makes this a very simple and intuitive debugging
For multipass effects, users can select pass build-up preview mode by pressing “p” in the preview window (this feature is available for the DirectX, OpenGL and OpenGL ES preview pipelines). Each individual pass is rendered to a small viewport
in the preview window. The results of previous passes are composited
|If a draw call renders to a render target or
multiple render targets, the contents of each render target will be displayed
in a separate viewport. This technique is useful both during the creation
of multi-pass effects, and also in educational environments to help explain
the algorithm to students. It also aids in quick debugging as it
is quite easy to see if individual draw calls output erroneous results
or are composited incorrectly.
Renderable Textures Contents
Shader developers can also preview the contents
of their offscreen buffers in different ways while creating shader-based
effects in RenderMonkey. The contents for any renderable texture used by the
active effect can be previewed by simply right-clicking on the renderable texture
node and viewing the thumbnail for that texture. The thumbnail can be expanded
to view the entire texture with all relevant texture information (size / format)
displayed and a separate thumbnail exists to preview the contents of the alpha
channel of that texture. The user also has an option to save the contents of a renderable texture into a
file by using the "Save" context menu option for that renderable texture
In order to preview the contents of a renderable texture,
the users can use the pass
The other option is enabled by pressing "r" in the preview window. This preview
option allows the user to dynamically view
the contents of each renderable texture used in the final effect.
contents are displayed in the state that they will be after the execution of
the final draw call in the effect. This way it becomes very simple to view, for
example, the contents of a shadow map, as the user rotates the camera around
in the preview window.
Fine-tune Shader Performance
During any shader development, there comes
the time when we want to optimize the
performance of the shader.
The RenderMonkey IDE aids developers in several ways.
During rendering in the OpenGL, OpenGL ES and DirectX preview window, developers have access to frame statistics during each frame rendering. Pressing "s" in the preview window, displays
the frame rate for the currently active effect as well as additional statistics
for all draw calls included in the rendering (number of primitives and
number of vertices).
Developers creating DirectX HLSL shaders can also view a
disassembly of the compiled shader. The disassembly includes
an integrated ALU and texture ops
instruction counter. This can be used to fine tune high level
algorithms to generate optimal code.
Managing Effect Data
RenderMonkey stores all settings and data necessary to encapsulate the effect
in an extensible XML
workspace file. The users can manipulate this effect data when loaded
into RenderMonkey via a convenient view into the effect database called the workspace
tree view. The workspace editor can be used to access all elements, or nodes,
in the workspace, for editing or viewing
To make creation of texture and geometry objects in RenderMonkey more streamlined,
the application will scan user-defined default texture and model
repository directories at run-time for all supported texture and geometry
object formats and compile a list for quick addition of new texture / model nodes.
The location of the default data repository can be customized by the user via
the application preferences dialogue.
||RenderMonkey makes extensive use of informative
tooltips, making viewing the contents of a node as simple as moving
the mouse cursor over the nodes. Node specific data is displayed
in the tooltip, such as the number of primitives and vertices in a geometry
object; renderable texture dimensions and surface format; or renderable
states set and their values for a render state block.
RenderMonkey remembers user preferences
for window placement and sizing and stores that information per-workspace.
This, with the improved docking window support, allows the users to customize
the IDE exactly to their liking. The users can also select from a number
of application settings for the main application and selected plug-ins (for
example, the text editor may be customized to allow user specified tabs,
fonts etc. ). The application will remember user
preferences for the last plug-in editing a particular node type. This
way if the application has multiple plug-ins that can edit the same node
type, the users don’t have to go through the steps of repeatedly selecting
a non-default plug-in editor. The application will remember the settings
and automatically select the appropriate plug-in the next time the user edits
To facilitate sharing of shaders amongst developers, RenderMonkey IDE now provides
a package import /
export capability. Any effect workspace can be exported to a single
zip file that contains all of the textures and models necessary to render
These packaged workspaces can be easily imported back into RenderMonkey
without requiring any subsequent modifications
to fix up geometry & texture paths.
Involving Artists in the Shader Creation Process
Creating shader-based effects in real-time should not be the sole domain of programmers.
Artists are intimately involved in the process, often from the intial prototype
stage. RenderMonkey provides several interfaces and tools which are artist focused
to help artists
collaborate in the shader creation process.
Artist interfaces in RenderMonkey
A shader developer can mark certain variables in the shader effect workspace
as “artist-editable”. An
artist working on this effect can then filter their view of the effect (using
the Art tab - ). This will restrict the artists view of
the workspace to display only those variables. The variables can then be
edited by the artists using the standard GUI widgets. If necessary,
the developer is also free to customize these widgets using the SDK to include
that more closely match those used
by the artists in other tools.
|| RenderMonkey also includes an Artist Interface plugin - which includes
all of the artists editable parameters in a single interface. The appearace
of this plugin should be familiar to artists who have used standard DCC
applications such as Maya and 3DStudioMax.
| The artists can use color wheels and scalar
sliders in a single page interface. As with all of the editors, all changes
are immediately reflected in the rendering window.
Easy Texture / Model Resource Management
Using textures in RenderMonkey is very simple and convenient.
The creation of new texture nodes is intuitive with the use of default
texture repository directories and quick access menus (as described here). Once the user has created a texture
node, to view the texture image stored in that node, the user has to
simply right-click on the node and view the displayed image
thumbnail for the texture surface.
RenderMonkey provides an option to view the texture as a full size image in a
large thumbnail with all relevant texture information (size / format) attached
and the contents of the alpha channel stored in this texture.
If the user clicks on the large thumbnail of the texture, RenderMonkey
will launch an associated editor application
for that texture image.
The user can specify their preferred
application (e.g. Photoshop) which will be used whenever the user
edits the texture by clicking on its thumbnail. A similar mechanism exists
For users who used external editors for models & textures, RenderMonkey
supports the ability to automatically reload these files whenever they have
user can select to turn
on automatic update of textures and
models, and then RenderMonkey will automatically reload textures and
rebuild geometric objects’ data whenever the associated files change on disk. Alternatively,
can do this manually on-demoand by pressing “t” or “m” in
the preview window. This will cause RenderMonkey to reload all resources
from files and rebuild all run-time resources for the
- Supported Geometry and Texture Formats:
- Support for floating texture surface formats via DDS import
- Standard texture file formats supported: BMP, JPEG, TGA, GIF, PNG, NMF (ATI
- Geometry file support: 3DS, OBJ, X, NMF
Custom Component Creation
RenderMonkey ships with a plug-in SDK that allows developers to extend the existing
capabilities of this powerful IDE to suit their needs. More information on can be found in
COLLADA OpenGL Effects Exporter and Mesh Importer
OpenGL effects can now be exported from RenderMonkey in COLLADA 1.4.1 format. The exporter outputs geometry, shaders, and the texture assets using COLLADA 1.4.1’s profile_GLSL. It is possible to view the COLLADA output using the COLLADA OpenGL Effects Viewer that we provide on the download page. This is a Windows-based binary plug-in for OpenSceneGraph 2.2 . Also included in the download is the Open Source code for the viewer and instructions on how to build it.
RenderMonkey also has a new geometry importer that will load triangle meshes from COLLADA 1.4.1 documents. This is an ideal way to load COLLADA geometries and prototype COLLADA effects for your content pipeline.
More information about COLLADA can be found at: