Computer graphics from scratch

Colors on a screen can be generated using a combination of red, green and blue. In a computer, each of this components is represented as a number. In the following implementation, a byte per component is used. The three bytes combined give a total of 2ドル^{24}$ colors. A color depth of 24. This format is known as 888. To reduce memory usage, 555 and 565 formats are sometimes used.

Colors can be thought as elements of a three dimentional vector space. As such, they can be added and multiplied by some scalar. As the values are bounded, to prevent overflows the values after each operation are clamped between 0 and 255.

A canvas has pixels. It also has a dimention, although that may be infered from the pixel's data strucuture.

The only primitive needed is a putPixel(x, y, color), where x,y are the coordinates. In computer graphics, the coordinate systems used is centered at the origin. The conversion from an array style coordinate would be

\[p_{x} = \frac{w}{2} + a_{x}, p_{y} = \frac{h}{2} + a_{y}\]

where, $a_{i}$ are the "array coordinates" and $p_{i}$ the "pixel coordinates".

Originally, I was goind to use treeform/pixie to manipulate images. In other examples, people used sdl or some other library. But I found a video from Tsoding, who used images inPPM Format because it is so simple it can be implemented in a few lines of code without any external library.

The whole specification is in the link, but the important parts are

• The header format is <format> <width> <height> <max>. Spaces may be replaced with any whitespace. P6 is the format for binary color images. And with 888 RGB images, a max value of 255 is enough.
• The rest of the file's bytes are the pixels, three (or six if max if greater than 255) bytes per pixel. They will be rendered first from left to right, them from top to bottom, the same way a two dimentional array is layed in memory.

Using this format, is was simple enough to create custom RGB colors, a canvas, a putPixel primitive and a procedure to save and visualize images.

The scene is a restricted portion of the 3D space. For now, suppose it is parallel to XY and a fixed distance 1 from the origin. So finding the correspondin point in the scene is just a scaling.

\[s_{x} = p_{x}\frac{s_{w}}{w}, s_{y} = p_{y}\frac{s_{h}}{h}, s_{z} = 1\]

where $p_{i}$ are the scene points. In a more code-like presentation

toSceneCoords(px, py, distance=1) {
 return (px*scene.w/canvas.w, py*scene.h/canvas.h, distance)
}

Then, the raytracing steps can be rewritter as

1. Fix a view point.

2. For every pixel on the canvas

   1. Determine the corresponding point on the scene.
   2. Determine the color seen through that scene point.
   3. Paint the pixel with that color.

For 1, lets fix the view point at the origin. 2.1 just consiste of applying toSceneCoords and 2.3 is just a call to putPixel. 2.2 still requires a little more math.

findIntersections(sphere, origin, point) {
 a = |point-origin|^2
 b = 2 * |origin- sphere.center|*|point-origin|
 c = |origin - sphere.center|^2 + sphere.radius^2
 return findRoots(a, b, c)
}

findColor(origin, point) {
 color = scene.backGroundColor
 closest = inf
 for sphere in scene {
 intersenctions = findIntersections(sphere, origin, point)
 for solution in intersections {
 if 0 <= solution < closest {
 closest = solution
 color = sphere.color
 }
 }
 }
 return color
}

rayTrace(origin) { // step 1
 for x in canvas.xrange { // step 2.0
 for y in canvas.yrange { // step 2.0
 point = toSceneCoords(x, y) // step 2.1
 color = findColor(origin, point) // step 2.2
 putPixel(x, y, color) // step 2.3
 }
 }
}