April 20, 2020

Raytraclj, a raytracer in Clojure

I was preparing an article about Clojure and buddy (it is coming) and then my friend David told me:

You already know your backend, APIs and stuff. Why don’t you get out of your comfort zone and do some 3D.

He was right 🤠

I thought about writing a raytracer because it’s cool and I know nothing, so I searched on the web and found this gem named Ray Tracing in One Weekend.

Then I told my friend David, I’m gonna write this raytracer but in Clojure and he told me:

Dude I already sent you this book two days ago.

Fair enough, so I just launched IntelliJ and started to code.

As the book suggests, it took me the weekend. But hey, it was a lot of fun, learned a lot (and forgot pretty quickly 😅, I wouldn’t be able to come up with all these formulas by heart). But it opens my perspective on other fields in IT.

OMG this is way harder to get right than backends! I had some problem of reflections, how do you debug that? ahah so much fun. I’ve thought multiple times boy you’re so dumb, and I think I am 🤪.

The code is on agrison/raytraclj, I’ll just post the latest version I’ve committed below.

The final scene from the first book takes around 35 minutes to render on my computer (Ryzen 9 3900X) with multi-threading enabled.

So this is fairly slow, the C++ implementation in the book took around 14 minutes. I did not try to improve that much the performance. Just tinkered with Aparapi to move some computations on the GPU but was not able to. I should look at neanderthal, maybe it can help, I don’t know.

All in all, just do it if you have some time, it was a cool experiment, and the book is a gem ❤.


Someone pointed me to the clojure2d project on Github (via Reddit) and digging in it I fount that it contains an implementation of the same ray tracer. The implementation in there is way faster than mine (based on fastmaths) and it has real-time rendering on an image canvas.

You can take a look at it over there: https://github.com/Clojure2D/clojure2d-examples/tree/master/src/rt_in_weekend

Just be sure to change map to pmap at line 80 of file ch12_random_scene.clj, it’s like 5 to 6 times faster and it renders on a canvas view in real time, really great work!

I definitely need to change my code to use fastmaths to see what improvements it gives!

Until next time!


(ns me.grison.raytraclj.camera
  (:require [me.grison.raytraclj.ray :as ray]
            [me.grison.raytraclj.vec :as vec]))

