# Sample Assignment Project Ideas

This page is an ongoing list of programming project ideas for students on the BSc and Masters courses. This list will be updated from time to time with more project ideas.

## Wrinkles in deformation

The goal of this assignment is to implement a geometric wrinkle system which automatically deforms the surface to apply wrinkles to the underlying deformed geometry. The system must accept an undeformed input surface and a deformed target surface, and calculate the deformation resulting from the wrinkling effect on the surface. The application should be to skin wrinkling, although ideally the method would be transferable to other application domains such as cloth. Note that the deformation could take the form of actual geometric perturbations, or as a high resolution displacement map which is calculated using your method. Interim Deliverables A working prototype and background research. Final Deliverables You must submit the following as your final deliverable:

• A demonstration of your method applied to a set of input test models which demonstrates qualitatively the effectiveness of your method. These could take the form of a single rendered frame for each test model or a video showing the deformation occurring.

• A stand­alone application or plugin for Maya (or other appropriate production software) which implements one of the two options.

• The source code for the application.

In Visual Effects, realism of deformable geometries is conveyed through a believable deformation of animated objects. In this sense, wrinkles are a key feature for many different surfaces as cloth or skin. Wrinkles can be obtained through various approaches:

• procedural: computing the compression of edges around vertices and use this value to apply a pre­made blend target
• simulation: full simulation of the surface (e.g. cloth simulation) The first approach is very fast but does not deliver realistic results as it presents the same set of wrinkles over time. The latter approach is more realistic but is hard to compute, becoming infeasible for complex characters with too many polygons. Moreover, simulated wrinkles are difficult to control. A solution is to use a mixed approach: over the deformed geometry, compute the stretch tensor and define the predominant direction of the wrinkle. By growing the wrinkle over the surface, it is possible to then build wrinkles that properly resemble real surfaces. Making the method time­dependant it is possible to make the wrinkles coherent over the animation. A good reference for this work can be found in:

Animation Wrinkling: Augmenting Coarse Cloth Simulations with Realistic­looking Wrinkles, Rohmer et al., ACM Trans. Graph. December 2010. http://dl.acm.org/citation.cfm?id=1866183

You can see how we adopted this solution in:

Procedural wrinkles generation in the implicit skinning framework, Turchet, Fryazinov, Romeo, Proceeding SIGGRAPH Asia 2015, http://dl.acm.org/citation.cfm?id=2820937

## Data Visualization Tool

Write a simple tool that can load and render a series of abstract data based on simple rules.

For example a file many contain the following data:

Frame 1
0,0,0
0,1,0
Frame 2
0,1,0
0,2,0
Frame N
0,99,0
0,100,0
0,200,0


The tool would render a series of frames, each frame containing a series of points. Each point would be rendered as a particle / point / sphere (depending upon other setup). The data set could be very large, so the tool should be able to handle a large number of points. It should also be extensible so that more complex data can be loaded and custom shaders can read and format this data (up to 16 x Vec4 data inputs per point).

The tool should be able to render the data in real time, and allow the user to navigate around the data set, scrub to frame and various other controls. The tool should also allow the user to select a point and display the data associated with that point.

An extension to this could be a live viewer where the data can be streamed to the viewer and rendered in real time via network sockets, mapped memory or other IPC mechanism.

## A Grid Simulation framework

Write a framework to allow simple scriptable grid simulations to be visualized, The idea is to allow the tool to create 2D grids / cells where particles can be places. Each simulation step will evaluate a script to control the particles, update the grid and visualization.

It is suggested the scripting language be either Python or Lua which are east to embed into other programs. The tool should allow the user to create a grid, place particles and then write and edit the script to control the particles. The script should be able to read and write to the grid and control the particles. The script should also be able to control the visualization of the particles.

## Face cloning

The goal of this project is to define a facial deformation system which accepts as input a base model with a sequence of corresponding face targets / blend shapes and a target model. The method needs to create a set of face targets and blend shapes for the target model using the base model as input.

You must submit the following as your final deliverable:

• A facial workout sequence comparing a facial animation sequence of the source model and the target model.
• A stand­alone application or plugin for Maya (or other appropriate production software) which implements one of the two options.
• The source code for the application.

