@@ -56,6 +56,7 @@ struct Trace

 {

     float    distance;

     Material material;

+    vec3     miss;

 };

 //// Circle

@@ -69,15 +70,20 @@ struct Circle

         auto const offs = center - ray.origin;

         auto const proj = dot(offs, ray.direction);

         if (proj < 0.0F) // Past.

-            return {infinity, {}};

+            return {infinity, {}, {}};

         auto const perp2 = dot(offs, offs) - proj * proj;

         auto const pene2 = radius * radius - perp2;

         if (pene2 < 0.0F) // Miss.

-            return {infinity, {}};

+        {

+            auto const poin = ray.point(proj);

+            auto const rati = 1.0F - radius * inversesqrt(perp2);

+            auto const miss = rati * (center - poin);

+            return {proj, material, miss};

+        }

         auto const dist = proj - sqrt(pene2);

         if (dist < 0.0F) // Inside.

-            return {infinity, {}};

-        return {dist, material};

+            return {infinity, {}, {}};

+        return {dist, material, vec3(0.0F)};

     }

 };

@@ -91,7 +97,7 @@ struct Scene

     Shapes   shapes;

     Trace trace(Ray const & ray) const

     {

-        auto nearest = Trace{infinity, background};

+        auto nearest = Trace{infinity, background, {}};

         for (auto const & shape : shapes)

         {

             auto const trace = shape.trace(ray);

@@ -122,6 +128,16 @@ struct Camera

         auto const direction = normalize(world.xyz() - position);

         return Ray{position, direction};

     }

+    vec2 project(uvec2 const & size, vec3 const & point) const

+    {

+        auto const aspect   = (float)size.x / (float)size.y;

+        auto const viewport = uvec4(0, 0, size);

+        auto const up       = vec3(0.0F, 1.0F, 0.0F);

+        auto const view     = glm::lookAt(position, target, up);

+        auto const proj     = glm::perspective(fovy, aspect, near, far);

+        auto const window   = glm::project(point, view, proj, viewport);

+        return window.xy();

+    }

 };

 //// ACES

