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.

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]

[http://worldofleveldesign.com/categories/cryengine-3-sdk/cryengine-3-sdk-08-add-vegetation-foliage-trees.php]

[http://www.sidefx.com/index.php?option=com_content&task=view&id=1721&Itemid=66]

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

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

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.

Implementation of Simple Forward+ rendering algorithm

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. Research ranges from final render quality, to improved simulations, faster and robust pipelines and new, inventive ways to view and interact with CG assets. One of these areas is the use of real-time rendering. In recent years, the de facto go to method for real time rendering has been a deferred rendering pipeline. Whilst deferred presents the ability to handle many lights and to decouple light calculations from the object complexity, it also has disadvantages such as limited material variation, high memory usage and it’s rendering of transparent objects. Another intriguing real time rendering technique is Forward+ as presented by AMD back in 2011, an extension to the more traditional and limited Forward rendering technique. For this task, you should imagine yourself as part of an R&D team tasked with investigating the benefits of using and implementing alternative rendering techniques. As part of this team, you have been asked to conduct initial investigation into what is required to implement a Forward+ renderer and which algorithm is the most suitable. As part of this, you need to put together a simple prototype demonstrating your chosen algorithm and present it to your Lead in a few weeks. Your Lead would like to see the results of each rendering approach before making a decision on which is the best avenue to pursue further. For all the different rendering techniques your team will be investigating, the same minimum requirements and restrictions have been imposed. Your prototype should be able to manipulate at least a single light in the scene, and it should render a simple scene with simple geometry with at least simple materials. Your Lead is also aware that a few weeks is not enough for a well-researched implementation to run at high frame rates. As a result, they have not set a target performance, and have stated that even 1 FPS would be acceptable as long as it shows a complete and well implemented algorithm. It is assumed for this task that you are able to use the base of your choice; either a game engine within which you integrate a Forward+ rendering algorithm, or a standalone application using either OpenGL or DirectX. Your goal is to research and select an appropriate Forward+ rendering algorithm and implement a basic prototype of the method. Your focus here is not performance, and the renderer does not need to be multithreaded. Instead, you should focus on the implementation of the algorithm to ensure it is correct and well written. Your Forward+ prototype should present at least one light that is moveable, and should render a prebuilt scene of simple geometry (e.g. the Sponza demo). Your prototype should also be accompanied by a detailed discussion of the algorithm implemented to show your understanding of the process, as well as any issues and limitations you have learnt or see with it. Note that the critical objective of this task is to produce a working prototype that clearly shows the Forward+ rendering technique at any reasonable frame rate from which an assessment of its usefulness and quality as a render method can be made. There is not enough time to implement a fully working Forward+ renderer, so it is crucial that you identify early on the key concepts and parts you will need to implement to usefully present the prototype and what can be left out. It is also important to understand what these missing features could add to the prototype. There is always the risk that certain features are harder to implement than initially anticipated. If this is the case, explain in your report 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.