When working with Digital Actors, it is important to rely on real data of their faces to ensure that we deliver contents that are as realistic as possible. Real data commonly comes in the form of a static three­dimensional scan and we have to make our generic human head match the scanned data. This way, our animatable head looks like the real actor. We currently perform this work by hand, having artists matching the two meshes but we would like to do this more automatically. One way would be to select a set of matching feature points across the two meshes and use that to register the remainder of the vertices. This way it would be possible to fit one mesh onto the other. This work can then also be extended to transfer different expressions between two different head meshes. A good reference for this work can be found in:

Expression Cloning, Noh and Neumann, Proceedings of the 28th annual conference on Computer graphics and interactive techniques, 277­288, 2001, http://dl.acm.org/citation.cfm?id=383290

Deformation Transfer for Triangle Meshes Sumner and Popovic, Proceedings of ACM SIGGRAPH 2004, http://dl.acm.org/citation.cfm?id=1015736

## Elastic and Plastic Deformations using Spherical Rigid Bodies

For performance reasons, convex collision shapes are typically used in traditional rigid body dynamics. However, when simulating destruction and fracturing, the resulting shapes are typically concave, which results in more expensive collision detection algorithms necessary. One solution is the decomposition of concave shapes into sets of convex shapes representing a single rigid body. However, this approach is not necessarily trivial to implement as is requires approximation resulting typically in overlapping neighbouring convex shapes. The latter results in the often perceived “pop” when turning neighbouring geometries into rigid bodies as their collision shapes effectively already overlap. Another limitation of using single collision shapes that perfectly describe the renderable geometry is that their resolution is often unnecessarily high for rigid body dynamics, and can inherently merely represent rigid motions. The goal of this assignment is to combine a sphere packing algorithm with the Bullet physics solver to implement rigid body dynamics utilising sets of spheres to approximate complex, concave geometry shapes, avoid the “pop” mentioned above, and material properties that support both fully rigid as well as elastic and plastic deformation. The latter can be achieved by representing a geometry not by a single spherical collision shape but by multiple non- overlapping spherical rigid bodies that are interconnected via constraints. The implementation must allow for elastic and plastic deformation by controlling and dynamically updating the parameters of these constraints (e.g. stiffness and rest-length). If you have time left, find a way to deform the source geometry smoothly using its interconnected rigid bodies.

### FINAL DELIVERABLES

You must submit the following as your final deliverable:

• One or more simulation scene or setups that shows that your implementation provides solutions to all challenges explained in the goals section.
• A stand-alone application with an OpenGL viewport or plugin to Maya or Houdini (or other appropriate production software) that runs the simulation and renders spherical shapes and constraints. If time permits, also provide an option to render the deformed source geometry.
• The source code of your application or plugin.

An elegant solution to address these challenges was proposed by our peers at Dreamworks Animation [Budsberg et al. 2014]. Their idea is to utilise functionality in both OpenVDB and Bullet to represent collision shapes using spheres. This has several advantages:

• The number of the spheres can be controlled to favour quality over simulation performance
• Collisions between spheres are inherently efficient to compute
• Interconnected spheres can be used to represent larger and more complex shapes that can even emulate elastic and plastic deformation

### REFERENCES

Jeff Budsberg, Nafees Bin Zafar, and Mihai Aldén. 2014. Elastic and plastic deformations with rigid body dynamics. In ACM SIGGRAPH 2014 Talks (SIGGRAPH ‘14). ACM, New York, NY, USA, , Article 52 , 1 pages. DOI=http://dx.doi.org/10.1145/2614106.2614132

## Generating VFX Elements

VFX Elements are short clips of smoke, fire etc. which can be composited into a VFX shot from a library (see, for example, here). However a discerning viewer is able to spot repeated use of these elements in frame, so some variation would be useful, without running a full simulation or reshooting.

I would like to see a Machine Learning model which generates variations on a certain class of VFX Element (for example, explosions). You can use an automated process in Houdini to generate a variety of data for your training. To make this problem feasible from both a complexity and computational perspective, I’d recommend the following:

1. Use a simple GAN network (for example SimpleGAN)
2. Train on stills rather than full clips
3. Train with about 100-200 low res images / clips (128x128)

## A performant on-demand USD re-composition method

