/// 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();
auto const delta = 0.001F;
/// Types
//// Ray
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
{
vec4 color;
};
//// Trace
struct Trace
{
float distance;
Material material;
vec3 miss;
};
//// Circle
struct Circle
{
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, {}, {}};
auto const perp2 = dot(offs, offs) - proj * proj;
auto const pene2 = radius * radius - perp2;
if (pene2 < 0.0F) // Miss.
{
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, vec3(0.0F)};
}
};
//// Shapes
using Shapes = std::vector<Circle>;
//// Scene
struct Scene
{
Material background;
Shapes shapes;
Trace trace(Ray const & ray) const
{
auto nearest = Trace{infinity, background, {}};
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};
}
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
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{
// background
{vec4(0.2F, 0.2F, 0.5F, 0.5F)},
// shapes
{
{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 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;
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)
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);
});
}
git.rcrnstn.net