Detect inside of sphere

The sphere detection only ever considered the "closer" intersection
point. This only works for ray that originate outside the sphere.

Implement manipulation (transformations)

As I have no mechanism for selecting an element so far, the testing
element is the current camera.
I am a little suspicious of the rotation orientation, but it is easily
corrected with sign in the key handling. I may think about it later.

Use t_object (t_element) for lights and cameras

This is because manipulation (translation and rotation) has to be
implemented not just for objects but for lights and cameras also.
It would be better to create a separate union from t_object, but I
cannot think of a way that would not be quite difficult to use.

The typedef t_element can be used for generic element, whereas t_object
should be used for objects (things casting shadow) only.

The vectors for lights and cameras was also changed to vectors of
t_element so that it is easy to pass it as a t_element pointer to change
it in place.

Fix index increment on parsing file

Free scene memory at the end

Convert camera FOV to radians when parsing

Add comments to the .rt file (//)

Fix cylinder rendering

I thought that the ray forms and acute angle with a vector from
point of entry to cylinder center, but that was not true.
Instead the projections to the plane orthogonal the rotational axis have
this property. So in this commit I implement the test for it.

Fix computation of radial vector of cylinder

Implement .rt and args parsing, move test scene

Add rt_grammar and rt_parsing_table as they describe the grammar used to
parse the .rt file. Their contents are available to he program through
the file parsing_info.h where they are encoded (using xxd -i).

The test_scene is added for testing as the "default scene" had to be
erased from main for parsing to be enabled.

Other changes involve the parsing implementation directly.

Update Libft to newer version

Fix issues with translation

This was the same issue as was fixed in a2872aa. Ray was expected to
have normalized direction, but did not.

Add more complex scene to demonstrate miniRT

I wanted to have a scene now, but .rt parsing needs to be implemented
yet.

Add intensity dependence on distance

Fix shadow casting

The shadows did not work because the obstruction detection used a
function that expects ray with normalized direction vector. But the
obstruction detection did not normalize its ray because the check for
whether the obstruction is between the object and the light was easier.
The fix is normalizing the ray vector and using distance.

Initialize ray start in get_camera_ray

Solve plane shadow acne

This commit makes it so an object does not use itself for shadow
calculation. This only works properly for objects, that are not concave.

Change plane light diffusion

In the previous commit I noted that plane may not interact with light,
if the normal has the wrong sign. This commit changes but now a plane is
illuminated through itself - it diffuses light that is on the other side
than the camera.
This could be excused arguing that it is an infinitely thin piece so it
should emit light on both sides, but I would rather it would only
emit light on the side it is illuminated on.

Implement Lambertian diffuse lighting (kind of)

This implementation has its problems. The one I can think of now is that
planes are only reflecting, when their normal points in the direction of
the light.

Fix some minor bugs in the RT calculations

Add a simple scene for debugging

Implement cylinder-ray intersection detection

This commit makes the project compilable.

Implement camera to ray function

Separate vector functions to separate file

Bring the project closer to compileability

Fix Makefile includes and links.
Comment line prototypes out of main.c.
Rearrange the functions in main.c (I really should just write the
declarations into the header file...).

Implement the color calculation

Also reimplement the t_color as typedef of t_vec3 so that I can use the
vec* operations on color. The t_color now signifies the linear RGB and
needs to be converted to (and from) sRGB upon printing (reading).

Implement most of ray intersection detection

Implement finding the intersection of ray with plane and sphere and use
the intersection closest intersection to camera for color finding.
Cylinder will be implemented at another time.
Also change what qualifies as an object; Now objects have to interact
with light. Light sources and cameras are not objects anymore.

Add the structures used for defining the scene

Add the structures that are needed for the scene representation.
Also change the functions in main a little to accommodate some of these
changes.

Add some functions and structure

These functions were taken from fract-ol project, which uses the
minilibx library.

Add initial tools and structure