@@ -220,6 +236,15 @@ int main(int argc, char const * argv[])

         {

             auto trace = scene.trace(ray);

             auto color = trace.material.color;

+            if (trace.miss != vec3(0.0F))

+            {

+                auto const point = ray.point(trace.distance);

+                auto const dist  = distance(

+                    camera.project(size, point),

+                    camera.project(size, point + trace.miss)

+                );

+                color.a *= 1.0F - clamp(dist, 0.0F, 1.0F);

+            }

             rgb   += color.rgb() * color.a * trans;

             trans *= 1.0F - color.a;

             if (trace.distance == infinity || trans == 0.0F)

@@ -25,6 +25,7 @@ using namespace glm;

 /// Constants

 auto const infinity = std::numeric_limits<float>::infinity();

+auto const delta    = 0.001F;

 /// Types

@@ -34,12 +35,20 @@ struct Ray

 {

     vec3 origin;

     vec3 direction;

+    vec3 point(float distance) const

+    {

+        return origin + direction * distance;

+    }

+    Ray resumed(float distance)

+    {

+        return {point(distance), direction};

+    }

 };

 //// Material

 struct Material

 {

-    vec3 color;

+    vec4 color;

 };

 //// Trace

@@ -191,24 +200,34 @@ int main(int argc, char const * argv[])

     };

     auto const scene = Scene{

         // background

-        {vec3(0.2F, 0.2F, 0.5F)},

+        {vec4(0.2F, 0.2F, 0.5F, 0.5F)},

         // shapes

         {

-            {vec3( 2.0F, -1.0F, -10.0F), 3.0F, {vec3(1.0F, 0.0F, 0.0F)}},

-            {vec3( 1.0F,  2.0F,  -7.0F), 2.0F, {vec3(0.0F, 1.0F, 0.0F)}},

-            {vec3(-1.0F,  0.0F,  -4.0F), 1.0F, {vec3(0.0F, 0.0F, 1.0F)}},

-            {vec3( 0.0F, -1.0F,  -3.0F), 0.2F, {vec3(0.0F, 1.0F, 1.0F)}},

+            {vec3( 2.0F, -1.0F, -10.0F), 3.0F, {vec4(1.0F, 0.0F, 0.0F, 1.0F)}},

+            {vec3( 1.0F,  2.0F,  -7.0F), 2.0F, {vec4(0.0F, 1.0F, 0.0F, 1.0F)}},

+            {vec3(-1.0F,  0.0F,  -4.0F), 1.0F, {vec4(0.0F, 0.0F, 1.0F, 1.0F)}},

+            {vec3( 0.0F, -1.0F,  -3.0F), 0.2F, {vec4(0.0F, 1.0F, 1.0F, 0.5F)}},

         },

     };

     auto const tonemap = ACES{vec3(1.0F)};

     auto const output  = TGA{uvec2(640, 480), path};

     //// Render

     output.render([&](uvec2 const & size, uvec2 const & pixel) {

-        auto const ray   = camera.ray(size, pixel);

-        auto const trace = scene.trace(ray);

-        auto const rgb   = trace.material.color;

-        auto const srgb  = convertLinearToSRGB(tonemap.transform(rgb));

-        auto const alpha = 1.0F;

+        auto rgb   = vec3(0.0F); // Pre-multiplied alpha (opacity).

+        auto trans = 1.0F;       // 1 - alpha (opacity).

+        auto ray   = camera.ray(size, pixel);

+        while (true)

+        {

+            auto trace = scene.trace(ray);

+            auto color = trace.material.color;

+            rgb   += color.rgb() * color.a * trans;

+            trans *= 1.0F - color.a;

+            if (trace.distance == infinity || trans == 0.0F)

+                break;

+            ray = ray.resumed(trace.distance + delta);

+        }

+        auto const alpha = 1.0F - trans;

+        auto const srgb  = convertLinearToSRGB(tonemap.transform(rgb / alpha));

         return vec4(srgb, alpha);

     });

 }

@@ -36,31 +36,39 @@ struct Ray

     vec3 direction;

 };

+//// Material

+struct Material

+{

+    vec3 color;

+};

+

 //// Trace

 struct Trace

 {

-    float distance;

+    float    distance;

+    Material material;

 };

 //// Circle

 struct Circle

 {

-    vec3  center;

-    float radius;

+    vec3     center;

+    float    radius;

+    Material material;

     Trace trace(Ray const & ray) const

     {

         auto const offs = center - ray.origin;

         auto const proj = dot(offs, ray.direction);

         if (proj < 0.0F) // Past.

-            return {infinity};

+            return {infinity, {}};

         auto const perp2 = dot(offs, offs) - proj * proj;

         auto const pene2 = radius * radius - perp2;

         if (pene2 < 0.0F) // Miss.

-            return {infinity};

+            return {infinity, {}};

         auto const dist = proj - sqrt(pene2);

         if (dist < 0.0F) // Inside.

-            return {infinity};

-        return {dist};

+            return {infinity, {}};

+        return {dist, material};

     }

 };

