We present a novel wavelet method for the simulation of fluids at high spatial resolution. The algorithm enables large- and small-scale detail to be edited separately, allowing high-resolution detail to be added as a post-processing step. Instead of solving the Navier-Stokes equations over a highly refined mesh, we use the wavelet decomposition of a low-resolution simulation to determine the location and energy characteristics of missing high-frequency components. We then synthesize these missing components using a novel incompressible turbulence function, and provide a method to maintain the temporal coherence of the resulting structures. There is no linear system to solve, so the method parallelizes trivially and requires only a few auxiliary arrays. The method guarantees that the new frequencies will not interfere with existing frequencies, allowing animators to set up a low resolution simulation quickly and later add details without changing the overall fluid motion.

This code is a reference implementation of our paper Wavelet Turbulence for Fluid Simulation. The code is intended as a pedagogical example, so clarity has been given preference over performance. Optimizations that inhibit readability have been removed, so the running times experienced will be longer than those reported in the paper.

Home Page: http://www.cs.cornell.edu/~tedkim/WTURB
Project Page: http://www.cs.cornell.edu/~tedkim/WTURB/source.html
Language: C++
Platform: Linux, Windows, OS X
License: GNU Public License
Sponsor: Cornell University

The RmanPtcSop project is a Houdini geometry operator (SOP) for loading and displaying RenderMan point clouds. It is based on the open source dnPtcViewerNode project from Double Negative Visual Effects.

Features of the rmanPtc SOP include:

• Independent control for limiting the number of points loaded and displayed.
• Geometry output for all point attributes in the cloud.
• OpenGL display preview for attributes as point or disk primitives.
• Ability to cull points based on a reference bounding box.

Home Page: http://danbethell.github.com/rmanptcsop/
Language: C++
Platform: Linux, Windows, OS X
License: New BSD License

JupiterFileCache (JFC) is a general purpose, multi location, multi process, thread safe file read & write cache library.

This is a C++ library that allows caching files in remote (network) locations onto the local client to speed up future accesses to these files. This reduces network traffic, but also, more importantly disk access, on the server. Modern network infrastructures are rarely the problem, but a server’s disks often don’t cope well when hundreds of clients read large files, often repeatedly, by querying small pieces of data, all at the same time.

It comes with a SWIG interface to be easily accessible through scripting languages (e.g Python) without the need to use a C++ compiler.

RSL shadeop implementation, modeled after the automatic network cache in DNA research’s 3Delight. It allows caching files like textures, point clouds or other heavy data, on a render farm client, automatically, by simply specifying the cache location with an environment variable, or in the RIB (with an option). In your shaders you can use the cacheFile() shadeop. It should work with any renderer that has an RSL shadeop API but was tested & used in production with Pixar’s PhotoRealistic RenderMan.

Project Page: http://code.google.com/p/jupiterfilecache
Language: C++ Python
Platform: Linux, OS X, Windows
License: Creative Commons 3.0 BY-SA
Sponsor: Jupiter Jazz

OpenFX is an open standard for visual effects plug-ins. It allows plug-ins written to the standard to work on any application that supports the standard. This avoids the current per application fragmentation of plug-in development and support, which causes much heartache to everyone, plug-in developers, application developers and end users alike

The core aims of OpenFX were established early on, these are…

• to develop a standard for writing visual effects plug-ins,
• to develop that standard with a broad consensus within the industry,
• have that standard be vendor and operating system neutral,
• have that standard be sufficiently flexible that it supports a wide range of visual effects systems, from editors to compositors.

Subsidiary aims are,

• have the standard be expandable to other areas in the future, for example sound plug-ins or image i/o plug-ins,
• have any expansion of the standard be done in such a manner so that hosts can easily support plug-ins using differerent versions of the API,
• have plug-ins written to the standard be tunable to the host system they are running on,
• allow hosts to provide extra custom functionality to plugins that wish to use it.

Home Page: http://openfx.sourceforge.net/
Project Page: http://sourceforge.net/projects/openfx/
Language: c++
Platform: Linux, OS X, Windows
License: BSD
Sponsor: The Foundry, Autodesk, Gen-Arts, FilmLight, Assimilate, Re-Vision Effects

Jupiter Skin is a project container for several skin shaders developed by /*jupiter jazz*/.

At the moment this project features the following shaders:

• Jupiter SGI Skin

Jupiter Spherical Gradient Illumination Skin is a 3Delight RenderMan shader that reads scanned RGB world space normal maps for 3 different wavelengths (red, green, blue), and a fourth normal map to be used in the specular term.

This technique, presented at:

http://gl.ict.usc.edu/Research/FaceScanning/

allows the user to re-create the appear of the subtle subsurface effects of skin, together with self-shadowing and inter-reflections.