(defn random-in-unit-disk []
  (loop [p (vec/- (vec/* [(rand) (rand) 0] 2) [1 1 0])]
    (if (< (vec/ p p) 1)
      (recur (vec/- (vec/* [(rand) (rand) 0] 2) [1 1 0])))))

(defn make [look-from look-at vup vfov aspect aperture focus-dist]
  (let [lens-radius (/ aperture 2)
        theta (/ (* vfov Math/PI) 180)
        half-height (Math/tan (/ theta 2))
        half-width (* aspect half-height)
        origin look-from
        w (vec/unit-vector (vec/- look-from look-at))
        u (vec/unit-vector (vec/ vup w))
        v (vec/ w u)
        lower-left-corner (vec/- (vec/- (vec/- origin
                                               (vec/* u (* half-width focus-dist)))
                                        (vec/* v (* half-height focus-dist)))
                                 (vec/* w focus-dist))
        horizontal (vec/* u (* 2 half-width focus-dist))
        vertical (vec/* v (* 2 half-height focus-dist))]
    {:lower-left-corner lower-left-corner
     :horizontal        horizontal
     :vertical          vertical
     :origin            origin
     :lens-radius       lens-radius
     :u                 u
     :v                 v
     :w                 w}))

(defn get-ray [{:keys [lower-left-corner horizontal vertical
                       origin lens-radius u v]} s t]
  (let [rd (vec/* (random-in-unit-disk) lens-radius)
        offset (vec/+ (vec/* u (vec/x rd)) (vec/* v (vec/y rd)))]
    (ray/make (vec/+ origin offset)
              (vec/+ lower-left-corner
                     (vec/- (vec/- (vec/+ (vec/* horizontal s) (vec/* vertical t))


(ns me.grison.raytraclj.hitable
  (:require [me.grison.raytraclj.vec :as vec]
            [me.grison.raytraclj.ray :as ray]))

(defprotocol Hitable
  (hit [this r t-min t-max]))

(defn hit-record [r t center radius material]
  (let [p (ray/point-at-parameter r t)]
    {:t t :p p :normal (vec// (vec/- p center) radius) :material material}))

(defrecord Sphere [center radius material]
  (hit [this r t-min t-max]
    (let [oc (vec/- (ray/origin r) (:center this))
          a (vec/squared-length (ray/direction r))
          half-b (vec/ oc (ray/direction r))
          c (- (vec/squared-length oc) (* (:radius this) (:radius this)))
          discriminant (- (* half-b half-b) (* a c))]
      (when (pos? discriminant)
        (let [root (Math/sqrt discriminant)
              temp (/ (- (- half-b) root) a)]
          (if (and (< temp t-max) (> temp t-min))
            (hit-record r temp (:center this) (:radius this) (:material this))
            (let [temp (/ (+ (- half-b) root) a)]
              (when (and (< temp t-max) (> temp t-min))
                (hit-record r temp (:center this) (:radius this) (:material this))))))))))

(defn hits [world r t-min t-max]
  (let [closest-so-far (atom t-max)
        record (atom nil)]
    (doseq [i (range 0 (count world))]
        (if-let [rec (hit (get world i) r t-min @closest-so-far)]
            (reset! closest-so-far (:t rec))
            (reset! record rec)))))


(ns me.grison.raytraclj.material
  (:require [me.grison.raytraclj.vec :as vec]
            [me.grison.raytraclj.ray :as ray]))

(defn random-in-unit-sphere []
  (loop [p (vec/- (vec/* [(rand) (rand) (rand)] 2.0) [1.0 1.0 1.0])]
    (if (> (vec/squared-length p) 1.0)
      (recur (vec/- (vec/* [(rand) (rand) (rand)] 2.0) [1.0 1.0 1.0])))))

(defprotocol Material
  (scatter [this r-in rec]))

(defrecord Lambertian [a]
  (scatter [this r-in rec]
    (let [target (vec/+ (vec/+ (:p rec) (:normal rec)) (random-in-unit-sphere))
          scattered (ray/make (:p rec) (vec/- target (:p rec)))]
      {:ok true :attenuation (:a this) :scattered scattered})))

(defrecord Metal [a f]
  (scatter [this r-in rec]
    (let [fuzz (if (< f 1) f 1)
          reflected (vec/reflect (vec/unit-vector (:direction r-in)) (:normal rec))
          scattered (ray/make (:p rec) (vec/+ reflected (vec/* (random-in-unit-sphere) fuzz)))
          final (vec/ (:direction scattered) (:normal rec))]
      {:ok (pos? final) :attenuation (:a this) :scattered scattered})))

(defn schlick [cosine ref-idx]
  (let [r0 (/ (- 1 ref-idx)
              (+ 1 ref-idx))
        r0 (* r0 r0)]
    (+ r0 (* (- 1 r0)
             (Math/pow (- 1 cosine) 5)))))

(defrecord Dielectric [ref-idx]
  (scatter [this r-in rec]
    (let [reflected (vec/reflect (:direction r-in) (:normal rec))
          attenuation [1.0 1.0 1.0]
          dot-dir-normal (vec/ (:direction r-in) (:normal rec))
          ni-over-nt (if (pos? dot-dir-normal)
                       (:ref-idx this)
                       (/ 1.0 (:ref-idx this)))
          outward-normal (if (pos? dot-dir-normal)
                           (vec/- [0 0 0] (:normal rec))
                           (:normal rec))
          cosine (if (pos? dot-dir-normal)
                   (/ (* (:ref-idx this) (vec/ (:direction r-in) (:normal rec)))
                      (vec/length (:direction r-in)))
                   (/ (- (vec/ (:direction r-in) (:normal rec)))
                      (vec/length (:direction r-in))))
          refracted (vec/refract (:direction r-in) outward-normal ni-over-nt)
          reflect-prob (if (not (nil? refracted))
                         (schlick cosine (:ref-idx this))
      (if (< (rand) reflect-prob)
        {:ok true :attenuation attenuation :scattered (ray/make (:p rec) reflected)}
        {:ok true :attenuation attenuation :scattered (ray/make (:p rec) refracted)}))))


(ns me.grison.raytraclj.ray
  (:require [me.grison.raytraclj.vec :as vec]))

(defn make
  [origin direction]
  {:origin origin :direction direction})

(defn origin [ray]
  (:origin ray))

(defn direction [ray]
  (:direction ray))

(defn point-at-parameter
  [ray t]
  (vec/+ (origin ray)
         (vec/* (direction ray) t)))

(defn hit-sphere
  [center radius {:keys [origin direction]}]
  (let [oc (vec/- origin center)
        a (vec/ direction direction)
        b (* 2.0 (vec/ oc direction))
        c (- (vec/ oc oc) (* radius radius))
        discriminant (- (* b b) (* 4 a c))]
    (if (neg? discriminant)
      (/ (- (- b)
            (Math/sqrt discriminant))
         (* 2.0 a)))))


(ns me.grison.raytraclj.vec
  (:require [clojure.core :as clj]))

(defn mute [op
            [^float x1 ^float y1 ^float z1]
            [^float x2 ^float y2 ^float z2]]
  [(op x1 x2) (op y1 y2) (op z1 z2)])

(defn + [v1 v2]
  (mute clj/+ v1 v2))

(defn - [v1 v2]
  (if (number? v2)
    (map #(clj/- v2 %) v1)
    (mute clj/- v1 v2)))

(defn * [v1 v2]
  (if (number? v2)
    (map #(clj/* v2 %) v1)
    (mute clj/* v1 v2)))

(defn / [v1 v2]
  (if (number? v2)
    (if (zero? v2)
      (* v1 (clj// 1 v2)))
    (mute clj// v1 v2)))

(defn  [v1 v2]
  (reduce clj/+ (* v1 v2)))

(defn  [[x1 y1 z1] [x2 y2 z3]]
  [(clj/- (clj/* y1 z3) (clj/* z1 y2))
   (clj/- (clj/* z1 x2) (clj/* x1 z3))
   (clj/- (clj/* x1 y2) (clj/* y1 x2))])

(defn squared-length [[x y z]]
  (clj/+ (clj/* x x) (clj/* y y) (clj/* z z)))

(defn length [v]
  (Math/sqrt (squared-length v)))

(defn unit-vector [v]
  (let [l (length v)]
    (map #(clj// % l) v)))

(defn x [v]
  (first v))

(defn y [v]
  (second v))

(defn z [v]
  (last v))

(defn reflect [v n]
  (let [m (* n (clj/* ( v n) 2))]
    (- v m)))

(defn refract [v n ni-over-nt]
  (let [uv (unit-vector v)
        dt ( uv n)
        discriminant (clj/- 1.0
                        (clj/* ni-over-nt ni-over-nt (clj/- 1 (clj/* dt dt))))]
    (when (pos? discriminant)
      (let [uv-ndt (- uv (* n dt))
            n-discrim (* n (Math/sqrt discriminant))]
        (- (* uv-ndt ni-over-nt) n-discrim)))))

Alexandre Grison - //grison.me - @algrison