Individual Effort:

No team participation is really encouraged in the case of the homeworks or the labs. If you need to use code you found online, you need to (1) check with us whether this is ok, (2) clearly mark it and (3) mention it in the readme file of your submission. If you fail to do one of these, it will be treated as academic misconduct. See here for more info.

Late Submission:

Don't get behind in the lab assignments - always start early!
In this course you will have a total of 4 (four) grace days that you can distribute however you like. See here for more information on grace days.

Forum:

There is a forum at Moodle. (Note: Please make use of the forum. Help each other, but don't copy homework!)

Objectives:

• To develop a ray tracer.
• To understand ray tracing and implement a ray tracer!
• To create some nice color images

In this lab you are writing a ray-tracer. After some basic features you will extend it to include some interesting effects. You should not use any OpenGL/WebGL nor any libraries (other than for XML parsing and reading/writing PNG images) in this assignment. You can use any programming language you want, as long as your programm compiles and runs on almighty without installing additional environments (This should work at least with Java and C++).

Hint: We all love JavaScript, but writing a ray tracer with it is not the best decision. Unless you have a lot of time...

Submission Guidelines

We will use almighty server as a build environment. This means that your solutions of the Labs 3a and 3b must compile and run at least on almighty, which we will use in case we can't run or compile your solutions on our local machines during grading. You can transfer files from and to almighty using the scp command (or your OS equivalent) or alternatively clone your gitlab repo to almighty and compile your solution by ssh'ing to almighty and running cmake (c++) or gradle (java) (javac 11.0.7/g++ 7.5/cmake 3.10.2 are installed - make sure your java or c++ version of choice is compatible). Most of you are probably already familiar with working on almighty from other courses, but if you have any issues, feel free to ask - we are there to help you.

Alternatively, you can now also use Rust for this project.

For C++ and Java, your project must build and run on almighty. Regardless of the programming language you choose, you must not submit prebuilt binaries. Your project should compile and run (on almighty for C++/Java) without errors and without requiring extra configuration (if you use Rust, just use cargo for building - no need to make it work on almighty). Make sure to submit all the required files and to test it in time.

Be sure to submit any comments or remarks in a 'readme' file, especially how your submission can be built and executed.

Scene files
Your raytracer has to be able to read in any file in the format specified here. You can implement this by allowing your program to accept a file path as an input parameter or by implementing a file picker or by letting the user type in a file path during the runtime of your program, BUT having file paths hard coded in your program and letting the user choose one or more scenes within a predefined set of scene files is NOT an option!

Tasks:

(80%) Required Tasks

• T1: (10%) Parse and raycast triangles (meshes read from obj files) (example4.xml).
• T2: (10%) Implement basic reflection (perfect specular - example5.xml)
• T3: (10%) Implement basic refraction (perfect specular - example6.xml)
• T4: (10%) Add basic (color image) texture mapping for triangles. This requires the functionality to read .png files (example6.xml)
• T5: (10%) Add camera transformations (example7.xml)
• T6: (10%) Add texture mapping for spheres (example8.xml)
• T7: (20%) Add object transformations (translation, scaling, rotation) (example9.xml)

(20%) Effects
Pick up to 20% from the following effects:

• EF1: (5%) Bump mapping. (Effect name: bump)
• EF2: (10%) Environment mapping with image based lighting. (Effect name: env)
• EF3: (5%) Anti-aliased textures. (Effect name: anti)
• EF4: (10%) Motion blur (on the moving objects, not the whole image). (Effect name: blur)
• EF5: (10%) Depth of field & real camera lense. (Effect name: dof)
• EF6: (5%) Area lights & soft shadows. (Effect name: area)
• EF7: (10%) Proper reflection/refraction (based on Fresnel's + Beer's law) (Effect name: fresnel)
• EF8: (5%) Spot light sources. (Effect name: spot)
• EF9: (10%) Implement the Cook-Torrance shading model. (Effect name: cook)
• EF10: (10%) Create scripts to enable simple animations. (Effect name: anim)

(10%) Bonus
We will assign bonus marks up to 10% for either:

• B1: very creative scenes (with sophisticated geometry)
• B2: close to photo-realistic scenes (with great lighting effects)
• B3: implementing a kd-tree acceleration structure using a sub-O(n^2) building algorithm.
• B4: ray-tracing Julia sets.
• B5: implementing path tracing.
• B6: implement antialiasing using supersampling

Please state in the readme of your submission, which tasks, effects or bonus points you have completed!

Hints and Tips:

You should feel free to design your program as you see fit, however, the following progression will make life easier for you:

1. Create a valid image. If your programming environment does not support writing formats like PNG or JPEG you can also use the PPM format.
2. Create a default camera and rays.
   Encode the ray direction as RGB and write it to an image to help debug your ray generation. The following image is an example of what the image should look like (r=x, g=y, b=z).
   
3. Create intersectable surfaces.
   The following images show a reasonable progression. In the first image, white is a positive sphere intersection test. In the second image, the sphere is shaded based on the normal at the intersection point:
   

In general, some useful hints to observe:

• Use visual debugging by encoding data to RGB and outputting to an image.
• There are two tactics to perform transformations: Transform the rays or transform the objects. If you choose to transform the rays remember that you must use the inverse transformations!
• To transform the normal correctly, the transpose of the inverse transformation matrix must be used.
• Calculate the inverse transformation matrix as you receive the transformations.
• Some useful sites to get you started:
  Constructing eye rays
  Intersection routines
• While we are providing some very primitive shapes. I am encouraging you to create your own, more interesting shapes in a modeling program, such as the open source Blender.

Input Files:

Your raytracer should be able to read our xml based input file format:
Input file specification

The following input scenes will be used to grade your submission, so make sure that they are displayed correctly.

Download example scenes

Submission

• Be sure to double check your final submission by unzipping it in another directory, best on a different computer
• Provide a 'readme' file in which you describe the following:
  1. A 'claim'-section in which you describe an overview of which tasks you actually implemented (T1, T2, T3, T4, T5, T6, T7 etc.)
     • Provide additional remarks if you somehow implemented them only partially or if there are any noteworthy mistakes.
     • Failing to do so will lead to a worse mark.
     Valid file formats are: .txt, .md, and .pdf.
  2. A 'tested environments'-section, describing for instance the OS of dev-computer, OS of test-computer, browsers (+version) used for testing, ...
  3. A 'additional and general remarks'-section, containing additional noteworthy comments (if applicable).
• Include everything required by your program in your submission including: objects, textures, etc...
• Submit your files on Moodle.

Grading Criteria

Grading the labs will be based on the correctness and the adherence to assignment specification.
Following issues will lead to point deductions (up to):

• -10%: very bad readability and structure of code, no use of comments, very bad indentation, etc.
• -10%: ignoring adherence to lab procedures (see submission section)
• -5%: very bad efficiency

In order to get a full mark, you need to do all of the assigned tasks AND adhere to to lab procedures while creating readable and efficient code. I.e. if you accomplish only 70% of the tasks correctly, but you do not adhere to lab procedures, your final mark will be 70*(1-0.05) = 66.5%.