This is the kind of maths I hoped I could try to understand.The spirit is not there :)

it's very easy, actually.

`the basic idea is this: our "primitive" functions returns`

`distance from a given point to the primitive. i.e.`

auto point(1, 2, 3); float dist = BoxPrimitive(point);

`now `dist` is a distance from `point` to our box. it's by`

`definition a shortest possible distance, of course.`

now, to trace a ray, we are doing basically this: try all primitives and find the minimal distance to ray origin.

`then we know that we can safely move ray forward by that`

`distance, 'cause it won't hit anything by the way. so move it,`

`and repeat the process.`

`stop when we made some number of steps or minimal distance is`

`less then some threshold.`

`whoa, we succesfully found our hitpoint! (and with some trick we`

`also know wich primitive we hit)`

`basically, that's all. now just fire rays for all screen pixels,`

`and color the pixels according to primitive color, adding some`

`lighting to make image sexy.`

`the math is our ordinary vector algebra and light calculation,`

`nothing arcane.`

`to calculate lights, we can use the same "find minimal distance"`

`function to get light intencity for the given point. this is a`

`win, 'cause we don't have to really trace a ray here.`

`of course, this is the simpliest case: light without shadow`

`casting. to cast shadows, we have to trace a ray for real.`

`using "distance field" will allow us to do some more tricks too:`

`easy soft shadows, ambient occlusion and others. they are, of`

`course, possible with traditional raytracing too, but more`

`expensive.`

`of course, the more objects our scene has, the slower it renders,`

`as we don't try to do any space partitioning.`

`something like that. the code is really simple, just try to work`

`out some simple primitive formula, and you'll get it.`