Traversing USD scenes might seem straightforward, but for very large scenes such as the Moana Island, loading all payloads and activating all branches can take tens of minutes to complete. A better approach would be a system that only loads payloads or activates branches when those locations are needed by the application, for example if they are to be displayed in a Hydra viewer.

Composition and re-composition is one of the most expensive parts of the scene assembly in the USD stage, as it not only causes prims to load/unload, it may also dirty affected render prims in the Hydra viewer, forcing a lot of CPU->GPU traffic, often unnecessarily. Methods like UsdStage::SetLoadRules essentially recomposes the entire stage, so is more expensive than it necessarily needs to be. (Note that UsdStage::LoadAndUnload is pretty efficient in scoped recomposition, but this method does not effectively support the AllRule.) Additionally, setting activation state (active/inactive) in a layer forces a full recomposition, which is particularly expensive.

Develop a USD scene loading system which restricts loading only to Prims that are needed (for example, if they are expanded in a directory-like view) and restricts recomposition only to prims that are actually affected. Measure your performance and compare against the provided methods.

## Content management with OpenAssetIO

In a modern studio, assets may be stored remotely, or provided by a different studio. OpenAssetIO provides an API for assets to be referenced in a location agnostic way. From the ASWF: “OpenAssetIO aims to give artists the ability to find and share deeply connected assets regardless of how or where they’re stored. Developed by Foundry, OpenAssetIO is an open source interoperability standard between tools and asset management systems that reduces the integration effort and maintenance overhead of content creation pipelines. OpenAssetIO pioneers new, scalable, standardized asset-centric workflows by enabling tools and asset management systems to freely communicate with each other, without needing to know any specifics of their respective implementations. This leads to greater interoperability and creative collaboration compared to traditional file-based workflows.”

For this project I’d suggest that you should set up a basic OpenAssetIO server on the BU network, and support asset importing in your favourite DCC. I’d also explore the use of OpenAssetIO in conjunction with USD (i.e. remote assets as payloads) although this may be significantly ahead of the curve so might not be feasible in it’s nascent state.

## Prototype Multiple-Fluid Solver

In VFX it is the Software / R&D department’s responsibility to provide production with software solutions to specific show needs. Depending on the requirements or time frame this can either be an integration of a 3rd party commercial or open-source software, the implementation of a bespoke, proprietary software or algorithm (based on a paper), or a combination of all of these. In this challenge we imagine our MPC VFX supervisor of an upcoming show wants to have multiple fluids with different colours and material properties to interact in interesting ways as can be seen in the images above. She needs to show a first test to the client in 6 weeks. An original estimate from FX, Lighting and Compositing suggested that they require 3 weeks. This leaves us with 3 weeks to provide a working prototype. For the sake of this challenge we have already identified we cannot use commercial or open-source software out of the box. We have however a paper proposing an algorithm that does exactly what we need in our prototype:

• mixing miscible and immiscible fluids with varying properties (density, viscosity, friction), with control over diffusion between the different types of interacting fluids
• the option to define chemical reaction between two adjacent fluids resulting in changes to the material properties of the involved particles.

You goal is to find an existing CPU based SPH open-source implementation (with a license that allows for using the source code in production context without the need to publish the changes), and then use this as a starting point to add the functionality described above. If you cannot find a reasonable CPU version, but think you can rewrite the basics inspired by e.g. a GPU version, then this is fine. The goal is to get a basic SPH implementation, i.e. a starting point, up and running quickly. For the prototype, fluids need to be contained within a box (see images above), this frees you up from writing more complex boundary/collision code.

Note that the most important requirement is to get a working prototype after 3 weeks of development out to FX. There is always the risk that certain features are harder to implement than initially anticipated. This is totally fine. If you are running out of time, explain in writing why these features were hard to implement and give a suggestion as to what is required to implement them.

Also, the earlier you know that certain features won’t make it into the first version, and can give an update, the better. If you can provide work-arounds or rough versions, and better implementations later, even better.

### FINAL DELIVERABLES

You must submit the following as your final deliverable:

• One or more simulation scene(s) or setup(s) showing that your implementation provides solutions to (preferably all) challenges explained in the goals section.
• A stand-alone application with an OpenGL viewport or plugin to Maya or Houdini (or other appropriate production software) that runs the simulation and renders the fluids as coloured particles or optionally, surfaced meshes.
• The source code of your application or plugin.

