Scene (#10)

- Fix typo.
- Add `t` to `Hit`.

Author: karnkaul

tray/CMakeLists.txt

@@ -8,9 +8,13 @@ target_sources(${PROJECT_NAME} PRIVATE
   src/tray/io.cpp
   src/tray/io.hpp
   src/tray/light.hpp
+  src/tray/material.hpp
   src/tray/nvec3.hpp
   src/tray/ray.hpp
+  src/tray/renderable.hpp
   src/tray/rgb.hpp
+  src/tray/scene.cpp
+  src/tray/scene.hpp
   src/tray/sphere.hpp
   src/tray/vec.hpp
   src/tray/viewport.hpp

tray/src/main.cpp

@@ -1,8 +1,7 @@
 #include <tray/hit.hpp>
 #include <tray/image.hpp>
 #include <tray/io.hpp>
-#include <tray/light.hpp>
-#include <tray/ray.hpp>
+#include <tray/scene.hpp>
 #include <tray/viewport.hpp>
 #include <algorithm>
 #include <iostream>
@@ -28,27 +27,26 @@ int main() {
 	static constexpr auto vertical = fvec3{0.0f, viewport.extent.y(), 0.0f};
 	static constexpr auto top_left = origin + 0.5f * (-horizontal + vertical) + fvec3{0.0f, 0.0f, -viewport.depth};
 
-	static constexpr fvec3 gradient[] = {Rgb::from_hex(0xffffff).to_f32(), Rgb::from_hex(0x002277).to_f32()};
-	auto image = Image{extent};
-	auto const sphere = Sphere{.centre = {0.0f, 0.0f, -5.0f}, .radius = 1.0f};
-	DirLight const lights[] = {
-		DirLight{.intensity = {0.0f, 1.0f, 1.0f}, .direction = fvec3{-1.0f}},
-		DirLight{.intensity = {0.5f, 0.0f, 0.0f}, .direction = fvec3{0.0f, 0.0f, -1.0f}},
+	auto scene = Scene{};
+	scene.renderables.push_back(Sphere{.centre = {0.0f, 0.0f, -5.0f}, .radius = 1.0f});
+	scene.renderables.push_back({
+		Sphere{.centre = {0.5f, -2.0f, -10.0f}, .radius = 5.0f},
+		Material{.diffuse = {0.2f, 0.8f, 0.7f}},
+	});
+	scene.dir_lights = {
+		DirLight{.intensity = {1.0f, 1.0f, 1.0f}, .direction = fvec3{-1.0f}},
+		DirLight{.intensity = {0.5f, 0.3f, 0.3f}, .direction = fvec3{0.0f, 0.0f, -1.0f}},
 	};
 
+	auto image = Image{extent};
+
 	for (std::uint32_t row = 0; row < image.extent().y(); ++row) {
 		auto const yt = static_cast<float>(row) / static_cast<float>(image.extent().y() - 1);
 		for (std::uint32_t col = 0; col < image.extent().x(); ++col) {
 			auto const xt = static_cast<float>(col) / static_cast<float>(image.extent().x() - 1);
 			auto const dir = top_left + xt * horizontal - yt * vertical - origin;
 			auto const ray = Ray{origin, dir};
-			auto hit = Hit{};
-			if (hit(ray, sphere)) {
-				image[{row, col}] = Rgb::from_f32(clamp(DirLight::combine(lights, hit.normal)));
-				continue;
-			}
-			auto const t = 0.5f * (ray.direction.vec().y() + 1.0f);
-			image[{row, col}] = Rgb::from_f32(lerp(gradient[0], gradient[1], t));
+			image[{row, col}] = Rgb::from_f32(clamp(scene.raycast(ray)));
 		}
 	}
 

tray/src/tray/hit.cpp

@@ -3,7 +3,7 @@
 
 namespace tray {
 namespace {
-constexpr float smallet_positive_root(std::span<float const, 2> roots) {
+constexpr float smallest_positive_root(std::span<float const, 2> roots) {
 	if (roots[0] < 0.0f) { return roots[1]; }
 	if (roots[1] < 0.0f) { return roots[0]; }
 	return std::min(roots[0], roots[1]);
@@ -19,7 +19,7 @@ bool Hit::operator()(Ray const& ray, Sphere const& sphere) {
 
 	auto const sqd = std::sqrt(discriminant);
 	float const roots[] = {0.5f * (-b - sqd), 0.5f * (-b + sqd)};
-	auto const t = smallet_positive_root(roots);
+	t = smallest_positive_root(roots);
 	if (t < 0.0f) { return false; }
 
 	point = ray.at(t);

tray/src/tray/hit.hpp

@@ -7,6 +7,7 @@ namespace tray {
 struct Hit {
 	fvec3 point{};
 	nvec3 normal{};
+	float t{};
 
 	bool operator()(Ray const& ray, Sphere const& sphere);
 };

tray/src/tray/material.hpp

@@ -0,0 +1,8 @@
+#pragma once
+#include <tray/vec.hpp>
+
+namespace tray {
+struct Material {
+	fvec3 diffuse{1.0f};
+};
+} // namespace tray

tray/src/tray/renderable.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include <tray/hit.hpp>
+#include <tray/material.hpp>
+#include <memory>
+
+namespace tray {
+template <typename T>
+concept Hittable = requires(T const& t, Ray const& ray) {
+	Hit{}(ray, t);
+};
+
+class Renderable {
+  public:
+	template <Hittable T>
+	Renderable(T t, Material material = {}) : material{material}, m_model{std::make_unique<Model<T>>(std::move(t))} {}
+
+	bool hit(Hit& out, Ray const& ray) const { return m_model->hit(out, ray); }
+
+	Material material{};
+
+  private:
+	struct Base {
+		virtual ~Base() = default;
+		virtual bool hit(Hit& out, Ray const& ray) const = 0;
+	};
+
+	template <Hittable T>
+	struct Model : Base {
+		T t;
+		Model(T&& t) : t{std::move(t)} {}
+		bool hit(Hit& out, Ray const& ray) const override { return out(ray, t); }
+	};
+
+	std::unique_ptr<Base> m_model{};
+};
+} // namespace tray

tray/src/tray/scene.cpp

@@ -0,0 +1,19 @@
+#include <tray/scene.hpp>
+
+namespace tray {
+fvec3 Scene::raycast(Ray const& ray) const {
+	struct {
+		Renderable const* renderable{};
+		Hit hit{};
+	} nearest{};
+	auto hit = Hit{};
+	for (auto const& renderable : renderables) {
+		if (renderable.hit(hit, ray) && (!nearest.renderable || hit.t < nearest.hit.t)) { nearest = {&renderable, hit}; }
+	}
+	if (!nearest.renderable) {
+		auto const t = 0.5f * (ray.direction.vec().y() + 1.0f);
+		return lerp(background.bottom, background.top, t);
+	}
+	return DirLight::combine(dir_lights, nearest.hit.normal) * nearest.renderable->material.diffuse;
+}
+} // namespace tray

tray/src/tray/scene.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include <tray/light.hpp>
+#include <tray/renderable.hpp>
+#include <tray/rgb.hpp>
+#include <vector>
+
+namespace tray {
+struct Scene {
+	std::vector<DirLight> dir_lights{};
+	std::vector<Renderable> renderables{};
+	struct {
+		fvec3 top{Rgb::from_hex(0x002277).to_f32()};
+		fvec3 bottom{Rgb::from_hex(0xffffff).to_f32()};
+	} background{};
+
+	fvec3 raycast(Ray const& ray) const;
+};
+} // namespace tray