change bonus points to normal points

assignments_2021/assignment1_path_tracing/assignment1_path_tracing.tex

@@ -31,7 +31,7 @@
 In this assignment you will implement all of the crucial parts to get a Monte Carlo based rendering system.
 The result will be 1. an ambient occlusion integrator, 2. a direct light renderer, and 3. a simple path tracer.
 The assignments build up upon each other, be sure to test everything before continuing.
-For this assignment you can ignore the material BRDF and just assume white diffuse materials ($\rho = \{1,1,1\}$).
+For most points in this assignment you can ignore the material BRDF and just assume white diffuse materials ($\rho = \{1,1,1\}$).
 
 \textbf{We have updated the \texttt{assignments} repository. Please merge all upstream changes before starting to work.}
 \begin{verbatim}
@@ -106,7 +106,7 @@ Altogether, this should be about 20 lines in a new \texttt{integrator\_ao.cpp} f
 Compare results with different sample counts (16, 64, 256...), do you see an improvement?
 If not, go back to Completing Nori's MC Intestines!
 
-\section{Direct lighting (9 Points)}
+\section{Direct lighting (up to 9 Points)}
 Check the slides about light and the recaps in Monte Carlo integration and Path Tracing for the correct integrals.
 There are two possibilities on how to implement direct lighting: hemisphere sampling and light source sampling.
 Hemisphere sampling works well only for very very large lights (sky), while light source sampling works especially well with small lights.
@@ -137,7 +137,7 @@ If you hit a regular surface instead, cast a random ray according to uniform hem
 If the closest intersected object is a light, compute its contribution using the equations from the lecture, otherwise return zero (black).
 This should only require a small edit from the \texttt{ao} integrator.
 
-\subsection{Light surface sampling (6 points)}
+\subsection{Light surface sampling (up to 6 points)}
 Light surface sampling is important for performant path tracers (it's referenced as "next event estimation" or "direct light sampling" there).
 In contrast to hemisphere sampling, you are not simply shooting rays around the hemisphere and hope to find light.
 Instead, you try to connect hit points directly to light sources and check if that connection is possible.
@@ -186,7 +186,7 @@ Once you have a point, cast a shadow ray and compute the contribution, if any ($
 If there are multiple lights, make sure to compensate for the fact that you chose a particular one!
 Add a boolean property to allow switching between hemisphere sampling and surface sampling.
 
-\section{Simple Path Tracing (8 Points + 22 Bonus)}
+\section{Simple Path Tracing (15 Points + 15 Bonus)}
 \subsection{Implement the recursive path tracing algorithm (8 points)}
 Create a new integrator and call it \texttt{path\_tracer\_recursive}(\texttt{.cpp}).
 Start with a copy of the direct lighting integrator.
@@ -208,13 +208,13 @@ However, the proper way to do it is to keep track of the \textit{throughput}.
 With every bounce, the importance emitted from the camera is attenuated, and the probability for continuation should become lower.
 You should keep track of this throughput in a Color3f vector, and use its largest coefficient for Russian Roulette (2 Points). Check the slides for details.
 
-\subsection{Implement and use the Diffuse BRDF / BSDF (2 bonus points)}
+\subsection{Implement and use the Diffuse BRDF / BSDF (2 points)}
 Encapsulate uniform hemisphere sampling of diffuse materials in \texttt{diffuse.cpp}.
 The test cases already use it, so you can store and use its albedo to generate colour!
-These 2 bonus points are only valid in conjunction with a working path tracer.
+These 2 points are only valid in conjunction with a working path tracer.
 Check slides for details.
 
-\subsection{Implement path tracing in a loop (5 bonus points)}
+\subsection{Implement path tracing in a loop (5 points)}
 Every recursive algorithm can be written in a loop as well.
 Sometimes a stack is needed, but in the path tracer that is not necessary.
 The loop form is much friendlier to the processor, and you can avoid stack overflows (which could happen with very deep recursions).