Once the texture are acquired:

• The three normal maps for the Lambertian diffuse term contain increasing detail as the light wavelength decreases.
• The normal map for the blue wavelength contains more detail than the normal map for the green wavelength, which in turn contains more detail than the red wavelength map.
• The specular normal map is used to drive the specular contribution (and the reflections), with the specular term being comprised of two specular lobes based on the Torrance-Sparrow model.

The user has the possibility of selecting between two microfacet distribution functions used:

• the Beckmann microfacet distribution, as suggested in the publication by Robert L. Cook and Kenneth E. Torrance, “A reflectance model for computer graphics”

• a Gaussian distribution, which is cheaper to compute and produces slightly softer results.

The weight of each of the specular lobe’s contribution can also be controlled directly by the user, or it can be made automatically via the extracted data in the specular intensity image.

Notice also that this shader provides optionally a full two pass (point cloud based)subsurface term as well for greater flexibility.

This work has been sponsored by Srinivas M. Mohan (Indian Artists Computer Graphics Pvt. Ltd.) for the movie *Endhiran*, and it is based on:

• “Rapid Acquisition of Specular and Diffuse Normal Maps from Polarized Spherical Gradient Illumination”.
 By Wan Chun Ma, Tim Hawkins, Pieter Peers, Charles-Felix Chabert, Malte Weiss, Paul Debevec. 
University of Southern California Institute for Creative Technologies.
 Eurographics Symposium on Rendering 2007.
• “Estimating Specular Roughness and Anisotropy from Second Order Spherical Gradient Illumination”.
 By Abhijeet Ghosh , Tongbo Chen, Pieters Peers, Cyrus A. Wilson, Paul Debevec.
 University of Southern California Institute for Creative Technologies.
 Eurographics Symposium on Rendering 2009.

Project Page: http://code.google.com/p/jupiterskin/
Language: Renderman Shading Language
Platform: Linux, OSX, Windows
License: New BSD License
Sponsor: Jupiter Jazz

Originally developed by Blur Studio, Arsenal was a replacement for 3dsmax’s BackBurner. It’s now a robust render management platform supporting many renderers, including 3dsmax, Maya, Houdini, 3delight, XSI, Nuke, Fusion, Shake and After Effects.

The core is written in C++ using Qt, and PyQt is used to extend Python interfaces. There are GUI tools to manage the queue, custom submitters for some packages, and a generic Python API for others.

Project Page: http://code.google.com/p/arsenalsuite/
Language: C++ Python
Platform: Windows, Linux
License: GNU GPL v2
Sponsor: Blur Studio

The OSL project includes a complete language specification, a compiler from OSL to an intermediate assembly-like bytecode, a runtime library interpreter that executes the shaders (including just-in-time machine code generation using LLVM), and extensive standard shader function library. These all exist as libraries with straightforward C++ APIs, and so may be easily integrated into existing renderers, compositing packages, image processing tools, or other applications. Additionally, the source code can be easily customized to allow for renderer-specific extensions or alterations, or custom back-ends to translate to GPUs or other special hardware.

Home Page: http://opensource.imageworks.com/?p=osl
Project Page: http://code.google.com/p/openshadinglanguage/
Language: C++
Platform: Linux, OSX, Windows
License: New BSD
Sponsor: Sony Pictures Imageworks

OpenColorIO (OCIO) is an open source color management project sponsored by Sony Pictures Imageworks. Based on development started in 2003, OpenColorIO enables color transforms and image display to be handled in a consistent manner across multiple graphics applications (compositors, image playback tools, renderers, color grading, etc). Unlike other color management solutions, OCIO is geared towards motion-picture post production and is suitable for both visual effects work and animated features.

OpenColorIO has been used on dozens of feature films including Alice in Wonderland, Cloudy With A Chance Of Meatballs, Spiderman(s), Surf’s Up, and Watchmen.

Home Page: http://opencolorio.org/
Project Page: https://github.com/imageworks/OpenColorIO
Language: C++, Python
Platform: Linux, OSX, Windows
License: Open BSD
Sponsor: Sony Pictures Imageworks

Particles are an important part of effects work, because they allow free-form information in 3D space. Unfortunately, there is no standard format for particles akin to Wavefront .obj. Most animation systems have their own proprietary particle formats. For example Maya uses the binary and ascii particle database formats .pdb and .pda file formats. Houdini uses the .geo and .bgeo geometry uber formats. Renderers typically have their own point cloud format such as RenderMan’s PTC format and Houdini’s .pc. All of these formats share a common theme. They allow particles to be iterated or indexed and associate a customizable set of attributes with them. The goal of Partio is to provide a unified interface akin to unified image libraries that makes it easier to load, save, and manipulate particle files.

