Create the Vector3D class, member of the namespace Math.

The actual light position is set in the infinite but now we want the light to be place at a given position.

Find an optimisation algorithm for Raytracing.

The hitPoint function, return a Math::Point3D type, create a color class and change the type of return hitPoint, so rename the hitPoint to getColorOfPoint

The plane don't work, please check the function hitPoint, the function return a position if the ray never touch the plane.

The actual result:

The configuration file:

The expected result:

Create the plane primitive, it's a infinite plane on one axis.

We already implement the design pattern named "Factory" but in this project we must have 2 design pattern so I've to choice between all these design pattern:

• Builder
• Composite
• Decorator
• Observer
• State
• Mediator

Now I think I'm going to implement the builder pattern !

Create a GUI, this GUI should be display the result in a window.

Use SDL2 for this task.

Adding the example file given in the subject in the scenes/ folder

Refactor all Makefiles for clean the outputs.

Create the following needs:

• Makefile root; Makefile for each plugins, Makefile for the executable
• plugins folder
• src folder with : plugins/, raytracer/
• include folder
• tests folder
• scenes folder
• screenshots folder

Implement the Octree algorithm for optimize the Raytracer.

See here (p.116) or here for see more in Octree algorithm

I've to Implemente the Camera class of raytracer !

Create the Primitive Interface with the following virtual method:

• hit which return the position of the ray hit value

Create the cone primitive in plugin form

In the config file, the cone must be :

I will create the renderer class which will make the render of the raytracer.

The Renderer class will have the following variables:

• camera
• Lights
• Primitives

At the end the renderer will have product the .ppm image.

The compute of the hitpoint Sphere is not correctly implemented.

This issues is made to ensure the good working of the sphere hit method.

Handle the hitpoint Container Primitives method to return the correct pixel.

Display the .ppm file in SDL, that should more efficient.

Create the Sphere primitive into a plugin.

The plugin need a getInstance to get the class Sphere for the .so.

A class Sphere, wich contain:

• a constructor()
• a hit function which return the double where the sphere was hit by a ray

Create the Cyliender primitive into a plugin.

The plugin need a getInstance to get the class Cylinder for the .so.

A class Sphere, wich contain:

• a constructor()
• a hit function which return the double where the sphere was hit by a ray

I've to set up antialiasing through supersampling

Create the Rectangular Cuboid Primitive.

For more information about the rectangular cuboid see here

Create the triangle primitive.

Handle the colored lights.

On a white surface, a red light should render a red surface.
On a blue surface, a yellow light should render a green surface.

Etc...

To add a color to a light :

I've to implement the rotation system for primitives and camera !

I've to check inside the settings file and use the libconfig library to parse the different plane primitives !

The goal of this branch is to compute the exact color of a hit point.

For that, all primitives have to get a computeColor method which take the hitpoint and lightContainer and compute the hitcolor pixel in relation to the primitive material.

The current problem is that a primitive behind the camera is displayed instead of of being invisible.

The goal is to not display the element behind the camera.

Create the PirmitivesContainer class to contains the Primitives.
The class must have the following methods:

• add (add a new primitive to the container)
• hit (compute all the hit points by a ray and return it)
• clear (clear the Primitives list)

Add a good ReadME.md that explain the project.

Create the ray class with the following variables :

• Vector3D _direction
• Point3D _origin

And the following methods:

• origin
• direction
• at

Handle the light factor : diffuse.

The diffuse factor determined how the light spread over the primitive.

The display in SDL is inverted on Y axis

Handle the translation for primitives/camera/lights

The translation must be done in the parser or in the getOrigin of the objects.

I've to use the Scena class who have the data of Camera and I've to set up the camera !

Create a function which take a color vector and a stream and write colors in the stream

Compute color for all materials types in Plane primitives.

See src/Plugins/Primitives/Plane/Plane.cpp for create the function

I've to implement the parsing system of the external file !

To do it i'm going to use the libconfig++ library!

Here is an example of a scene file using libconfig++ file format:

Configuration of the camera

camera :
{
resolution = { width = 1920; height = 1080; };
position = { x = 0; y = -100; z = 20; };
rotation = { x = 0; y = 0; z = 0; };
fieldOfView = 72.0; # In degree
};

Primitives in the scene

primitives :
{
// List of spheres
spheres = (
{ x = 60; y = 5; z = 40; r = 25; color = { r = 255; g = 64; b = 64; }; } ,
{ x = -40; y = 20; z = -10; r = 35; color = { r = 64; g = 255; b = 64; }; }
) ;

    // List of planes
    planes = (
            { axis = " Z " ; position = -20; color = { r = 64; g = 64; b = 255; }; }
    ) ;

};

Light configuration

lights :
{
ambient = 0.4; # Multiplier of ambient light
diffuse = 0.6; # Multiplier of diffuse light

    # List of point lights
    point = (
         { x = 400; y = 100; z = 500;};
    ) ;

    # List of directional lights
    directional = () ;

};

Compute the hit color of the plane.

By default the color is dark, but the goal of this issue is to return a color based on the normal of the plane, his material and the different lights.

Handle the OBJ files.
Creates a parser OBJ that create many triangle for the Mesh.

Refactor the Makefile of Cylinder primitive

I've to fix the rotation of cuboid

Fix the getNormal computation in Cylinder.

The normal should be the orthogonal vector of the cylinder axis, but currently, the normal is the same as the cylinder which is not the same

Handle the drop shadow on the scene: