Beforehand I’ve made up our minds to place in force a slightly total raycasting engine in ClojureScript.

It became once quite a few relaxing, an intelligent expertise, and ClojureScript became once awesome.

I’ve applied shrimp labyrinth sport, and regarded as collectively with more features to the engine, corresponding to digicam shake, and wall height commerce.

However when I’ve started working on these, I rapidly understood, that I’d rob to transfer on to something more piquant, love staunch 3D rendering engine, that additionally uses rays.

Clearly, my first though became once about writing a ray-tracer^{1}.

This approach is vast known, and gained quite a few traction neutral neutral these days.

With native hardware strengthen for ray tracing, quite a few games are using it, and there are quite a few tutorials instructing how to place in force one^{2}.

Briefly, we solid a bunch of rays in 3D home, and calculate their trajectories, purchasing for what ray will hit and leap off.

Assorted materials delight in diversified leap properties, and by tracing rays from digicam to the provision of sunshine, we can imitate illumination.

There are additionally quite a few diversified approaches how to calculate bouncing, e.g. for world illumination, and ambient light, however I’ve felt that it is a long way a slightly complex job, for a weekend submit.

And unlike raycasting, most ray-tracers require polygonal info in uncover to work, where raycasting handiest wish to know wall initiate and terminate features.

I’ve wanted a identical technique for 3D rendering, where we specify an object when it comes to it’s mathematical representation.

Adore for sphere, we’ll gracious specify coordinate of a center, and a radius, and our rays will gain intersection features with it, providing us a adequate data to blueprint this sphere on display masks masks.

And neutral neutral these days, I’ve read a couple of identical approach, that uses rays for drawing on display masks masks, however in its put of casting infinite rays as in raycasting, it marches a ray when it comes to steps.

And it additionally uses a peculiar trick, to type this route of very optimized, due to the this reality we can use it for rendering staunch 3D objects.

I’ve made up our minds to structure this submit equally to the one about raycasting, so this will likely be every other long-read, customarily more about Fennel in arena of raymarching, however on the terminate I promise that we’ll earn something that appears to be like love this:

So, gracious as in raycasting, first we desire to attain is to know the way raymarching engine works *on paper*.

## Raymarching basics

Raymarching could maybe even neutral additionally be illustrated equally to raycaster, excluding it requires more steps except we could maybe per chance render our image.

First, we desire a digicam, and an object to undercover agent at:

Our first step would to solid a ray, however, unlike with raycasting, we’ll solid a fraction of a ray:

We then test, if the ray intersects with the sphere.

It’s now not, so we attain yet every other step:

It’s now not intersecting yet, so we repeat again:

Oops, ray overshoot, and is now contained in the sphere.

Here’s now not undoubtedly upright option for us, as we desire for our rays to complete without prolong on the thing’s flooring, without calculating intersection level with the thing itself.

We are in a position to repair this by casting shorter ray:

Nonetheless, right here is highly inefficient!

And moreover, if we’ll commerce the angle a exiguous or transfer the digicam, we can overshoot again.

Meaning that we’ll both delight in wrong end result, or require a extraordinarily shrimp step size, which will blow up computation route of.

How we can fix this?

### Distance estimation

The approach to right here is a signed distance characteristic, or a so known as Distance Estimator.

Imagine if we knew how a long way we’re from the thing at any level of time?

This would mean that we can shoot a ray of this size in any route and mute don’t hit something else.

Let’s add every other object to the scene:

Now, let’s blueprint two circles, which will signify distances from the objects, to the level from where we’ll solid rays:

We are in a position to perceive, that there are two circles, and one is bigger than every other.

This means, that if we spend the shortest righteous distance, we can safely solid ray in any route and never overshoot something else.

Shall we scream, let’s solid a ray in direction of the square:

We are in a position to perceive, that we haven’t reached the square, however more importantly we did now not overshoot it.

Now we desire to march the ray again, however what distance could maybe even neutral mute it duvet?

To answer to this ask, we desire to build up every other distance estimation from ray terminate to the objects in the scene:

But again we spend shorter distance, and march in direction of the square, then earn the gap again, and repeat the complete route of:

You might want to per chance maybe per chance also perceive that with every step the gap to the thing becomes smaller, and thus we can by no technique overshoot the thing.

Nonetheless this additionally technique, that we can accumulate quite a few undoubtedly shrimp steps, except we in the break utterly hit the thing, if we ever attain.

Here’s now not a upright suggestion, on story of it is a long way a lot more inefficient than using fastened distance, and produces too lawful outcomes, which we don’t undoubtedly need.

So in its put of marching up except we exactly hit the thing, we can march *adequate* times.

E.g. except the gap to the thing is sufficiently shrimp, then there’s no staunch existing proceed marching, because it is a long way obvious that we can hit the thing soon.

However this additionally technique, that if the ray goes approach the fringe of an object, we attain quite a few pricey steps of computing distance estimations.

Here’s a ray that is parallel to the aspect of the square, and marches in direction of the circle:

We attain quite a few seemingly pointless measurements, and if a ray became once closer to the square’s aspect, we would attain a lot more steps.

Nonetheless this additionally technique, that we can use this data (since we’re already computed it) to render such issues as glow, or ambient occlusion.

However more on this later.

Once ray hit an object now we delight in the complete data we desire.

Ray represents a degree on the display masks masks, and the more rays we solid the greater resolution of our image could per chance be.

And since we’re now not using triangles to signify objects, our spheres will continuously be tender, no topic how shut we’re to it, on story of there’s no polygons lively.

Here’s on the complete it.

Ray marching is slightly straightforward thought, gracious love raycaster, though it’s a exiguous more complex, as we attain wish to compute issues in 3D home now.

So let’s initiate imposing it by installing required instruments, and constructing the venture.

## Conducting structure

As you respect from the title we can use two necessary instruments to earn ray-marcher, that are LÖVE, a free sport engine, and Fennel the programming language.

I’ve chosen Fennel, on story of it is a long way a Declare love language, that compiles to Lua, and I’m quite a fan of Lisps.

However we additionally desired to blueprint somewhere, and I know no GUI toolkit for Lua.

However there is LÖVE – a sport engine that runs Lua code, which is agreeable on operating on all programs, thus a perfect candidate for our job.

Installation steps could maybe even neutral vary per operating machine, so please consult with manuals^{3}^{, }^{4}.

On the time of penning this submit I’m using Fedora GNU/Linux, so for me it technique:

```
$ sudo dnf set up cherish luarocks readline-devel
$ luarocks set up --local fennel
$ luarocks set up --local readline # requires readline-devel
$ export PATH="$PATH: $HOME/.luarocks/bin"
```

It’s better to permanently add `$HOME/luarocks/bin`

(or every other path, in case your installation differs) to the `PATH`

variable in your shell, in uncover to be in a predicament to use installed utilities without specifying fat path at any time when.

You might want to per chance maybe per chance also test if every thing is installed precisely, by operating `fennel`

in you repeat line.

```
$ fennel
Welcome to Fennel 0.5.0 on Lua 5.3!
Utilize (doc something) to perceive documentation.
>> (+ 1 2 3)
6
>>
```

For other distributions installation steps could maybe even neutral fluctuate, and for Dwelling windows, I judge it’s righteous to skip the `readline`

section, which is utterly now not fundamental, however makes editing in a REPL a exiguous more joyful.

Once every thing is installed, let’s earn the venture itemizing, and the `necessary.fnl`

file, where we can write our code.

```
$ mkdir love_raymarching
$ cd love_raymarching
$ touch necessary.fnl
```

And that’s it!

We are in a position to ascertain if every thing works by collectively with this code to `necessary.fnl`

:

```
(fn cherish.blueprint []
(cherish.graphics.print "It undoubtedly works!"))
```

Now we can compile it with `fennel --compile necessary.fnl > necessary.lua`

, thus producing the `necessary.lua`

file, and speed `cherish .`

(dot is intentional, it signifies contemporary itemizing).

A window could maybe even neutral mute seem, with white textual speak material `It undoubtedly works!`

in upper left corner:

Now we can initiate imposing our raymarcher.

## Scene setup

Correct as in raycaster, we desire a digicam that can shoot rays, and a few objects to undercover agent at.

Let’s initiate by rising a digicam object, that can retailer coordinates and rotation info.

We are in a position to attain so, by utilizing `var`

to state a variable that is local to our file, and that we can later commerce with `living`

^{5}:

```
(var digicam {:pos [0.0 0.0 0.0]
:x-rotate 0.0
:z-rotate 0.0})
```

For those unfamiliar with Lisps, and particularly Clojure, let me rapidly indicate what this syntax is.

Whenever you happen to respect these items, feel free to skip this section.We initiate by utilizing a

`var`

particular invent, that binds a fee to a popularity love this:`(var name fee)`

.

So if we initiate the REPL, using`fennel`

repeat in the shell, and write`(var a 40)`

, a contemporary variable`a`

could per chance be created.

We then can test, that it has the specified fee by typing`a`

, and pressing return:We are in a position to then alter the contents of this variable by utilizing

`living`

particular invent, which works love this`(living name contemporary-fee)`

:`>> (living a (+ a 2)) >> a 42`

Now to curly and square brackets.

Every thing enclosed in curly braces is a hashmap.

We are in a position to use any Lua fee as our key, and doubtlessly the most total alternative is a string, however Fennel has extra syntax for outlining keys – a colon adopted by a note:`:a`

.

Here’s known as a key phrase, and in Fennel it is a long way truly the identical as`"a"`

, however we don’t wish to jot down a pair of quotes.

Nonetheless key phrases can’t possess spaces, and every other symbols.So penning this

`{:a 0 :b 2 :c :hello}`

in the REPL will type a contemporary desk, that holds three key fee pairs, which we can later earn with every other syntax – the dot`.`

.

Combining it with`var`

, we can perceive that it works:`>> (var m {:a 1 :b 2 :c :hello}) >> (. m :b) 2`

There’s additionally a shorthand for this syntax, that is, we can type

`m.b`

and earn accurate of entry to the`:b`

key’s fee:Witness that even though we’ve specified the fee for

`:c`

as`:hello`

, the REPL printed it to us as`"hello"`

.We’re left with square brackets now, and right here is obvious straightforward vector.

It will grow and shrink, and retailer any Lua values in it:`>> [0 :a "b c" (fn [x] x)] [0 "a" "b c" #`

: 0x56482230e090>] Nonetheless Lua doesn’t undoubtedly delight in vectors or arrays, and it utilizes tables for this, where keys are simply indexes.

So the code above is a a lot like this Fennel expression`{1 0 2 "a" 3 "b c" 4 (fn [x] x)}`

, however we can use square brackets for comfort.Demonstrate, that we can mix listed tables (vectors) and smartly-liked tables (hashmaps) collectively.

We are in a position to attain it as shown above, by specifying indexes as keys, or disclose a vector var and`living`

a key in it to some fee:`>> (var v [0 1 :a]) >> (living v.a 3) >> v {:a 3 1 0 2 1 3 "a"}`

So digicam is truly a Lua desk, that shops keys `:pos`

, `:x-rotate`

, and `:y-rotate`

, every storing a respective fee.

We use a vector as our arena, and two floats as our rotation angles.

Now we can type objects, however earlier than that, we desire a scene to retailer those objects:

Yep, that’s our scene.

Nothing fancy, simply an empty vector to which we can later add objects.

Now we can earn these objects, so let’s initiate with perchance doubtlessly the most fine one – a sphere.

And I’ll additionally rapidly indicate what makes raymarching diversified from other programs of rising 3D graphics.

### Creating objects

What’s a sphere?

That depends on the arena, we’re working in.

Let’s commence up Blender, accumulate away the default dice, and earn sphere with `Shift+a`, Mesh, UV Sphere:

To me, this appears to be like nothing love a sphere, on story of it consists out of rectangles.

Nonetheless if we subdivide the flooring, we can earn more upright representation:

This appears to be like more love a sphere, however right here is mute gracious an approximation.

Theoretically, if we transfer very shut to it, we can perceive the perimeters and corners, especially with flat shading.

Also, every subdivision provides more features, and it will get more and costlier to compute:

We now wish to type these alternate-offs, on story of we don’t need very lawful spheres, when we desire staunch time processing.

However raymarching doesn’t delight in this limitation, on story of sphere in raymarching is printed by the level and radius size.

Which we can then work with by utilizing signed distance characteristic.

So let’s earn a characteristic, that can construct sphere:

```
(fn sphere [radius pos color] ➊
(let [[x y z] ➋ (or pos [0 0 0])
[r g b] (or coloration [1 1 1])]
{:radius (or radius 5)
:pos [(or x 0) (or y 0) (or z 0)]
:coloration [(or r 0) (or g 0) (or b 0)]
:sdf sphere-distance ➌}))
```

There’s quite a few stuff happening, so let’s dive into it.

Here’s a so known as constructor – a characteristic, that takes some parameters and constructs an object with these parameters applied, then returns it.

In most typed languages we would disclose a class, or structure to signify this object, however in Fennel (and hence in Lua) we can gracious use a desk.

And right here is my current section of such languages.

So we feeble `fn`

particular invent to earn a characteristic named `sphere`

, that takes three parameters: `radius`

, arena in home `pos`

, and `coloration`

➊.

Then we perceive every other particular invent `let`

.

It’s a long way feeble to introduce domestically scoped variables, and has every other fine property – destructuring ➋.

Let’s rapidly know the system

`let`

works in this case.

Whenever you happen to respect how destructuring works, it is doubtless you’ll maybe per chance skip this section.Here’s a straightforward example:

`>> (let [a 1 b 2] (+ a b)) 3`

We’ve launched two local variables

`a`

and`b`

, which have interaction values`1`

and`2`

respectively.

Then we’ve computed their sum and returned it which means.Here’s upright, however what if we desired to compute a sum of three vector parts multiplied by

`b`

?

Let’s save a vector into`a`

:`>> (let [a [1 2 3] b 2] )`

There are many of programs to attain this, corresponding to

`decrease`

over a vector with a characteristic that sums parts, or earn values from the vector in a loop, and save those into some local variable.

Nonetheless, in case of our venture, we continuously know exactly what number of parts there could per chance be, so we can gracious accumulate these out by indexes with none roughly loop:`>> (let [a [1 2 3] b 2 a1 (. a 1) a2 (. a 2) a3 (. a 3)] ((+ a1 a2 a3) b)) 12`

But, right here is highly verbose, and never undoubtedly upright.

We are in a position to type it a exiguous much less verbose by skipping local variable definitions and use values without prolong in the sum:`>> (let [a [1 2 3] b 2] (print (.. "fee of 2d ingredient is " (. a 2))) ((+ (. a 1) (. a 2) (. a 3)) b)) fee of sectond ingredient is 2 12`

Nonetheless, again, this isn’t undoubtedly huge, as now we would like to repeat the identical syntax three times, and what if we desire to use 2d fee from the vector in several areas?

Adore right here, I’ve added

Lets use a neighborhood binding for this, however we don’t desire to attain this manually.That’s where destructuring turns out to be helpful, and belief me, it is a long way a extraordinarily helpful thing.

We are in a position to specify a pattern, that is applied to our data, and binds variables for us love this:`>> (let [[a1 a2 a3] [1 2 3] b 2] (print (.. "fee of 2d ingredient is " a2)) ((+ a1 a2 a3) b)) fee of sectond ingredient is 2 12`

Which works slightly love this:

Here’s a lot shorter than any of outdated examples, and enables us to use any of vector values in several areas.

We are in a position to additionally destructure maps love this:

`>> (var m {:a-key 1 :b-key 2}) >> (let [{:a-key a :b-key b} m] (+ a b)) 3`

And this additionally has a shorthand for when the name of the most necessary and the name of desired local binding will match:

`>> (var m {:a 1 :b 2}) >> (let [{: a : b} m] (+ a b)) 3`

Which is even shorter.

All this truly boils all of the system down to this roughly Lua code:

`-- vector destructuring -- (let [[a b] [1 2]] (+ a b)) local _0_ = {1, 2} local a = _0_[1] local b = _0_[2] return (a + b) -- hashmap destructuring -- (let [{: a : b} {:a 1 :b 2}] (+ a b)) local _0_ = {a = 1, b = 2} local a = _0_["a"] local b = _0_["b"] return (a + b)`

Which is nothing particular undoubtedly, however this instance mute shows the vitality of Declare’s macro machine, by which destructuring is applied.

However it will get undoubtedly wintry when we use this in characteristic kinds, as we can perceive later.

If we were to name `(sphere)`

now, we would earn an error, on story of we specified a fee ➌ for a key `:sdf`

, that doesn’t yet exist.

SDF stands for Signed Distance Goal.

That is, a characteristic, that can return the gap from given existing an object.

The space is optimistic when the level is commence air of the thing, and is unfavorable when the level is contained in the thing.

Let’s disclose an SDF for a sphere.

What’s huge about spheres, is that to compute the gap to the sphere’s flooring, we handiest wish to compute distance to the center of the sphere, and subtract sphere’s radius from this distance.

Let’s put in force this:

```
(local sqrt math.sqrt) ➊
(fn sphere-distance [{:pos [sx sy sz] : radius} [x y z]] ➋
(- (sqrt (+ (^ (- sx x) 2) (^ (- sy y) 2) (^ (- sz z) 2)))
radius))
```

For efficiency causes we snort `math.sqrt`

as a `local`

variable `sqrt`

, that holds characteristic fee, to stay a long way from repeated desk search for.

As became once later pointed out, Luajit does optimize such calls, and there is never a repeated search for for technique calls.

Here’s mute ture for undeniable Lua, so I’m going to lend a hand this as is, however it is doubtless you’ll maybe per chance skip all these local definitions while you happen to love to please in and use programs without prolong.

And at ➋ we again perceive destructuring, however now not in the `let`

block, however in the characteristic argument checklist.

What truly happens right here is that this – characteristic takes two parameters, first of which is a hashmap, that can deserve to please in a `:pos`

key phrase linked to a vector of three numbers, and a `:radius`

key phrase with a fee.

2d parameter is purely a vector of three numbers.

We without prolong destructuring these parameters into a living of variables local to the characteristic physique.

Hashmap is being destructured into sphere arena vector, which is without prolong destructured to `sx`

, `sy`

, and `sz`

, and a `radius`

variable storing sphere’s radius.

2d parameter is destructured to `x`

, `y`

, and `z`

.

We then compute the ensuing fee by utilizing the system from above.

Nonetheless, Fennel and Lua handiest understand definitions in the uncover from the cease to the bottom, so we desire to clarify `sphere-distance`

earlier than `sphere`

.

Let’s test our characteristic by passing several features and a sphere of radius 5:

```
>> (sphere-distance (sphere 5) [5 0 0])
0.0
>> (sphere-distance (sphere 5) [0 15 0])
10.0
>> (sphere-distance (sphere 5) [0 0 0])
-5.0
```

Enormous!

First we test if we’re on the sphere’s flooring, since the radius of our sphere is `5`

, and we’ve living `x`

coordinate to `5`

as smartly.

Next we test if we’re `10`

something a long way from the sphere, and lastly we test that we’re *interior* the sphere, on story of sphere’s heart and our level each and every are on the initiating.

However we additionally can name this characteristic as a technique with `: `

syntax:

```
>> (local s (sphere))
>> (s:sdf [0 0 0])
-5
```

This works on story of programs in Lua are a syntactic sugar.

After we write `(s:sdf p)`

it is a long way truly equal to `(s.sdf s p)`

, and our distance characteristic takes sphere because it’s first parameter, which enables us to use technique syntax.

Now we desire a distance estimator – a characteristic that can compute distances to all object and could maybe even neutral return the shortest one, so we could maybe per chance then safely extend our ray by this amount.

```
(local DRAW-DISTANCE 1000)
(fn distance-estimator [point scene]
(var min DRAW-DISTANCE)
(var coloration [0 0 0])
(every [_ object (ipairs scene)]
(let [distance (object:sdf point)]
(when (< distance min)
(set min distance)
(set color (. object :color)))))
(values min color))
```

This function will compute the distance to `each`

object in the `scene`

from given `point`

, using our signed distance functions, and will choose the minimum distance and a color of this ray.

Even though it makes little sense to return color from distance-estimator, we’re doing this here because we don’t want to compute this whole process again just to get the color of the endpoint.

Let’s check if this function works:

```
>> (distance-estimator [5 4 0] [(sphere) (sphere 2 [5 7 0] [0 1 0])])
1.0 [0 1 0]
```

It undoubtedly works, we bought the gap to 2d sphere, and it’s coloration, since the level we’ve specified became once closer to this sphere than to the opposite.

With the digicam, object, a scene, and this characteristic now we delight in all we desire to initiate taking pictures rays and rendering this on display masks masks.

## Marching ray

Correct as in raycaster, we solid rays from the digicam, however now we attain it in 3D home.

In raycasting our horizontal resolution became once specified by an amount of rays, and our vertical resolution became once on the complete infinite.

For 3D right here is now not an option, so our resolution now depends on the 2D matrix of rays, in its put of 1D matrix.

Snappily math.

What number of rays we’ll wish to solid in uncover to occupy up 512 by 448 pixels?

The reply is straightforward – multiply width and height and right here’s the amount of rays you’ll need:

A shimmering `229376`

rays to march.

And every ray has to attain many distance estimations because it marches a long way from the level.

Impulsively, all that micro optimizations, love locals for capabilities attain now not feel that unnecessary.

Let’s hope for doubtlessly the most fine and that LÖVE will address staunch time rendering.

We are in a position to initiate by rising a characteristic that marches single ray in the route our digicam appears to be like.

However first, we desire to clarify what we would use to specify coordinates, directions etc in our 3D home.

My first strive became once to use spherical coordinates to clarify ray route, and transfer features in 3D home slightly to digicam.

Nonetheless it had quite a few problems, especially when objects at angles diversified from 90 levels.

Adore right here’s a screenshot of me the sphere from the “front”:

And right here’s when making an strive from “above”:

And when I’ve added dice object, I’ve observed a *little* fish-perceive distortion terminate:

Which became once now not huge in any appreciate.

So I’ve made up our minds that I would remake every thing with vectors, and kind an ethical digicam, with “undercover agent-at” level, will compute projection plane, etc.

And to attain this now we would like to be in a predicament to work with vectors – add those, multiply, normalize, e.t.c.

I’ve desired to refresh my data on this topic, and made up our minds to now not use any existing library for vectors, and put in force every thing from scratch.

It’s now not that laborious.

Especially when we already delight in vectors in the language, and could maybe even destructure it to variables with ease.

So we desire these total capabilities:

`vec3`

– a constructor with some helpful semantics,`vec-size`

– characteristic that computes magnitude of vector,- arithmetic capabilities, corresponding to
`vec-sub`

,`vec-add`

, and`vec-mul`

, - and other unit vector capabilities, mainly
`normalize`

,`dot-product`

, and`excessive-product`

.

Here’s the provision code of every of those capabilities:

```
(fn vec3 [x y z]
(if (now not x) [0 0 0]
(and (now not y) (now not z)) [x x x]
[x y (or z 0)]))
(fn vec-size [[x y z]]
(sqrt (+ (^ x 2) (^ y 2) (^ z 2))))
(fn vec-sub [[x0 y0 z0] [x1 y1 z1]]
[(- x0 x1) (- y0 y1) (- z0 z1)])
(fn vec-add [[x0 y0 z0] [x1 y1 z1]]
[(+ x0 x1) (+ y0 y1) (+ z0 z1)])
(fn vec-mul [[x0 y0 z0] [x1 y1 z1]]
[(x0 x1) (y0 y1) (z0 z1)])
(fn norm [v]
(let [len (vec-length v)
[x y z] v]
[(/ x len) (/ y len) (/ z len)]))
(fn dot [[x0 y0 z0] [x1 y1 z1]]
(+ (x0 x1) (y0 y1) (z0 z1)))
(fn excessive [[x0 y0 z0] [x1 y1 z1]]
[(- (y0 z1) (z0 y1))
(- (z0 x1) (x0 z1))
(- (x0 y1) (y0 x1))])
```

