Replace double by floats, fix missing padding issues, display a sphere

7 files changed, 86 insertions, 46 deletions

diff --git a/include/rt.hpp b/include/rt.hpp
index 570fc42..1961d35 100644
--- a/include/rt.hpp
+++ b/include/rt.hpp
@@ -4,22 +4,22 @@
 #include <limits>
 #include <cstdlib>
 
-const double pi = 3.1415926535897932385;
-const double infinity = std::numeric_limits<double>::infinity();
+const float pi = 3.1415926535897932385f;
+const float infinity = std::numeric_limits<float>::infinity();
 
-inline double deg_to_rad(double deg) {
+inline float deg_to_rad(float deg) {
     return deg * pi / 180.0;
 }
 
-inline double randd() {
+inline float randd() {
     return rand() / (RAND_MAX + 1.0);
 }
 
-inline double randd(double min, double max) {
+inline float randd(float min, float max) {
     return min + randd() * (max - min);
 }
 
-inline double clamp(double x, double min, double max) {
+inline float clamp(float x, float min, float max) {
     if (x < min) return min;
     if (x > max) return max;
     return x;
diff --git a/include/vec3.hpp b/include/vec3.hpp
index faed334..26cd2b3 100644
--- a/include/vec3.hpp
+++ b/include/vec3.hpp
@@ -8,21 +8,21 @@ class vec3 {
     public:
     vec3();
 
-    vec3(double x, double y, double z);
+    vec3(float x, float y, float z);
 
     vec3 operator-() const;
 
     vec3& operator+=(vec3 vec);
 
-    vec3& operator*=(double scale);
+    vec3& operator*=(float scale);
 
-    vec3& operator/=(double numerator);
+    vec3& operator/=(float numerator);
 
-    double length() const;
+    float length() const;
 
-    double length_sq() const;
+    float length_sq() const;
 
-    double dot(const vec3& vec) const;
+    float dot(const vec3& vec) const;
 
     vec3 cross(const vec3& vec) const;
 
@@ -32,13 +32,13 @@ class vec3 {
 
     static vec3 random();
 
-    static vec3 random(double min, double max);
+    static vec3 random(float min, float max);
 
     float x, y, z;
     float padding;
 };
 
-vec3 lerp(vec3 u, vec3 v, double t);
+vec3 lerp(vec3 u, vec3 v, float t);
 
 vec3 operator+(vec3 u, vec3 v);
 
@@ -46,15 +46,15 @@ vec3 operator-(vec3 u, vec3 v);
 
 vec3 operator*(vec3 u, vec3 v);
 
-vec3 operator*(vec3 u, double scale);
+vec3 operator*(vec3 u, float scale);
 
-vec3 operator*(double scale, vec3 u);
+vec3 operator*(float scale, vec3 u);
 
-vec3 operator/(vec3 u, double scale);
+vec3 operator/(vec3 u, float scale);
 
 vec3 reflect(vec3 v, vec3 n);
 
-vec3 refract(const vec3& uv, const vec3& n, double etai_over_etat);
+vec3 refract(const vec3& uv, const vec3& n, float etai_over_etat);
 
 std::ostream& operator<<(std::ostream& out, vec3 vec);
 
diff --git a/include/vk-renderer.hpp b/include/vk-renderer.hpp
index c54009f..d63e501 100644
--- a/include/vk-renderer.hpp
+++ b/include/vk-renderer.hpp
@@ -9,11 +9,14 @@
 struct input_data {
     color sky_color;
     color ground_color;
+    vec3 camera_pos;
 
     float viewport_width;
     float viewport_height;
-    float pad1;
-    float pad2;
+    float proj_plane_distance;
+    float pad;
+
+    vec3 sphere_position;
 };
 struct path_tracer_data {
     struct input_data inputs;
diff --git a/shaders/compute.comp b/shaders/compute.comp
index 8126536..43054d5 100644
--- a/shaders/compute.comp
+++ b/shaders/compute.comp
@@ -1,20 +1,51 @@
+struct ray {
+    vec3 origin;
+    vec3 direction;
+};
+
 layout(set = 0, binding = 0) buffer Inputs {
-    vec3 sky_color;
-    vec3 ground_color;
+    vec4 sky_color;
+    vec4 ground_color;
+    vec4 camera_pos;
+
     float viewport_width;
     float viewport_height;
-    vec2 padding;
-    vec3 [1920 * 1080] image;
+    float proj_plane_distance;
+    float padding;
+
+    vec4 sphere_position;
+
+    vec4 [1920 * 1080] image;
 };
 
+bool hit_sphere(vec3 position, float radius, ray r) {
+    // Vector from the ray origin to sphere position
+    vec3 origin_center = r.origin - position;
+
+    float a = dot(r.direction, r.direction);
+    float half_b = dot(r.direction, origin_center);
+    float c = dot(origin_center, origin_center) - radius * radius;
+    float discriminant = half_b * half_b - a * c;
+
+    return (discriminant > 0);
+}
+
 void main() {
     uint x = gl_GlobalInvocationID.x;
     uint y = gl_GlobalInvocationID.y;
     uint width = gl_NumWorkGroups.x;
     uint height = gl_NumWorkGroups.y;
 
-    vec2 uv = vec2(float(x) / width, 1.0 - float(y) / height);
-    vec2 ndc = vec2(uv * 2.0 - 1.0);
+    vec2 uv = vec2(float(x) / (width - 1), float(y) / (height - 1));
+
+    vec3 first = camera_pos.xyz - vec3(viewport_width / 2.0, viewport_height / 2.0, proj_plane_distance);
+    vec3 proj_plane_pos = first + vec3(uv.x * viewport_width, uv.y * viewport_height, 0.0);
+
+    ray r = ray(camera_pos.xyz, proj_plane_pos - camera_pos.xyz);
+    if (hit_sphere(sphere_position.xyz, 0.5, r)) {
+        image[y * width + x] = vec4(1.0, 0.0, 0.0, 0.0);
+        return;
+    }
 
-    image[y * width + x] = mix(ground_color, sky_color, uv.y);
+    image[y * width + x] = mix(sky_color, ground_color, uv.y);
 }
diff --git a/src/color.cpp b/src/color.cpp
index 565516f..c1036e0 100644
--- a/src/color.cpp
+++ b/src/color.cpp
@@ -6,10 +6,10 @@ void write_color(std::ostream& out, const color& pixel_color, uint32_t samples_p
     auto g = pixel_color.y;
     auto b = pixel_color.z;
 
-    auto scale = 1.0 / samples_per_pixel;
-    r = sqrt(r * scale);
-    g = sqrt(g * scale);
-    b = sqrt(b * scale);
+    // auto scale = 1.0 / samples_per_pixel;
+    // r = sqrt(r * scale);
+    // g = sqrt(g * scale);
+    // b = sqrt(b * scale);
 
     out << static_cast<uint32_t>(256.0 * clamp(r, 0.0, 0.999)) << ' '
         << static_cast<uint32_t>(256.0 * clamp(g, 0.0, 0.999)) << ' '
diff --git a/src/main.cpp b/src/main.cpp
index fd52ef0..97624ea 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -81,20 +81,26 @@ int main() {
     vkrenderer renderer {};
 
     // Image dimensions
-    const double aspect_ratio = 16.0 / 9.0;
+    const float aspect_ratio = 16.0 / 9.0;
     const size_t width = 1920;
     const size_t height = width / aspect_ratio;
     const uint32_t samples_per_pixel = 1;
     const uint32_t max_depth = 100;
 
-    const vec3 camera_position{ 13.0, 2.0, 3.0 };
-    const vec3 camera_target{ 0.0, 0.0, 0.0 };
+    // const vec3 camera_position{ 13.0, 2.0, 3.0 };
+    const vec3 camera_position{ 0.0, 0.0, 0.0 };
+    const vec3 camera_target{ 0.0, 0.0, 1.0 };
     const double aperture = 0.1;
     const double distance_to_focus = 10;
     camera camera { camera_position, camera_target, 20.0, aspect_ratio, aperture, distance_to_focus };
     struct input_data inputs = {
         .sky_color = sky_color,
         .ground_color = ground_color,
+        .camera_pos = camera_position,
+        .viewport_width = 2.f * aspect_ratio,
+        .viewport_height = 2.f,
+        .proj_plane_distance = 1.f,
+        .sphere_position = { 0.f, 0.f, -1.f },
     };
 
     // World hittable objects
diff --git a/src/vec3.cpp b/src/vec3.cpp
index 94b3432..b1e73f8 100644
--- a/src/vec3.cpp
+++ b/src/vec3.cpp
@@ -3,7 +3,7 @@
 
 vec3::vec3(): x(0.0), y(0.0), z(0.0) {}
 
-vec3::vec3(double x, double y, double z): x(x), y(y), z(z) {}
+vec3::vec3(float x, float y, float z): x(x), y(y), z(z) {}
 
 vec3 vec3::operator-() const {
     return vec3 {
@@ -21,7 +21,7 @@ vec3& vec3::operator+=(vec3 vec) {
     return *this;
 }
 
-vec3& vec3::operator*=(double scale) {
+vec3& vec3::operator*=(float scale) {
     x *= scale;
     y *= scale;
     z *= scale;
@@ -29,7 +29,7 @@ vec3& vec3::operator*=(double scale) {
     return *this;
 }
 
-vec3& vec3::operator/=(double numerator) {
+vec3& vec3::operator/=(float numerator) {
     x /= numerator;
     y /= numerator;
     z /= numerator;
@@ -37,15 +37,15 @@ vec3& vec3::operator/=(double numerator) {
     return *this;
 }
 
-double vec3::length() const {
+float vec3::length() const {
     return sqrt(length_sq());
 }
 
-double vec3::length_sq() const {
+float vec3::length_sq() const {
     return x * x + y * y + z * z;
 }
 
-double vec3::dot(const vec3& vec) const {
+float vec3::dot(const vec3& vec) const {
     return x * vec.x + y * vec.y + z * vec.z;
 }
 
@@ -71,11 +71,11 @@ vec3 vec3::random() {
     return vec3 { randd(), randd(), randd() };
 }
 
-vec3 vec3::random(double min, double max) {
+vec3 vec3::random(float min, float max) {
     return vec3 { randd(min, max), randd(min, max), randd(min, max) };
 }
 
-vec3 lerp(vec3 u, vec3 v, double t) {
+vec3 lerp(vec3 u, vec3 v, float t) {
     return (1.0 - t) * u + t * v;
 }
 
@@ -91,7 +91,7 @@ vec3 operator*(vec3 u, vec3 v) {
     return vec3(u.x * v.x, u.y * v.y, u.z * v.z);
 }
 
-vec3 operator*(vec3 u, double scale) {
+vec3 operator*(vec3 u, float scale) {
     return vec3(
         u.x * scale,
         u.y * scale,
@@ -99,11 +99,11 @@ vec3 operator*(vec3 u, double scale) {
     );
 }
 
-vec3 operator*(double scale, vec3 u) {
+vec3 operator*(float scale, vec3 u) {
     return u * scale;
 }
 
-vec3 operator/(vec3 u, double scale) {
+vec3 operator/(vec3 u, float scale) {
     return (1.0 / scale) * u;
 }
 
@@ -111,7 +111,7 @@ vec3 reflect(vec3 v, vec3 n) {
     return v - 2 * v.dot(n) * n;
 }
 
-vec3 refract(const vec3& uv, const vec3& n, double etai_over_etat) {
+vec3 refract(const vec3& uv, const vec3& n, float etai_over_etat) {
     auto cos_theta = fmin(n.dot(-uv), 1.0);
     vec3 r_out_perp =  etai_over_etat * (uv + cos_theta*n);
     vec3 r_out_parallel = -sqrt(fabs(1.0 - r_out_perp.length_sq())) * n;