@@ -70,10 +78,11 @@ using Shapes = std::vector<Circle>;

 //// Scene

 struct Scene

 {

-    Shapes shapes;

+    Material background;

+    Shapes   shapes;

     Trace trace(Ray const & ray) const

     {

-        auto nearest = Trace{infinity};

+        auto nearest = Trace{infinity, background};

         for (auto const & shape : shapes)

         {

             auto const trace = shape.trace(ray);

@@ -181,12 +190,14 @@ int main(int argc, char const * argv[])

         100.0F,                  // far

     };

     auto const scene = Scene{

+        // background

+        {vec3(0.2F, 0.2F, 0.5F)},

         // shapes

         {

-            {vec3( 2.0F, -1.0F, -10.0F), 3.0F},

-            {vec3( 1.0F,  2.0F,  -7.0F), 2.0F},

-            {vec3(-1.0F,  0.0F,  -4.0F), 1.0F},

-            {vec3( 0.0F, -1.0F,  -3.0F), 0.2F},

+            {vec3( 2.0F, -1.0F, -10.0F), 3.0F, {vec3(1.0F, 0.0F, 0.0F)}},

+            {vec3( 1.0F,  2.0F,  -7.0F), 2.0F, {vec3(0.0F, 1.0F, 0.0F)}},

+            {vec3(-1.0F,  0.0F,  -4.0F), 1.0F, {vec3(0.0F, 0.0F, 1.0F)}},

+            {vec3( 0.0F, -1.0F,  -3.0F), 0.2F, {vec3(0.0F, 1.0F, 1.0F)}},

         },

     };

     auto const tonemap = ACES{vec3(1.0F)};

@@ -195,7 +206,7 @@ int main(int argc, char const * argv[])

     output.render([&](uvec2 const & size, uvec2 const & pixel) {

         auto const ray   = camera.ray(size, pixel);

         auto const trace = scene.trace(ray);

-        auto const rgb   = vec3(min(trace.distance / 100.0F, 100.0F));

+        auto const rgb   = trace.material.color;

         auto const srgb  = convertLinearToSRGB(tonemap.transform(rgb));

         auto const alpha = 1.0F;

         return vec4(srgb, alpha);

new file mode 100644

@@ -0,0 +1,203 @@

+/// Includes

+

+#include <array>

+#include <fstream>

+#include <iostream>

+#include <limits>

+#include <string>

+#include <vector>

+

+#define GLM_FORCE_SWIZZLE

+#include <glm/glm.hpp>

+#include <glm/fwd.hpp>

+#include <glm/ext/matrix_transform.hpp>  // https://glm.g-truc.net/0.9.9/api/a00247.html

+#include <glm/ext/matrix_clip_space.hpp> // https://glm.g-truc.net/0.9.9/api/a00243.html

+#include <glm/ext/matrix_projection.hpp> // https://glm.g-truc.net/0.9.9/api/a00245.html

+#include <glm/gtc/color_space.hpp>       // https://glm.g-truc.net/0.9.9/api/a00289.html

+// #include <glm/gtx/io.hpp>                // https://glm.g-truc.net/0.9.9/api/a00332.html

+

+

+/// Namespaces

+

+using namespace glm;

+

+

+/// Constants

+

+auto const infinity = std::numeric_limits<float>::infinity();

+

+

+/// Types

+

+//// Ray

+struct Ray

+{

+    vec3 origin;

+    vec3 direction;

+};

+

+//// Trace

+struct Trace

+{

+    float distance;

+};

+

+//// Circle

+struct Circle

+{

+    vec3  center;

+    float radius;

+    Trace trace(Ray const & ray) const

+    {

+        auto const offs = center - ray.origin;

+        auto const proj = dot(offs, ray.direction);

+        if (proj < 0.0F) // Past.

+            return {infinity};

+        auto const perp2 = dot(offs, offs) - proj * proj;

+        auto const pene2 = radius * radius - perp2;

+        if (pene2 < 0.0F) // Miss.

+            return {infinity};

+        auto const dist = proj - sqrt(pene2);

+        if (dist < 0.0F) // Inside.

+            return {infinity};

+        return {dist};

+    }

+};

+

+//// Shapes

+using Shapes = std::vector<Circle>;

+

+//// Scene

+struct Scene

+{

+    Shapes shapes;

+    Trace trace(Ray const & ray) const

+    {

+        auto nearest = Trace{infinity};

+        for (auto const & shape : shapes)

+        {

+            auto const trace = shape.trace(ray);

+            if (trace.distance < nearest.distance)

+                nearest = trace;

+        }

+        return nearest;

+    }

+};

+

+//// Camera

+struct Camera

+{

+    vec3  position;

+    vec3  target;

+    float fovy;

+    float near;

+    float far;

+    Ray ray(uvec2 const & size, uvec2 const & pixel) const

+    {

+        auto const aspect    = (float)size.x / (float)size.y;

+        auto const viewport  = uvec4(0, 0, size);

+        auto const window    = vec3(vec2(pixel) + 0.5F, 0.0F);

+        auto const up        = vec3(0.0F, 1.0F, 0.0F);

+        auto const view      = glm::lookAt(position, target, up);

+        auto const proj      = glm::perspective(fovy, aspect, near, far);

+        auto const world     = glm::unProject(window, view, proj, viewport);

+        auto const direction = normalize(world.xyz() - position);

+        return Ray{position, direction};

+    }

+};

+

+//// ACES

+struct ACES

+{

+    vec3 whitepoint;

+    vec3 transform(vec3 color) const

+    {

+        color /= whitepoint;

+        return

+            (color * (2.51F * color + 0.03F)) /

+            (color * (2.43F * color + 0.59F) + 0.14F);

+    }

+};

+

+//// TGA

+struct TGA

+{

+    uvec2       size;

+    std::string path;

+    template<typename ColorFunc>

+    void render(ColorFunc const & color_func) const

+    {

+        auto frame_size = size.x * size.y;

+        auto frame      = std::vector<u8vec4>(frame_size);

+        auto header     = std::array<u8, 18>{

+            0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+            (u8)(size.x >> 0U),

+            (u8)(size.x >> 8U),

+            (u8)(size.y >> 0U),

+            (u8)(size.y >> 8U),

+            32, 0,

+        };

+        for (auto y = 0U; y < size.y; ++y)

+        {

+            for (auto x = 0U; x < size.x; ++x)

+            {

+                auto const color = color_func(size, uvec2(x, y));

+                auto const index = y * size.x + x;

+                frame[index] = clamp(color.bgra(), 0.0F, 1.0F) * 255.0F + 0.5F;

+            }

+        }

+        auto ostream = std::ofstream(path, std::ios::binary);

+        write(ostream, header);

+        write(ostream, frame);

+    }

+    template<typename Collection>

+    void write(std::ostream & ostream, Collection const & collection) const

+    {

+        ostream.write(

+            (char const *)collection.data(),

+            (std::streamsize)(sizeof(*collection.data()) * collection.size())

+        );

+    }

+};

+

+

+/// Main

+

+int main(int argc, char const * argv[])

+{

+    //// Arguments

+    if (argc != 2)

+    {

+        std::cerr << "Usage: raytrace <path>" << std::endl;

+        return 0;

+    }

+    auto const * path = argv[1]; // NOLINT

+    //// Configure

+    auto const camera = Camera{

+        vec3(0.0F, 0.0F,  0.0F), // position

+        vec3(0.0F, 0.0F, -1.0F), // target

+        radians(45.0F),          // fovy

+        0.01F,                   // near

+        100.0F,                  // far

+    };

+    auto const scene = Scene{

+        // shapes

+        {

+            {vec3( 2.0F, -1.0F, -10.0F), 3.0F},

+            {vec3( 1.0F,  2.0F,  -7.0F), 2.0F},

+            {vec3(-1.0F,  0.0F,  -4.0F), 1.0F},

+            {vec3( 0.0F, -1.0F,  -3.0F), 0.2F},

+        },

+    };

+    auto const tonemap = ACES{vec3(1.0F)};

+    auto const output  = TGA{uvec2(640, 480), path};

+    //// Render

+    output.render([&](uvec2 const & size, uvec2 const & pixel) {

+        auto const ray   = camera.ray(size, pixel);

+        auto const trace = scene.trace(ray);

+        auto const rgb   = vec3(min(trace.distance / 100.0F, 100.0F));

+        auto const srgb  = convertLinearToSRGB(tonemap.transform(rgb));

+        auto const alpha = 1.0F;

+        return vec4(srgb, alpha);

+    });

+}