Since we already know the way destructuring works, it’s now not laborious to perceive what these capabilities attain.

`vec3`

, however, has some logic in it, and likewise it is doubtless you’ll maybe per chance scrutinize that `if`

has three outcomes.

`if`

in Fennel is more love `cond`

in other lisps, meaning that we can specify as many `else if`

as we desire.

Therefore, calling it without arguments produces a nil size vector `[0 0 0]`

.

If known as with one argument, it returns a vector where every coordinate is made up our minds to this argument: `(vec 3)`

will construct `[3 3 3]`

.

In other instances we both specified or now not specified `z`

, so we can simply earn a vector with `x`

, `y`

, and both `0`

or `z`

.

You might want to per chance maybe per chance also neutral shock, why right here is printed as capabilities, and why didn’t I applied operator overloading, so we could maybe per chance simply use `+`

or `*`

to compute values?

I’ve tried this, however right here is highly late, since on every operation now we would like to attain search for in meta-desk, and right here is love undoubtedly late.

Here’s a immediate benchmark:

```
(macro time [body]
`(let [clock# os.clock
start# (clock#)
res# ,body
end# (clock#)]
(print (.. "Elapsed " (1000 (- terminate# initiate#)) " ms"))
res#))
;; operator overloading
(var vector {})
(living vector.__index vector)
(fn vec3-meta [x y z]
(setmetatable [x y z] vector))
(fn vector.__add [[x1 y1 z1] [x2 y2 z2]]
(vec3-meta (+ x1 x2) (+ y1 y2) (+ z1 z2)))
(local v0 (vec3-meta 1 1 1))
(time (for [i 0 1000000] (+ v0 v0 v0 v0)))
;; total capabilities
(fn vec3 [x y z]
[x y z])
(fn vector-add [[x1 y1 z1] [x2 y2 z2]]
(vec3 (+ x1 x2) (+ y1 y2) (+ z1 z2)))
(local v1 (vec3 1 1 1))
(time (for [i 0 1000000] (vector-add (vector-add (vector-add v1 v1) v1) v1)))
```

If we speed it with `lua`

interpreter, we’ll perceive the variation:

```
$ fennel --compile test.fnl | lua
Elapsed 1667.58 ms
Elapsed 1316.078 ms
```

Attempting out this with `luajit`

claims that this system is truly quicker, **however**, I’ve skilled most necessary slowdown in the renderer – every thing ran about 70% slower, basically basically based on the physique per 2d depend.

So capabilities are k, even though are a lot more verbose.

Now we can disclose a `march-ray`

characteristic:

```
(fn transfer-level [point dir distance] ➊
(vec-add level (vec-mul dir (vec3 distance))))
(local MARCH-DELTA 0.0001)
(local MAX-STEPS 500)
(fn march-ray [origin direction scene]
(var steps 0)
(var distance 0)
(var coloration nil)
(var now not-done? upright) ➋
(while now not-done?
(let [➍ (new-distance
new-color) (-> origin
(move-point direction distance)
(distance-estimator scene))]
(when (or (< new-distance MARCH-DELTA)
(>= distance DRAW-DISTANCE)
(> steps MAX-STEPS) ➌)
(living now not-done? untrue))
(living distance (+ distance contemporary-distance))
(living coloration contemporary-coloration)
(living steps (+ steps 1))))
(values distance coloration steps))
```

No longer a lot, however now we delight in some issues to chat about.

First, we disclose a characteristic to transfer level in 3D home ➊.

It accepts a `level`

, which is a 3 dimensional vector, a route vector `dir`

, which could per chance maybe even neutral mute be normalized, and a `distance`

.

We then multiply route vector by a vector that consists of our distances, and add it to the level.

Easy and easy.

Next we disclose several constants, and the `march-ray`

characteristic itself.

It Defines some local vars, that have interaction preliminary values, and uses a `while`

loop to march given ray adequate times.

You might want to per chance maybe per chance also scrutinize, that at ➋ we created a `now not-done?`

var, that holds `upright`

fee, and then use it in the `while`

loop as our test.

And likewise you additionally can scrutinize that at ➌ now we delight in a test, in case of which we `living`

`now not-done?`

to `untrue`

and exit the loop.

So it is doubtless you’ll maybe per chance also neutral shock, why to now not use `for`

loop in its put?

Lua supports index basically basically based for loops.

Fennel additionally has a strengthen for these.

So why use `while`

with a `variable`

?

Because Fennel has no `spoil`

particular invent for some procedure.

Here’s a exiguous of rant.

You can skip it while you happen to’re now not attracted to me making unconfirmed inferences about Fennel :).I judge that Fennel doesn’t strengthen

`spoil`

on story of Fennel is influenced by Clojure (upright me if I’m scandalous), and Clojure doesn’t delight in`spoil`

both.

Nonetheless, looping in Clojure is a exiguous of more controllable, as wespendwhen we desire to scuttle to subsequent iteration:`(loop [i 0] ;; attain stuff (when (< i 10) (recur (+ i 1))))`

Meaning that

`when`

`i`

is much less then`10`

I desire you to avoid losing every other iteration.In Fennel, however, the notion that isn’t quite love this, on story of now we would like to clarify a

`var`

explicitly, and save it into`while`

test arena:`(var i 0) (while (< i 10) ;; attain stuff (living i (+ i 1)))`

You might want to per chance maybe per chance also neutral now not perceive the variation, however I attain.

This additionally could maybe even neutral additionally be trivially expressed as a`for`

loop:`(for [i 0 10] (attain-stuff))`

.

Nonetheless, now not every break could maybe even neutral additionally be outlined as`for`

loop, when we don’t delight in`spoil`

.

And in Clojure we don’t wish to state a variable commence air the loop, since`loop`

does it for us, however the largest difference is right here:`(loop [i 0] (when (or (< i 100) (< (some-foo) 1000)) (recur (inc i))))`

Notice, that we’re looping until

`i`

reaches`100`

,oruntil`some-foo`

returns something greater than 1000.

We can easily express this as`for`

loop in Lua:`for i = 0, 100 do if some_foo() > 1000 then spoil terminate terminate`

Nonetheless we can’t attain the identical in Fennel, on story of there’s no

`spoil`

.

In this case we could maybe per chance disclose`i`

var, save`some_foo() < 1000`

to the`while`

loop test, and then use spoil when`i`

reaches`100`

, love this:`(var i 0) (while (or (< i 100) (< (some-foo) 1000)) (living i (+ i 1)))`

Which is kind of love Clojure example, and likewise it is doubtless you'll maybe per chance also neutral shock why attain I bitch, however in case of

`march-ray`

characteristic we can’t attain this both!

Since the characteristic we name returns a couple of values, which we desire to destructure ➍ to be in a predicament to ascertain those.

Or in some loops such characteristic could maybe even neutral rely upon the context of the loop, so it must be contained in the loop, now not in the test.So now not having

`spoil`

, or means to manipulate when to scuttle to subsequent iteration is a necessary downside.

Yes, Clojure’s`recur`

is additionally exiguous, because it must also neutral mute be in tail arena, so it is doubtless you'll maybe per chance’t use it as`proceed`

or something love that.

However it’s mute a exiguous more highly fine break.

I’ve truly regarded as writing a`loop`

macro, however apparently it’s now not as straightforward to attain in Fennel, as in Clojure, on story of Fennel lacks some in-constructed capabilities to manipulate sequences.

I mean it’s utterly doable, however requires technique too a lot work compared with defining a Boolean`var`

and setting it in the loop.

At ➍ we perceive syntax that I didn’t coated earlier than: `(let [(a b) (foo)] ...)`

.

A kind of us, who familiar with Declare, and particularly Racket would be puzzled.

You perceive, in Racket, and other Procedure implementations (that allow using diversified forms of parentheses) `let`

has this roughly syntax:

```
(let [(a 1) ;; In Scheme square brackets around bindings
(b 41)] ;; are replaced with parentheses
(+ a b))
```

Or more in total, `(let ((name1 value1) (name2 value2) ...) physique)`

.

Nonetheless in case of `march-ray`

characteristic, we perceive a identical invent, excluding 2d ingredient has no fee specified.

Here's again a legitimate syntax in some lisps (General Declare, as an instance), as we can type a binding that holds *nothing* and later `living`

it, however right here is now not what happens in this code, as we don’t use `foo`

in any appreciate:

```
(let [(a b) (foo)]
(+ a b))
```

And, since in Fennel we don’t need parentheses, and simply specify bindings as a vector `[name1 value1 name2 value2 ...]`

, every other that it is doubtless you'll maybe per chance imagine confusion could maybe even neutral happen.

You might want to per chance maybe per chance also neutral judge that `(a b)`

is a characteristic name that returns a `name`

, and `(foo)`

is a characteristic name that produces a `fee`

.

However then we **by hook or by crook** use `a`

and `b`

.

What's taking place right here?

However right here is fine every other roughly destructuring on hand in Fennel.

Lua has 1 smartly-liked data type, known as a desk.

Nonetheless Lua doesn’t delight in any particular syntax for destructuring, so when characteristic wants to advance several values, you've got gotten two alternatives.

First, it is doubtless you'll maybe per chance return a desk:

```
characteristic returns_table(a, b)
return {a, b}
terminate
```

However particular person of such characteristic will wish to earn values out of the desk themselves:

```
local res = returns_table(1, 2)
local a, b = unpack(res) -- or use indexes, e.g. local a = res[1]
print("a: " .. a .. ", b: " .. b)
-- a: 1, b: 2
```

However right here is additional work, and it ties values collectively into an info structure, which could per chance maybe even neutral now not be undoubtedly upright for you.

So Lua has a shorthand for this - it is doubtless you'll maybe per chance return a couple of values:

```
characteristic returns_values(a, b)
return a, b
terminate
local a, b = returns_values(1, 2)
print("a: " .. a .. ", b: " .. b)
-- a: 1, b: 2
```

Here's shorter, and more concise.

Fennel additionally strengthen this multivalue return with `values`

particular invent:

```
(fn returns-values [a b]
(values a b))
```

Here's a a lot like the outdated code, however how will we use these values?

All binding kinds in Fennel strengthen destructuring, so we can write this as:

```
(local (a b) (returns-values 1 2))
(print (.. "a: " a ", b: " b))
;; a: 1, b: 2
```

Same could maybe even neutral additionally be done with vectors or maps when defining, `local`

, `var`

, or `world`

variables:

```
(local [a b c] (returns-vector)) ;; returns [1 2 3]
(var {:x x :y y :z z} (returns-draw)) ;; returns {:x 1 :y 2 :z 3}
(world (bar baz) (returns-values)) ;; returns (values 1 2)
```

And all of this works in `let`

or when defining a characteristic!

OK.

We’ve outlined a characteristic that marches a ray, now we desire to shoot some!

## Taking pictures rays

As with math capabilities, let’s disclose some local definitions somewhere on the cease of the file:

```
(local cherish-features cherish.graphics.features)
(local cherish-dimensions cherish.graphics.getDimensions)
(local cherish-living-coloration cherish.graphics.setColor)
(local cherish-key-pressed? cherish.keyboard.isDown)
(local cherish-earn-joysticks cherish.joystick.getJoysticks)
```

Here's slightly a lot all we’ll need from LÖVE - two capabilities to blueprint colored pixels, one characteristic to earn resolution of the window, and enter handling capabilities for keyboard and gamepad.

We’ll additionally disclose some capabilities in `cherish`

*namespace desk* (IDK the way it is a long way is called smartly in Lua, on story of it is a long way a desk that acts love a namespace) - `cherish.load`

, `cherish.blueprint`

, and others along the technique.

Let’s initiate by initializing our window:

```
(local window-width 512)
(local window-height 448)
(local window-flags {:resizable upright :vsync untrue :minwidth 256 :minheight 224})
(fn cherish.load []
(cherish.window.setTitle "LÖVE Raymarching")
(cherish.window.setMode window-width window-height window-flags))
```

This could per chance even neutral living our window’s default width and height to `512`

by `448`

pixels, and living minimum width and height to `256`

by `224`

pixels respectively.

We additionally add title `"LÖVE Raymarching"`

to our window, however it indubitably is utterly now not fundamental.

Now we can living `cherish.blueprint`

characteristic, which will shoot 1 ray per pixel, and blueprint that pixel with acceptable coloration.

Nonetheless we desire a technique of claiming by which route we desire to shoot our ray.

To disclose the route we can first want a projection plane and a lookat level.

Let’s earn a lookat level as a straightforward zero vector `[0 0 0]`

for now:

Now we desire to know the way we disclose our projection plane.

In our case, projection plane is a plane that is our display masks masks, and our digicam is a few distance a long way from the display masks masks.

We additionally desire to be in a predicament to commerce our self-discipline of perceive, or FOV for rapid, so we desire a technique of computing the gap to projection, since the closer we're to projection plane, the broader our self-discipline of perceive:

We are in a position to without problems compute the gap if now we delight in an angle, which we additionally can disclose as a `var`

:

Now we can compute our projection distance (PD), by utilizing this system:

The put `fov`

is in Radians.

And to compute radians we’ll need this constant:

```
(local RAD (/ math.pi 180.0))
```

Now we can became any angle into radians by multiplying it by this fee.

At this level we know what's the gap to our projection plane, however we don’t comprehend it’s size and arena.

First, we desire a ray initiating (`RO`

), and we already delight in it as our digicam, so our `ro`

could per chance be equal to contemporary fee of `digicam.pos`

.

Next, we desire a scrutinize-at level, and now we delight in it as a `lookat`

variable, which is made up our minds to `[0 0 0]`

.

Now we can disclose a route vector, that can specify our *forward route*:

And with this vector `F`

if we transfer our level the gap that we’ve computed previously, we’ll navigate the center of our projection plane, which we can name `C`

:

Closing thing we would like to know, in uncover to earn our orientation in home, is where is *up* and *ethical*.

We are in a position to compute this by specifying an upward vector and taking a excessive product of it and our forward vector, thus producing a vector that is perpendicular to each and every of those vectors, and pointing to the ethical.

To attain this we desire an up vector, which we disclose love this `[0 0 -1]`

.

You might want to per chance maybe per chance also neutral shock why it is a long way printed with z axis unfavorable, however right here is executed so optimistic z values truly scuttle up as we undercover agent from the digicam, and ethical is to the ethical.

We then compute the ethical vector as follows:

And the up vector `U`

is a excessive product of `R`

and `F`

. Let’s write this down as in `cherish.blueprint`

:

```
(fn cherish.blueprint []
(let [(width height) (love-dimensions)
projection-distance (/ 1 (tan ((/ fov 2) RAD)))
ro camera.pos
f (norm (vec-sub lookat ro))
c (vec-add ro (vec-mul f (vec3 projection-distance)))
r (norm (cross [0 0 -1] f))
u (cross f r)]
nil)) ;; TBD
```

Currently we handiest compute these values, however attain now not use those, hence the `nil`

on the terminate of the `let`

.

However now, as we know where our projection plane is, and where our ethical and up, we can compute the intersection level, where at given `x`

and `y`

coordinates of a plane in unit vector coordinates, thus defining a route vector.

So, `for`

every `x`

from `0`

to `width`

and every `y`

from `0`

to `height`

we can compute a `uv-x`

and `uv-y`

coordinates, and gain the route vector `rd`

.

To gain the `uv-x`

we desire to type obvious it is a long way between `-1`

and `1`

by dividing contemporary `x`

by `width`

and subtracting `0.5`

from it, then multiplying by `x/width`

.

For `uv-y`

we handiest wish to divide contemporary `y`

by height, and subtract `0.5`

:

```
(for [y 0 height]
(for [x 0 width]
(let [uv-x ((- (/ x width) 0.5) (/ width height))
uv-y (- (/ y height) 0.5)]
nil))) ;; TBD
```

Now as now we delight in `uv-x`

and `uv-y`

, we can compute intersection level `i`

, by utilizing the up and ethical vectors and heart of the plane:

And in the break compute our route vector `RD`

:

And now we can use our `march-ray`

route of to compute distance and coloration of the pixel.

Let’s wrap every thing up:

```
(local tan math.tan)
(fn cherish.blueprint []
(let [projection-distance (/ 1 (tan ((/ fov 2) RAD)))
ro camera.pos
f (norm (vec-sub lookat ro))
c (vec-add ro (vec-mul f (vec3 projection-distance)))
r (norm (cross [0 0 -1] f))
u (cross f r)
(width height) (love-dimensions)]
(for [y 0 height]
(for [x 0 width]
(let [uv-x ((- (/ x width) 0.5) (/ width height))
uv-y (- (/ y height) 0.5)
i (vec-add c (vec-add
(vec-mul r (vec3 uv-x))
(vec-mul u (vec3 uv-y))))
rd (norm (vec-sub i ro))
(distance color) (march-ray ro rd scene)]
(if (< distance DRAW-DISTANCE)
(cherish-living-coloration coloration)
(cherish-living-coloration 0 0 0))
(cherish-features x y))))))
```

Now, if we living the `scene`

to possess a default `sphere`

, and arena our digicam at `[20 0 0]`

, we could maybe even neutral mute perceive this:

Which is upright, on story of our default sphere has white as the default coloration.

You might want to per chance maybe per chance also scrutinize, that we compute `distance`

and `coloration`

by calling `(march-ray ro rd scene)`

, and then test if `distance`

is decrease than `DRAW-DISTANCE`

.

If right here is the case, we living pixel’s coloration to the `coloration`

found by `march-ray`

characteristic, in any other case we living it to murky.

Lastly we blueprint the pixel to the display masks masks and repeat complete route of for the next intersection level, thus the next pixel.

However we don’t wish to blueprint murky pixels if we didn’t hit something else!

Consider, that on the initiating I’ve wrote, that if we scuttle journey the thing, we attain many steps, we can use this data to render glow.

So if we alter `cherish.blueprint`

characteristic a exiguous, we would be in a predicament to perceive the glow around our sphere.

And the closer the delighted bought to sphere, the stronger the glow could per chance be:

```
;; relaxation of cherish.blueprint
(let [ ;; rest of love.draw
(distance color steps) (march-ray ro rd scene)]
(if (< distance DRAW-DISTANCE)
(cherish-living-coloration coloration)
(cherish-living-coloration (vec3 (/ steps 100))))
(cherish-features x y))
;; relaxation of cherish.blueprint
```

Here, I’m setting coloration to the amount of steps divided by `100`

, which outcomes in this glow terminate:

Equally to this glow terminate, we can earn a unsuitable ambient occlusion - the more steps we did earlier than hitting the flooring, the more advanced it is a long way, hence much less ambient light could maybe even neutral mute be in a predicament to journey.

Unfortunately doubtlessly the most convenient object now we delight in at this moment is a sphere, so there’s no technique of exhibiting this trick on it, as its flooring isn’t very advanced.

All this could per chance maybe even neutral seem pricey, and it truly is.

Unfortunately Lua doesn’t delight in staunch multithreading to run this up, and threads feature, equipped by LÖVE outcomes in even worse efficiency than computing every thing in single thread.

Nicely at leas the technique I’ve tried it.

There’s a shader DSL in LÖVE, which could per chance maybe per chance be feeble to compute these items on GPU, however right here is currently out of the scope of this venture, as I desired to place in force this in Fennel.

Talking of shaders, now, that we can blueprint pixels on display masks masks, we additionally can coloration those, and compute lighting and reflections!

## Lights and reflections

Sooner than we initiate imposing lighting, let’s add two more objects - a flooring plane, and arbitrary field.

Great love sphere object, we first disclose signed distance characteristic, and then the constructor for the thing:

```
(local abs math.abs)
(fn field-distance [{:pos [box-x box-y box-z]
:dimensions [x-side y-side z-side]}
[x y z]]
(sqrt (+ (^ (max 0 (- (abs (- field-x x)) (/ x-aspect 2))) 2)
(^ (max 0 (- (abs (- field-y y)) (/ y-aspect 2))) 2)
(^ (max 0 (- (abs (- field-z z)) (/ z-aspect 2))) 2))))
(fn field [sides pos color]
(let [[x y z] (or pos [0 0 0])
[x-side y-side z-side] (or sides [10 10 10])
[r g b] (or coloration [1 1 1])]
{:dimensions [(or x-side 10)
(or y-side 10)
(or z-side 10)]
:pos [(or x 0) (or y 0) (or z 0)]
:coloration [(or r 0) (or g 0) (or b 0)]
:sdf field-distance}))
(fn flooring-plane [z color]
(let [[r g b] (or color [1 1 1])]
{:z (or z 0)
:coloration [(or r 0) (or g 0) (or b 0)]
:sdf (fn [plane [_ _ z]] (- z plane.z))}))
```

In case of `flooring-plane`

we incorporate `:sdf`

as a nameless characteristic, on story of it is a long way a easy one-liner.

Now, as now we delight in more objects, let’s add those to the scene and perceive if those work:

```
(var digicam {:pos [20.0 50.0 0.0]
:x-rotate 0.0
:z-rotate 0.0})
(local scene [(sphere nil [-6 0 0] [1 0 0])
(field nil [6 0 0] [0 1 0])
(flooring-plane -10 [0 0 1])])
```

With this `scene`

and `digicam`

we could maybe even neutral mute perceive this:

It’s a exiguous sadistic on the eyes, however we can now not decrease than type obvious every thing works precisely.

Now we can put in force lighting.

In uncover to calculate lighting we’ll wish to know a commonplace to the flooring at level.

Let’s earn `earn-commonplace`

characteristic, that receives the `level`

, and our `scene`

:

```
(fn earn-commonplace [[px py pz] scene]
(let [x MARCH-DELTA
(d) (distance-estimator [px py pz] scene)
(dx) (distance-estimator [(- px x) py pz] scene)
(dy) (distance-estimator [px (- py x) pz] scene)
(dz) (distance-estimator [px py (- pz x)] scene)]
(norm [(- d dx) (- d dy) (- d dz)])))
```

It's a fine trick, since we earn three more features around our genuine level, use existing distance estimation characteristic, and earn a normalized vector of subtraction of every axis from genuine level, with the gap to the contemporary level.

Let’s use this characteristic to earn commonplace for every level, and use commonplace as our coloration:

```
;; relaxation of cherish.blueprint
(if (< distance DRAW-DISTANCE)
(cherish-living-coloration (earn-commonplace (transfer-level ro rd distance) scene))
(cherish-living-coloration 0 0 0))
;; relaxation of cherish.blueprint
```

Witness that in uncover to earn endpoint of our ray we `transfer-level`

`ro`

along the route `rd`

using the computed `distance`

.

We then journey the ensuing level into `earn-commonplace`

, and our `scene`

, thus computing the commonplace vector, which we then journey to `cherish-living-coloration`

, and it provides us this end result:

You might want to per chance maybe per chance also perceive that the `flooring-plane`

remained blue, and this isn’t error. Blue in our case is `[0 0 1]`

, and since in our world, optimistic `z`

coordinates display masks *up*, we can perceive it without prolong in ensuing coloration of the plane.

The pinnacle of the dice and the sphere are additionally blue, and front aspect is inexperienced, meaning that our normals are upright.

Now we can compute total lighting.

For that we’ll want a delicate object:

Let’s earn a `coloration-level`

characteristic, that can accept a `level`

, level `coloration`

, `light`

arena, and a `scene`

:

```
(fn coloration-level [point color light scene]
(vec-mul coloration (vec3 (level-lightness level scene light))))
```

It will also neutral seem that this characteristic’s handiest procedure is to name `level-lightness`

, which we can disclose a exiguous later, and return a contemporary coloration.

And right here is upright, now not decrease than for now.

Let’s earn `level-lightness`

characteristic:

```
(fn clamp [a l t]
(if (< a l) l
(> a t) t
a))
(fn above-flooring-level [point normal]
(vec-add level (vec-mul commonplace (vec3 (MARCH-DELTA 2)))))
(fn level-lightness [point scene light]
(let [normal (get-normal point scene) ➊
light-vec (norm (vec-sub light point))
(distance) (march-ray (above-surface-point point normal) ➋
light-vec
scene)
lightness (clamp (dot light-vec normal) 0 1)] ➌
(if (< distance DRAW-DISTANCE)
(lightness 0.5)
lightness)))
```

What this characteristic does, is straightforward.

We compute the `commonplace`

➊ for given `level`

, then we gain a degree that is gracious above the flooring, using `above-flooring-level`

characteristic ➋.

And we use this level as our contemporary ray initiating to march in direction of the `light`

.

We then earn the `distance`

from the `march-ray`

characteristic, and test if we’ve went the complete technique to the max distance or now not.

If now not, this system that there became once a success, and we divide complete `lightness`

by 2 thus rising a shadow.

In the opposite case we return `lightness`

as is.

And `lightness`

is a dot product between `light-vec`

and `commonplace`

to the flooring ➌, where `light-vec`

is a normalized vector from the `level`

to the `light`

.

If we again alter our `cherish.blueprint`

characteristic love this:

```
;; relaxation of cherish.blueprint
(if (< distance DRAW-DISTANCE)
(let [point (move-point ro rd distance)]
(cherish-living-coloration (coloration-level level coloration scene light)))
(cherish-living-coloration 0 0 0))
;; relaxation of cherish.blueprint
```

We are in a position to also neutral mute perceive the shadows:

This already appears to be like love staunch 3D, and it is a long way.

However we can attain a exiguous more, so let’s add reflections.

Let’s earn a `reflection-coloration`

characteristic:

```
(var reflection-depend 3)
(fn reflection-coloration [color point direction scene light]
(var [color p d i n] [color point direction 0 (get-normal point scene)]) ➊
(var now not-done? upright)
(while (and (< i reflection-depend) now not-done?)
(let [r (vec-sub d (vec-mul (vec-mul (vec3 (dot d n)) n) [2 2 2])) ➋
(distance contemporary-coloration) (march-ray (above-flooring-level p n) r scene)] ➌
(if (< distance DRAW-DISTANCE)
(do (set p (move-point p r distance))
(set n (get-normal p scene))
(set d r) ➍
(let [[r0 g0 b0] color
[r1 g1 b1] new-color
l (/ (point-lightness p scene light) 2)]
(set color [((+ r0 (r1 l)) 0.66)
((+ g0 (g1 l)) 0.66)
((+ b0 (b1 l)) 0.66)]) ➎))
(set not-done? false) ➏))
(set i (+ i 1)) ➐)
color)
```

This is quite big function, so let’s look at it piece by piece.

First, we use destructuring to define several `vars`

➊, that we will be able to change using `set`

later in the function.

Next we go into `while`

loop, which checks both for maximum reflections reached, and if we the ray went to infinity.

First thing we do in the loop, is computing the reflection vector `r`

➋, by using this formula:

This is our new direction, which we will march from new `above-surface-point`

➌.

If we’ve hit something, and our `distance`

will be less than `DRAW-DISTANCE`

, we’ll `set`

our point `p`

to new point, compute new normal `n`

, and set direction `d`

to previous direction, which was reflection vector `r`

➍.

Next we compute the resulting color.

I’m doing a simple color addition here, which is not entirely correct way of doing it, but for now I’m fine with that.

We also compute `lightness`

of the reflection point, and divide it by `2`

, so our reflections appear slightly darker.

Then we add each channel and make sure it is not greater than `1`

, by multiplying it by `0.66`

➎.

The trick here, is that maximum `lightness`

we can get is `0.5`

, so if we add two values, one of which is multiplied by `0.5`

overall result can be averaged by multiplying by `0.66`

.

This way we not loosing brightness all the way, and reflection color blends with original color nicely.

In case if we don’t hit anything, it means that this is final reflection, therefore we can end ➏ the `while`

loop on this iteration.

Lastly, since I’ve already ranted on the absence of `break`

in Fennel, we have to increase loop counter manually ➐ at the end of the loop.

Let’s change `shade-point`

so it will pass color into this function:

```
(fn shade-point [point color direction scene light]
(-> coloration
(vec-mul (vec3 (level-lightness level scene light)))
(reflection-coloration level route scene light)))
```

You might want to per chance maybe per chance also scrutinize that I’ve added `route`

parameter, as we desire it for computing reflections, so we additionally wish to commerce the resolution to `coloration-level`

in `cherish.blueprint`

characteristic:

```
;; relaxation of cherish.blueprint
(if (< distance DRAW-DISTANCE)
(let [point (move-point ro rd distance)]
(cherish-living-coloration (coloration-level level coloration rd scene light))) ;; rd is our preliminary route
(cherish-living-coloration 0 0 0))
;; relaxation of cherish.blueprint
```

Let’s strive this out (I’ve brought `flooring-plane`

a exiguous closer to objects so we could maybe per chance better perceive reflections):

We are in a position to perceive reflections, and reflections of reflections in reflections, on story of previously we’ve living `reflection-depend`

to `3`

.

Currently our reflections are pure mirrors, as we mediate every thing at a perfect angle, and shapes seem gracious as staunch objects.

This could per chance per chance also be modified by introducing materials, that delight in diversified qualities love roughness, and by utilizing a a lot bigger reflection algorithms love Phong shading, however perchance subsequent time.

Refractions additionally kinda need materials, as refraction angle could maybe even neutral additionally be diversified, relying on what roughly material it goes through.

E.g. glass and mute pool of water could maybe even neutral mute delight in diversified refraction angle.

And a few surfaces could maybe even neutral mute mediate rays at obvious angles, and allow them to struggle through at other angles, which will additionally require obvious modifications in reflection algorithm.

Now, if we would living our `digicam`

, `lookat`

, and `light`

to:

```
(local lookat [19.75 49 19.74])
(var digicam {:pos [20 50 20]
:x-rotate 0
:z-rotate 0})
(local scene [(box [5 5 5] [-2.7 -2 2.5] [0.79 0.69 0.59])
(field [5 5 5] [2.7 2 2.5] [0.75 0.08 0.66])
(field [5 5 5] [0 0 7.5] [0.33 0.73 0.42])
(sphere 2.5 [-2.7 2.5 2.5] [0.56 0.11 0.05])
(sphere 10 [6 -20 10] [0.97 0.71 0.17])
(flooring-plane 0 [0.97 0.27 0.35])])
```

We could maybe per chance perceive an image from the initiating of this submit:

For now, I’m slightly joyful with contemporary end result, so lastly let’s type it that it is doubtless you'll maybe per chance imagine to transfer in our 3D home.

## Individual enter

We’ll be doing two diversified programs of appealing in our scene - with keyboard and gamepad.

The adaptation largely is in the reality, that gamepad can give us floating level values, so we can transfer slower or quicker relying on how we transfer the analogs.

We’ve already specified wanted capabilities from LÖVE as our locals, however to recap, we’ll need handiest two:

```
(local cherish-key-pressed? cherish.keyboard.isDown)
(local cherish-earn-joysticks cherish.joystick.getJoysticks)
```

However first, we’ll wish to type modifications to our `digicam`

, as currently it must handiest undercover agent on the initiating.

How will we compute the undercover agent at level for our digicam so we would be in a predicament to transfer it around in a most necessary technique?

I’ve made up our minds that a upright technique could per chance be to “transfer” digicam forward a obvious amount, and then rotate this level around digicam by utilizing some angles.

Luckily for us, we’ve already specified that our `digicam`

has two angles `:x-rotate`

, and `z-rotate`

:

```
(var digicam {:pos [20 50 20]
:x-rotate 255
:z-rotate 15})
```

And it is a long way additionally declared as a `var`

, meaning that we can `living`

contemporary values into it.

Let’s write a characteristic that can compute a contemporary `lookat`

level for contemporary `digicam`

arena and rotation:

```
(local cos math.cos)
(local sin math.sin)
(fn rotate-level [[x y z] [ax ay az] x-angle z-angle]
(let [x (- x ax)
y (- y ay)
z (- z az)
x-angle (x-angle RAD)
z-angle (z-angle RAD)
cos-x (cos x-angle)
sin-x (sin x-angle)
cos-z (cos z-angle)
sin-z (sin z-angle)]
[(+ (cos-x cos-z x) ((- sin-x) y) (cos-x sin-z z) ax)
(+ (sin-x cos-z x) (cos-x y) (- (sin-x sin-z z)) ay)
(+ ((- sin-z) x) (cos-z z) az)]))
(fn forward-vec [camera]
(let [pos camera.pos]
(rotate-level (vec-add pos [1 0 0]) pos digicam.x-rotate digicam.z-rotate)))
```

First characteristic `rotate-level`

will rotate one level around every other level by utilizing two levels.

It's a long way basically basically based on plane most necessary axes, however we handiest delight in two axes, so we attain now not wish to “roll”, hence we attain exiguous much less computations right here.

Next is the `forward-vec`

characteristic, that computes contemporary “forward” vector for `digicam`

.

Ahead in this case technique the route digicam is “going through”, which is basically basically based on two angles we specify in the `digicam`

.

With this characteristic we can put in force total movement and rotation capabilities for digicam:

```
(fn digicam-forward [n]
(let [dir (norm (vec-sub (forward-vec camera) camera.pos))]
(living digicam.pos (transfer-level digicam.pos dir n))))
(fn digicam-elevate [n]
(living digicam.pos (vec-add digicam.pos [0 0 n])))
(fn digicam-rotate-x [x]
(living digicam.x-rotate (% (- digicam.x-rotate x) 360)))
(fn digicam-rotate-z [z]
(living digicam.z-rotate (clamp (+ digicam.z-rotate z) -89.9 89.9)))
(fn digicam-strafe [x]
(let [z-rotate camera.z-rotate]
(living digicam.z-rotate 0)
(digicam-rotate-x 90)
(digicam-forward x)
(digicam-rotate-x -90)
(living digicam.z-rotate z-rotate)))
```

And if we alter our `cherish.blueprint`

again, we’ll be in a predicament to use our computed lookat level as follows:

```
(fn cherish.blueprint []
(let [;; relaxation of cherish.blueprint
lookat (forward-vec digicam)
;; relaxation of cherish.blueprint
```

Now we don’t want a world `lookat`

variable, and it is a long way truly adequate for us to compute contemporary `lookat`

every physique.

As for movement, let’s put in force a straightforward keyboard handler:

```
(fn address-keyboard-enter []
(if (cherish-key-pressed? "w") (digicam-forward 1)
(cherish-key-pressed? "s") (digicam-forward -1))
(if (cherish-key-pressed? "d")
(if (cherish-key-pressed? "lshift")
(digicam-strafe 1)
(digicam-rotate-x 1))
(cherish-key-pressed? "a")
(if (cherish-key-pressed? "lshift")
(digicam-strafe -1)
(digicam-rotate-x -1)))
(if (cherish-key-pressed? "q") (digicam-rotate-z 1)
(cherish-key-pressed? "e") (digicam-rotate-z -1))
(if (cherish-key-pressed? "r") (digicam-elevate 1)
(cherish-key-pressed? "f") (digicam-elevate -1)))
```

Equally we can put in force a controller strengthen:

```
(fn address-controller []
(when gamepad
(let [lstick-x (gamepad:getGamepadAxis "leftx")
lstick-y (gamepad:getGamepadAxis "lefty")
l2 (gamepad:getGamepadAxis "triggerleft")
rstick-x (gamepad:getGamepadAxis "rightx")
rstick-y (gamepad:getGamepadAxis "righty")
r2 (gamepad:getGamepadAxis "triggerright")]
(when (and lstick-y (or (< lstick-y -0.2) (> lstick-y 0.2)))
(digicam-forward (2 (- lstick-y))))
(when (and lstick-x (or (< lstick-x -0.2) (> lstick-x 0.2)))
(digicam-strafe (2 lstick-x)))
(when (and rstick-x (or (< rstick-x -0.2) (> rstick-x 0.2)))
(digicam-rotate-x (4 rstick-x)))
(when (and rstick-y (or (< rstick-y -0.2) (> rstick-y 0.2)))
(digicam-rotate-z (4 rstick-y)))
(when (and r2 (> r2 -0.8))
(digicam-elevate (+ 1 r2)))
(when (and l2 (> l2 -0.8))
(digicam-elevate (- (+ 1 l2)))))))
```

Correct for controller we type obvious that our `l2`

and `r2`

axes are from 0 to 2, since by default these axes are from `-1`

to `1`

, which isn’t going to work for us.

Equally to this we can add means to commerce self-discipline of perceive, or reflection depend, however I’ll leave this out for individuals who attracted to making an strive it themselves.

It’s now not laborious.

As a closing piece, we desire to detect if controller became once inserted, and address keys somewhere.

So let’s add these two closing capabilities that we desire for every thing to work:

```
(var gamepad nil)
(fn cherish.joystickadded [g]
(living gamepad g))
(fn cherish.change [dt]
(address-keyboard-enter)
(address-controller))
```

`cherish.joystickadded`

will accumulate care of awaiting save spanking contemporary controllers, and `cherish.change`

will question for save spanking contemporary enter once shortly.

By this moment we could maybe even neutral mute delight in a working raymarching 3D renderer with total lighting and reflections!

## Closing thoughts

I’ve made up our minds to jot down this submit on story of I became once attracted to three matters:

- Fennel, a Declare love language, which is so a lot love Clojure syntax-wise, and has huge interop with Lua (on story of it IS Lua)
- LÖVE, a fine sport engine I’ve been awaiting a extraordinarily long time already, and performed some games written with it, which were quite awesome,
- and Lua itself, a fine, rapidly scripting language, with wintry notion that every thing is a desk.

Even supposing I didn’t use a lot of Lua right here, I’ve truly tinkered with it so a lot accurate through complete route of, sorting out diversified issues, studying Fennel’s compiler output, and benchmarking diversified constructs, love self-discipline earn accurate of entry to, or unpacking numeric tables versus a couple of return values.

Lua has some undoubtedly wintry semantics of defining modules as tables, and incorporating particular intending to tables through `setmetatable`

, which is extraordinarily straightforward to know in my perceive.

Fennel is a large alternative while you happen to don’t desire to be taught Lua syntax (which is shrimp, however, you respect, it *exists*).

For me, Fennel is a large language, on story of I don’t wish to address Lua syntax AND on story of I will be able to jot down macros.

And even though I didn’t wrote any macro for this venture, on story of every thing is already presented in Fennel itself, the doable of doing this price something.

Also, accurate through benchmarking diversified features, I’ve feeble self-written `time`

macro:

```
(macro time [body]
`(let [clock# os.clock
start# (clock#)
res# ,body
end# (clock#)]
(print (.. "Elapsed: " (1000 (- terminate# initiate#)) " ms"))
res#))
```

So means to clarify such issues is a upright thing.

LÖVE is a large engine, and though I’ve feeble a extraordinarily exiguous little bit of it, I mute judge that right here is a terribly wintry venture, on story of there is so a lot more in it.

Presumably some day I’ll type a sport that can label LÖVE’s fat doable.

On a downside display masks…

The following raymarching is **very late**.

I’ve managed to earn around 25 FPS for a single object in the scene, and a 256 by 224 pixel resolution.

Yes, right here is on story of it runs in a single thread, and does quite a few pricey computations.

Lua itself isn’t a extraordinarily rapidly language, and even though LÖVE uses Luajit - a first rate in time compiler that emits machine code, it’s mute now not rapidly adequate for obvious operations, or tactics.

Shall we scream, if we put in force operator overloading for or vectors we’ll free quite a few efficiency for constant desk lookups.

Here's an existing dilemma in Lua, because it does it’s simplest of being shrimp and embeddable, so it could per chance maybe per chance work nearly on something else, due to the this reality it doesn’t attain quite a few caching and optimizations.

However hiya, right here is a raymarching in ~350 traces of code with some wintry tips love destructuring!

I’m beautiful with outcomes.

A slightly more polished version of the code from this article is on hand at this repository, so if something else doesn’t work in the code above, otherwise you bought lost and gracious desire to play with closing end result, you respect where to scuttle 🙂

Till subsequent time, and thanks for studying!