Home Page: http://www.disneyanimation.com/technology/partio.html
Project Page: https://github.com/wdas/partio
Language: C++ Python
Platform: Linux, OSX, Windows
License: New BSD
Sponsor: Walt Disney Animation Studios

Afanasy is a free and open source tool to control remote computing. You can compute anything quicker using a render farm – remote computers connected by a network. Afanasy is designed for computer graphics (3d rendering and 2d compositing) parallel calculation. It can compute different frames (or even parts of frames) on several computers simultaneously.

Afanasy provides render farm monitoring. It is very important to watch computers resources during the render process. You can see what kind of resource (CPU, memory, network etc.) is needed to render. It is very useful to know what your farm hosts are doing.

The Afanasy engine simply runs different command lines on hosts and controls running processes. You can use Afanasy to parallel calculate anything you can describe (split) through command lines.

Home Page: http://cgru.sourceforge.net/afanasy/doc/afanasy.html
Project Page: http://sourceforge.net/projects/cgru/
Language: C++, python
Platform: All
License: GPL

Arithmetic expressions appear in almost every animation system ever created. Being able to embed an expression language in a piece of custom software allows an amazing degree of artistic freedom. At Disney artists have enjoyed using expressions because they allow just enough flexibility without being overwhelming to non-programmer users. Developers have enjoyed them too for quick prototyping and deployment of fixes to production needs.

History

At Disney there have been various expression languages. SeExpr started as a language for our procedural geometry instancing tool, XGen. Work was done to generalize it into something that could be used in other contexts. Later it was integrated into paint3d, our texture painting facility, which opened the door to procedural synthesis. More recently, we have integrated it as a way of defining procedural controls to physical dynamical simulations and render time particle instancing.

Expressions can be seen as a way of allowing customization of inner loops. This is contrast to scripting which is mostly aimed at gluing large parts of code base together. So in this sense, C++ forms the center of your application, python could be used to put pieces of it together, and SeExpr is used to customize tight inner loops.

Major Features

• Arithmetic expression of scalar/vector types
• Large library of builtin functions
• Extensible variables and functions (including with DSOs)
• Simple to embed in any program

Home Page: http://www.disneyanimation.com/technology/seexpr.html
Project Page: http://github.com/wdas/seexpr/
Language: C++
Platform: Linux, OSX, Windows
License: New BSD
Sponsor: Walt Disney Animation Studios

Pimath is a boost.python binding for the IMath library that is part of the OpenEXR project.

Pimath binds the Imath API as closely as possible. Each hpp file contains a comment block at the top, highlighting cases where the bindings differ and why. Common reasons include:

Making a function signature more Pythonic;
Removing slightly optimised functions (where the overhead of python itself would vastly outweigh the optimisation);
Removing API redundancy;
Changing misleading Imath function names (rare).
Nice things about pimath:

It provides integral template instantiations where possible – eg V3i;
It provides ‘half’ template instantiations where possible – eg M33h;
It provides to- and from-python conversion for the Imath ‘half’ type;
It spreads type instantiation over several cpp files for quick multithreaded compiling.
It’s organised as a mirror image of Imath – it has corresponding headers, and a free function in Imath is a free function in pimath. If you know Imath, you know pimath.

Project Page: http://code.google.com/p/pimath/
Language: C++, python
Platform: All
License: New BSD Licence
Sponsor: Dr. D. Studios

Alembic is an open computer graphics interchange framework. Alembic distills complex, animated scenes into a non-procedural, application-independent set of baked geometric results. This ‘distillation’ of scenes into baked geometry is exactly analogous to the distillation of lighting and rendering scenes into rendered image data.

Alembic is focused on efficiently storing the computed results of complex procedural geometric constructions. It is very specifically NOT concerned with storing the complex dependency graph of procedural tools used to create the computed results. For example, Alembic will efficiently store the animated vertex positions and animated transforms that result from an arbitrarily complex animation and simulation process which could involve enveloping, corrective shapes, volume-preserving simulations, cloth and flesh simulations, and so on. Alembic will not attempt to store a representation of the network of computations (rigs, basically) which are required to produce the final, animated vertex positions and animated transforms.

The production ready version of Alembic 1.0 was announced at Siggraph 2011 and released on August 9th, 2011 by Lucasfilm and Sony Pictures Imageworks with support from major vendors including Autodesk, Side Effects Software, The Foundry, Luxology, Pixar’s Renderman and NVidia.

Home Page: http://alembic.io/
Project Page: http://code.google.com/p/alembic/
Language: C++, Python
Platform: Linux, OSX, Windows
License: New BSD License
Sponsor: Sony Pictures Imageworks, Lucasfilm

