• Until April 15th: Project ideas on Piazza (optional).
• April 16th: Project proposal PDF due on Canvas.
• May 11th: Project presentations in class.
• May 21st: Project report PDF due on Canvas, code due on GitHub.

Teams: Final projects must be done either individually, there is no option to work in teams.

Renderers: For your final project, you can work with one of the following renderers:

• DIRT, the renderer we use for programming assignments.
• Mitsuba 0.6, a research-oriented renderer with support for a rich class of rendering algorithms and scenes.

If you choose to use Mitsuba, your project proposal should justify this use. For example, if you want to experiment with modifications to some advanced rendering algorithm like Metropolis light transport, it is better to do so on Mitsuba. If you want to add support for new material classes, you should do that on DIRT.

Scope of final projects: Your final project should focus on implementing a set of features on top of either of the above renderers. We will broadly group implemented features into three categories:

• Simple features worth up to 2 points each (e.g., implementing a new type of light source or sensor, adding new BRDF models).
• Intermediate features worth up to 6 points each (e.g., implementing participating media, adding polarization support).
• Advanced features worth up to 10 points each (e.g., implementing bidirectional path tracing, adding specular next-event estimation).

Your project should comprise a list of features that sum up to at least 12 points. You can implement features for additional points for extra credit, e.g., to make up for credit you missed in programming assignments and quizzes, or for an A+ grade. Additionally, the list should include at least one intermediate or advanced feature. The above point breakdowns are just a rough guide. For each implemented feature, your project should produce:

• Feature-specific renderings showcasing a scene that emphasize's the feature's effect.
• Technical details of the implementation.
• Tests performed to validate correctness, and their results.
• Code, comments, and documentation for the feature's implementation.

In addition to the above, your final project should include a visually compelling rendering of a new scene that you put together to showcase all of the features you implemented. This image will serve as your entry to the rendering competition.

Each student will post on Piazza a list of features they are considering implementing, as well as a proposed categorization (simple, intermediate, advanced) and number of points for each feature. Please make sure to make your post private and assign it to the final project folder. The teaching staff will follow up on the posts, with feedback on each proposed feature (whether it is correctly categorized, whether it is too simple or too ambitious given the project timeline, and so on). We encourage you to submit a feature list summing up to more than the required 12 points, so that you have more options for your eventual project proposal.

Coming up with project ideas: Below are a few pointers that can help you come up with ideas. You should also take advantage of office hours between now and the due dates for your proposal, to discuss potential final project topics with the teaching staff.

• After each lecture, the teaching staff post on Slack pointers to papers and other material that relate to the lecture's overall theme, as well as more advanced topics not covered during the lecture. You can follow up on those pointers.
• If the overall theme of some lecture strongly appealed to you, you can do a literature search to find more recent papers in that area, and peruse those for ideas. Good starting points for your literature search are the related sections in the PBRT and AGI textbooks, as those almost always discuss key recent advances and papers. Google Scholar is also your friend, especially the option to show citations of a paper, which you can use to search through recent research on topics and papers we discuss in class lectures.
• You can look at results from rendering competitions in similar courses offered elsewhere. A list of such courses is available at the bottom of the course's main page.

Below are some pointers to specific topics that the teaching staff find intriguing, and associated literature. Most of the below-listed topics would correspond to intermediate and advanced features.

• Advanced integrators: bidirectional path tracing, Metropolis light transport, primary sample space.
• BSDF models: GGX microfacet models, energy conserving microfacet models, data-driven BRDF models.
• Coherent rendering: speckle effects, diffractive effects.
• Computational light transport: integrators for epipolar and disparity probing.
• Cloth, fur, and hair: see works in this area by Steve Marschner and Ravi Ramamoorthi.
• Differentiable rendering: differentiating local parameters and global parameters, path-space differentiable rendering.
• Eikonal rendering: eikonal rendering, refractive radiative transfer equation.
• Layered materials: layer lab, layering with statistical operators, position-free Monte Carlo, pearlescent materials.
• Lenses: ray tracing complex optics, depth of field effects.
• Lightfield: rendering plenoptic cameras.
• Luminaires: complex luminaires.
• Non-exponential radiative transfer: path-tracing algorithms.
• Polarization: bidirectional algorithms.
• Spectral rendering: spectral tracking.
• Specular and glints: specular next-event estimation, slope-space integrals.
• Temporal blur: H2MC.
• Time of flight: photon mapping techniques, ellipsoidal connections.
• Volumes, transmittance, and phase functions: null-space path integral, integral formulations of transmittance, Mie theory material models, perceptually-uniform phase functions, microflake phase functions, anisotropic radiative transfer.

The written project proposal should be a PDF of size between 1-2 pages, to be submitted on Canvas. It should:

• mention explicitly and provide justification for what renderer to plan to use;
• have a detailed list of the features you plan to implement, their categorization, and corresponding points;
• cite all related literature; and
• include a tentative schedule for your project.

There are two final deliverables for your project: A project presentation, and a project report.

Project presentation (May 11th): Project presentations will happen during a special class scheduled during the exam period. Each presentations will last for TBD minutes, with TBD more minutes for questions from the teaching staff and other students. Time limits will be strictly enforced! Therefore, you should make sure to prepare and practice your presentation in advance. You should prepare as many slides you think you need for the minutes you have (we recommend one slide per minute). Note that the total presentation time is due to change as we finalize logistics.

Project report and code (May 21st): Your final report, to be submitted on Canvas, should be a PDF, typeset on LaTeX, elaborating on the evaluation elements described above, for each of the features you implemented. Your code should be submitted through GitHub classroom.

Some of this write-up is inspired from Kayvon Fatahalian's final project instructions for 15-769: Visual Computing Systems, and from Wojciech Jarosz's final project instructions for Rendering Algorithms at Dartmouth.