As a starting point for your research on SPH implementation, check for expertise at your University. You can also search for WCSPH variants online, which are easy to understand and perfectly fine for this implementation. Note that incompressibility is not a requirement, but rather difficult to achieve for multi-fluids, and hence optional. If you prefer to present your work with the particles meshed, have a look at OpenVDB - it includes a fast and high quality way to convert particles to meshes.

### REFERENCES

Bo Ren, Chenfeng Li, Xiao Yan, Ming C. Lin, Javier Bonet, and Shi-Min Hu. 2014. Multiple-Fluid SPH Simulation Using a Mixture Model. ACM Trans. Graph. 33, 5, Article 171 (September 2014), 11 pages. DOI=http://dx.doi.org/10.1145/2645703

## Real Time Vegetation Dynamics

All aspects of film production, from pre-production, pre-visualisation, on set shooting, to post-production and VFX, are relying more and more on real time technologies to produce meaningful data and visual outputs. This data could be camera data, taken straight into VFX, light data used to drive real world light panels or final pixels to take straight to screen. One way in which clients want to use real time technologies is to create a living world with dynamics that serve as a strong reference for real life and/or the final VFX. One interesting specialisation of this is vegetation dynamics. Your goal for this task is to create a real-time vegetation dynamics and simulation system. The system should allow users to modify inputs to the system and see the effects in real time. Examples of controllable simulation inputs are wind, interactions with other objects and gravity. You only need to focus as a minimum on a single vegetation type (such as grass). The geometry can be pre-made and pre- defined. It does not need to be procedural. Your system should ensure good real time performance and interactivity when changing simulation settings and presenting the result. You should also show variety in the simulation settings. For example, if you implemented inter object dynamics, you could demonstrate different object types. The toolset can be developed inside a DCC tool, or as a standalone application. The only limitation is that Houdini may not be used. You are free to use third party libraries as long as they are open source. It is your choice whether you want to integrate an existing physics engine or develop your own physics system for this purpose. Note, you should not focus on vegetation layout or creation tools for this project and high quality rendering is not mandatory however can be considered a stretch goal. Instead, make sure you focus on the quality of the simulation and dynamics as well the overall performance. There is always the risk that certain features are harder to implement than initially anticipated. If this is the case, explain in writing why these were hard to complete and provide a suggestion on what is required to complete their implementation.

## Temporal Anti-Aliasing in Games

Temporal Anti-Aliasing (TAA) is the anti-aliasing algorithm of choice for many current real-time games engines including Frostbite and UE. It uses pixel samples of previous rendered frames, jittering and scene re-projection to trace the temporal history of adjacent pixels and blend them in order to avoid aliasing effects.

The Brief The TAA performs in general better than the competition. However, it still has some drawbacks such as blurriness, it does not work well with translucent materials and it sometimes shows pixel flickering due to jitter. Usually TAA requires tweaking to balance between ghosting and flickering artefacts Your task will be to implement the TAA algorithm and research/implement ideas for improving its performance (in some specific context) or extending its application. Pre-production and Interim Deliverables Algorithm Research and implementation outline /1st round of tests and algorithm performance/application. Final Deliverables

Executable file/video based on of your implementation of the TAA, which provides evidence of application of TAA in some real-time context or scene. Source code of your implementation, which can compiled and tested. Documentation, description of your implementation and possible improvements or extensions researched.

## Interactive Terrain Deformation and Sculpting

As the process of film and VFX creation evolves, there is a growing need for the development, iteration and designing of assets to become faster and more interactive. One example of this is the sculpting and generation of large scale CG terrains to form sets or environments for worlds or shots.

These terrains can vary from mountains and cities to deserts and jungles. Traditionally, making any changes to these terrains, preview and try different ideas, would involve many departments to build, sculpt and retexture the geometry, taking days to weeks for results. Your goal for this task is to create a terrain deformation and sculpting toolset that will allow users to directly interact, modify and iterate on existing terrain geometry. You will need to demonstrate a minimum of 2 environment types such as mountains and cities.