Rez is an integrated package configuration, build and deployment system for software. With Rez you can request a set of packages, and it will create a resolved shell that contains all the dependencies you need, while avoiding version clashes. It is used primarily in the VFX industry, but is applicable to any field where it’s necessary to manage many versions of internally-developed projects and their dependencies.

It includes a cmake-based build system which is integrated into the package resolution system, and a deployment system for releasing packages to a central location, and updating the repository.

Home Page: http://code.google.com/p/rez-config/
Project Page: http://github.com/nerdvegas/rez
Language: Python
Platform: Linux
License: GNU Lesser GPL

Project Page: https://github.com/nerdvegas/vfxgal
Language: C++, python
Platform: Linux, OSX
License: GNU LGPL

Home Page: http://www.openvdb.org/
Project Page: http://www.openvdb.org/
Language: C++
License: Mozilla Public License Version 2.0
Sponsor: DreamWorks Animation

OpenSubdiv is a set of open source libraries that implement high performance subdivision surface (subdiv) evaluation on massively parallel CPU and GPU architectures. This codepath is optimized for drawing deforming subdivs with static topology at interactive framerates. The resulting limit surface matches Pixar’s Renderman to numerical precision. The code embodies decades of research and experience by Pixar, and a more recent and still active collaboration on fast GPU drawing between Microsoft Research and Pixar.

The source code for OpenSubdiv is located on github and is now in open beta.

Home Page: http://graphics.pixar.com/opensubdiv
Project Page: https://github.com/PixarAnimationStudios/OpenSubdiv
Language: C++, glsl, OpenCL, CUDA
Platform: Linux, OS X, Windows
License: Microsoft Public License
Sponsor: Disney

TACTIC is a  flexible web-based production asset management system. TACTIC’s features include:

• Securely Store Assets in a Highly Scalable, Central Repository
• Find Assets, Tasks and Notes with Powerful Search Tools
• Automate Your Project’s File Structure
• Version Control Assets and Notes
• Rollback to Previous Asset Versions
• “In-Place” Checkins for Large Files
• Automate Naming Conventions
• Package and Deliver Files with Ease
• Import/Export CSV Data
• Check Files In and Out of the Database Easily

Home Page: http://www.southpawtech.com/tactic/
Language: Python
Platform: Linux, OS X, Windows
License: Eclipse Public License
Sponsor: Southpaw Technology

OpenDisplayCalib, aka ColorTribe, is an opensource cross-platform color measurement and calibration software suite for display devices.

The suite is composed of three tools :
– ColorHealer : a calibration and measurement application
– ColorKeeper : a color correction loader with helpful tools as screen detection, warning and email when correction is obsolete, gamma slider, printer lights, custom 2D LUTs loader (custom LUT is applied over the correction LUT), etc…
– ColorChief : a calib request management web app. For now, only a very simple mail feature has been implemented to allow calibrators to know when a station is un-calibrated.

ColorTribe enables post-production facilities to maintain a coherent fleet of displays, whatever the platforms or the devices are.

Home Page: http://opensource.mikrosimage.eu/colortribe.html
Project Page: https://github.com/mikrosimage/OpenDisplayCalib
Language: C Java
Platform: Linux Windows OSX
License: Modified BSD
Sponsor: Mikrosimage

OpenRenderManagement, aka Puli,  is an open-source render management project.

The Core project is called Puli and is entirely written in python.

PuliUI is a GWT project that provides a simple web interface for OpenDispatcher.

• Python APIPuli is an open-source render management solution entirely written in Python. It provides a job submission API that can be used directly within Maya® (Autodesk) or Nuke® (The Foundry) – amongst others.
• Job TypesSeveral action scripts are also provided to enable jobs submission for Maya® (Autodesk), Mental Ray® (NVidia), Nuke® (The Foundry) but you can easily write your own scripts to support your in-house rendering engine or any other 3rd party solution.
• Render StatisticsJobs informations and metadatas can be stored in a database (and therefore providing persistence) and can then be used to provide rendering statistics.

• Global RenderingPuli is able to seamlessly manage rendering on both local and distant networks.
  For example, you can mix your renderfarm between local render nodes and a 3rd party cloud solution.
• More Noteworthy Features• Priority management
  • Jobs dependencies
  • Rendering software license availability
  • Minimum hardware requirements for a job (CPU, memory, …)
  • Workstations and renderfarm management (render nodes pools)
  • Local user denial for his workstation to be used as a render node

Home Page: http://opensource.mikrosimage.eu/puli.html
Project Page: https://github.com/mikrosimage/openrendermanagement
Language: python
Platform: All
License: Modified BSD
Sponsor: Mikrosimage