The tools should allow them to modify a plethora of the terrains properties, including height, smoothness and material (sand, rock etc). It should also provide a digging tool for creation of holes, caves or rivers for example.

Your system should ensure correct geometry, UVs and normals at all times and should also be able to export the terrain geometry into either OBJ, FBX or USD (if you feel experimental) so that it can be loaded back into Maya. Additionally, it should handle large scale terrains efficiently with good real time performance. The toolset can be developed inside a DCC tool, or as a standalone application. The only limitation is that Houdini may not be used. You are free to use third party libraries as long as they are open source. It is not required for the sake of this task for the toolset to work in AR/VR. However, if it is possible to do so with controller interaction, this would be very interesting. Note, the focus of this task is on the features, quality of the experience and the usability of each tool provided. Make sure you focus on the key features to produce a quality useable product and explain with accompanying documentation any features not implemented and why. There is always the risk that certain features are harder to implement than initially anticipated. If this is the case, explain in writing why these were hard to complete and provide a suggestion on what is required to complete their implementation.

## Realtime Global Illumination

The Software R&D department of a VFX company is always looking to be on the cutting edge of whatever technology is available and relevant. This research ranges from final quality of renders, to more faithful simulations, faster and robust pipelines all the way to new and inventive ways to view and interact with CG assets. One of these areas is the use of realtime rendering and preview to allow supervisors and artists to quickly see, modify and experiment with the look of an asset.

It is assumed for the sake of this task that we already have a real time renderer available (OpenGL etc), but cannot use any integrated or third party Real Time GI solutions as the quality of their output is too low. We have however found multiple papers which show different methods to achieve what we want.

You can find many different papers and existing implementations on variations of Real Time GI methods online. There are multiple methods for Real Time Global Illumination such as Voxel Cone Tracing presented in different papers. It is up to you to decide which is most appropriate, however, as a good starting point we suggest looking up the different techniques here https://en.wikipedia.org/wiki/Global_illumination#List_of_methods.

## Rigid body dynamics

Simulation of two or more different simple rigid objects within a big cubical container. The objects are represented using polygons.

### Description and Requirement

The objects are subject to gravity. Giving an initial linear and angular velocities, your program should be able to simulate the interaction between the objects and the container. You should use at least two objects. You may also allow the user to specify necessary parameters, such as initial speed, force and mass.

## Cloth simulation

Simulation of a piece of cloth using the mass-spring technique.

### Description and Requirement

A piece of rectangular cloth is represented by a number of mass points connected by a spring-damper model. Simulate the deformation of the cloth in the following situations:

• Under gravity;
• Consider at least two initial constraint settings, such as hanging on two fixed points; and resting on a table (e.g. a tablecloth).
• Interactions of cloth with other objects (obj meshes would be best)

You are also encouraged to try out other techniques, such as the implicit method. Please note that there are several examples of these on the web and yours must be different. I recommend using Jon’s RK4 demo as a basis and not other online tutorials.

## Inextensible cloth Simulation

Recent papers have introduced the idea of Inextensible cloth pdf web You should develop a stand alone tool (or maya plugin using necleus solvers as a basis) to demonstrate these principles.

## Inverse kinematics

Implement an inverse kinematic system.

### Description and Requirement

Your program should be able to move a simple articulated structure following a given goal. The shape of the structure is not important. A simple joined structure is acceptable.

• It is able to cope with a simple animated structure having at least three links.
• The user is able to set a goal interactively, either by a mouse or keyboard.

## Implicit surfaces

Implement a simple object modeling system using implicit surfaces.

### Description and Requirement

Implicit surfaces are good for representing organic looking objects. Implement a simple implicit surface system, such that it can be used to model simple objects. You may use either ray marching or marching cubes techniques to evaluate the iso-surface. A wireframe representation of the objects is acceptable.

## Free-Form Deformations (FFDs)

Implement a simple system using the FFDs to model deformable objects.

### Description and Requirement

Free-Form Deformations are a popular method for animating deformable objects and have been incorporated in all major animation packages. Implement a simple FFDs system, such that it can be used to deform simple objects. The initial idea was presented by Sederberg and Parry in 1986. A number of other researchers have made many other improvements to the original technique.

## Hair simulation

Implement a simple system for the simulation of long flowing hair.

### Description and Requirement

Realistic hair simulation is an important topic of computer animation. In this project you are required to implement a simple system to generate and animate long hairs. A number of research papers have been published and you can either follow existing techniques or develop your own. The important requirement is hair movement. All hair strands are subject to the initial forces from the body (head) movement and the gravity. Image quality is not essential.

## Flocking System

Craig Reynolds proposed the idea of a flocking system to simulate flocks of birds or schools of fish. #Description and Requirement

• The system should allowing for dynamic creation of entities and scene object avoidance.
• The system should have some form of user controllable parameters for each of the boids / agents in the system.
• A further advancement would be the use of scripting languages to program the boids brain.
• The focus of the simulation should be large amounts of boids (>50000) this will require the use of acceleration structures.

## Raytracer / Pathtracer

Create a Ray tracer with the ability to ray-trace primitives such as spheres, planes, cones and meshes. The program should use a simple text file to describe the material properties, lights and objects in the scene. Pre visualisation can be done using OpenGL and the ray-traced image may either be save to an image file or using the OpenGL framebuffer.

## L-Systems

Develop an interface that allows L-systems Lindermayer systems based modeling of plant like structures using OpenGL. The L system grammar should be specified from a text file.

## Dirt and junk

A common problem with CGI is that the end result looks too clean and artifical. Investigate various ways of adding dirt and junk to scenes and possible ways of deteriorating buildings due to pollution, weather and other factors.

## Rain, snow flurries

Develop a system to generate realistic animation of rain and snow. The student should pay attention to the following areas

• Artist control
• Realism Should time allow, the student may also like to consider the following
• Interaction with environment and characters
• Rendering

## Affine Particle In Cell

Implement the Affine Particle In Cell method (similar to FLIP) for fluid simulation using OpenVDB and possibly CUDA to support millions of particles per second. pdf This has just been integrated into the DNeg fluid pipeline and has dramatically improved stability, supporting billions of particles per frame on their cluster.

## Skin Deformation

A particular challenge for shape modelling is deforming the outer skin shape to give the impression of muscle deformations. Several new methods have been proposed in the Computer Graphics literature to tackle the problem of surface deformation. The goal of this project is to implement at least ONE of the following papers and create a usable system for modeling organic muscle shapes.

1. Bounded Biharmonic Weights for Real-Time Deformation project page video video

2. Laplacian Mesh Editing project page video

3. Elastic Implicit Skinning Project page video

# Vegetation simulation and rendering

A common problem in simulated environments is the generation of realistic vegetation growth and rendering using a small number of assets. There are a number of challenges associated with this problem. One of these problems can be tackled as part of this brief.

1. Vegetation growth: Build a tool that provides organic looking growth around a given piece of geometry. Imagine vine growth around tree trunks etc. The tool should deal with branch generation, collision detection, and leaf placements.

2. Animating large vegetation environment: Provide a tool for animating large Forest/Jungle like setups. Particular attention should be paid to data management for Rendering. Handling of LODs, usage of instancing. Provide different means to do foreground, mid ground and background animation. What are the challenges for each of the different levels.

3. Organic layout of large vegetation: A typical VFX production would generate a large volume of assets to be reused on shots. For a typical jungle/forest scene we can easily model 100s of individual tree and other vegetation to be place amongst any terrain. The task is to build a tool that would enable placement of these generic trees on any given terrain. Root placement, trunk relaxation and orientation according to the properties of the terrain.

## Generation of densely populated scenes

Write a tool that would allow users to generate a densely populated scene from a few base assets.

• The assets themselves are not important - primitives would be fine
• Care and thought should be given to the way the user will define and describe the layout and placing of assets to the system
• After the process of building the scene, the ability of the user to swap an asset type for another asset type should be provided
• This can be undertaken in any tool-set/language, but would ideally be written as a set of libraries and APIs that meant it would (given time) be extendible for different applications (Maya/Nuke/Houdini)

## Interesting material relating to the subject:

[http://library.imageworks.com/pdfs/imageworks-library-kami-geometry-instancer.pdf]

[http://graphics.pixar.com/library/AnyoneCanCook/paper.pdf]

[http://worldofleveldesign.com/categories/cryengine-3-sdk/cryengine-3-sdk-07-place-objects-models-into-map.php]