hachem.wtf
aboutsummaryrefslogtreecommitdiff
path: root/src/engine
diff options
context:
space:
mode:
Diffstat (limited to 'src/engine')
-rw-r--r--src/engine/engine.cpp38
-rw-r--r--src/engine/engine.h94
-rw-r--r--src/engine/object.h55
-rw-r--r--src/engine/scene.h47
4 files changed, 119 insertions, 115 deletions
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
index d6e2723..87eda62 100644
--- a/src/engine/engine.cpp
+++ b/src/engine/engine.cpp
@@ -79,12 +79,12 @@ namespace Donut
glGenFramebuffers(1, &m_geodesic_fbo);
}
- void Engine::update_window_dimensions()
+ auto Engine::update_window_dimensions() -> void
{
update_compute_dimensions();
}
- void Engine::set_window_dimensions(int width, int height)
+ auto Engine::set_window_dimensions(int width, int height) -> void
{
int old_width = m_width;
int old_height = m_height;
@@ -99,18 +99,18 @@ namespace Donut
update_compute_dimensions();
}
- void Engine::update_performance(float delta_time)
+ auto Engine::update_performance(float delta_time) -> void
{
if (delta_time > 0.0f)
m_current_fps = 1.0f / delta_time;
}
- void Engine::update_compute_dimensions()
+ auto Engine::update_compute_dimensions() -> void
{
m_texture = Texture2D::create(get_compute_width(), m_compute_height);
}
- void Engine::draw_full_screen_quad()
+ auto Engine::draw_full_screen_quad() -> void
{
RenderCommand::set_viewport(0, 0, m_width, m_height);
@@ -125,7 +125,7 @@ namespace Donut
RenderCommand::enable_depth_test();
}
- void Engine::draw_blur_pass()
+ auto Engine::draw_blur_pass() -> void
{
RenderCommand::set_viewport(0, 0, m_width, m_height);
@@ -143,7 +143,7 @@ namespace Donut
RenderCommand::enable_depth_test();
}
- void Engine::draw_geodesic_pass(int cw, int ch)
+ auto Engine::draw_geodesic_pass(int cw, int ch) -> void
{
m_quad_vao->bind();
RenderCommand::disable_depth_test();
@@ -170,7 +170,7 @@ namespace Donut
RenderCommand::enable_depth_test();
}
- void Engine::dispatch_compute(const Camera& cam)
+ auto Engine::dispatch_compute(const Camera& cam) -> void
{
auto& hdri_manager = HDRIManager::get();
m_hdri_environment = hdri_manager.get_current_hdri();
@@ -200,7 +200,7 @@ namespace Donut
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
- void Engine::upload_camera_ubo(const Camera& cam)
+ auto Engine::upload_camera_ubo(const Camera& cam) -> void
{
struct UBOData
{
@@ -231,7 +231,7 @@ namespace Donut
m_camera_ubo->bind(1);
}
- void Engine::upload_objects_ubo(const std::vector<ObjectData>& objs)
+ auto Engine::upload_objects_ubo(const std::vector<ObjectData>& objs) -> void
{
struct UBOData
{
@@ -256,7 +256,7 @@ namespace Donut
m_objects_ubo->bind(3);
}
- void Engine::upload_disk_ubo()
+ auto Engine::upload_disk_ubo() -> void
{
float r1 = static_cast<float>(m_sag_a.m_rs * 2.2);
float r2 = static_cast<float>(m_sag_a.m_rs * 5.2);
@@ -268,7 +268,7 @@ namespace Donut
m_disk_ubo->bind(2);
}
- void Engine::upload_simulation_ubo()
+ auto Engine::upload_simulation_ubo() -> void
{
struct UBOData
{
@@ -292,7 +292,7 @@ namespace Donut
m_simulation_ubo->bind(4);
}
- void Engine::update_physics(float delta_time)
+ auto Engine::update_physics(float delta_time) -> void
{
for (auto& obj : m_objects)
{
@@ -325,7 +325,7 @@ namespace Donut
}
}
- void Engine::render_scene()
+ auto Engine::render_scene() -> void
{
RenderCommand::clear();
m_shader_program->bind();
@@ -334,7 +334,7 @@ namespace Donut
RenderCommand::draw_arrays(6);
}
- Ref<Shader> Engine::create_compute_program(const char* path)
+ auto Engine::create_compute_program(const char* path) -> Ref<Shader>
{
std::ifstream in(path);
if(!in.is_open())
@@ -348,7 +348,7 @@ namespace Donut
return Ref<Shader>(Shader::create_compute("ComputeShader", src_str));
}
- std::pair<Ref<VertexArray>, Ref<Texture2D>> Engine::quad_vao()
+ auto Engine::quad_vao() -> std::pair<Ref<VertexArray>, Ref<Texture2D>>
{
float quad_vertices[] =
{
@@ -373,7 +373,7 @@ namespace Donut
return { vertex_array, texture };
}
- void Engine::load_objects_from_scene(const std::vector<Donut::Object>& objects)
+ auto Engine::load_objects_from_scene(const std::vector<Donut::Object>& objects) -> void
{
m_objects.clear();
m_objects.push_back(
@@ -410,7 +410,7 @@ namespace Donut
print_object_info();
}
- void Engine::print_object_info() const
+ auto Engine::print_object_info() const -> void
{
DONUT_INFO("=== Object Information ===");
DONUT_INFO("Total objects: {}", m_objects.size());
@@ -435,7 +435,7 @@ namespace Donut
DONUT_INFO("========================");
}
- void Engine::export_high_res_frame(const std::string& filename, int width, int height)
+ auto Engine::export_high_res_frame(const std::string& filename, int width, int height) -> void
{
DONUT_INFO("Exporting high-resolution frame: {}x{} to {}", width, height, filename);
diff --git a/src/engine/engine.h b/src/engine/engine.h
index 1c25466..0451d40 100644
--- a/src/engine/engine.h
+++ b/src/engine/engine.h
@@ -65,30 +65,30 @@ namespace Donut
Engine();
~Engine() = default;
- void draw_full_screen_quad();
- void draw_blur_pass();
- void dispatch_compute(const Camera& cam);
- void upload_camera_ubo(const Camera& cam);
- void upload_objects_ubo(const std::vector<ObjectData>& objs);
- void upload_disk_ubo();
- void upload_simulation_ubo();
- void render_scene();
- void update_physics(float delta_time);
- void update_window_dimensions();
- void set_window_dimensions(int width, int height);
+ auto draw_full_screen_quad() -> void;
+ auto draw_blur_pass() -> void;
+ auto dispatch_compute(const Camera& cam) -> void;
+ auto upload_camera_ubo(const Camera& cam) -> void;
+ auto upload_objects_ubo(const std::vector<ObjectData>& objs) -> void;
+ auto upload_disk_ubo() -> void;
+ auto upload_simulation_ubo() -> void;
+ auto render_scene() -> void;
+ auto update_physics(float delta_time) -> void;
+ auto update_window_dimensions() -> void;
+ auto set_window_dimensions(int width, int height) -> void;
- int get_width() const { return m_width; }
- int get_height() const { return m_height; }
+ auto get_width() const -> int { return m_width; }
+ auto get_height() const -> int { return m_height; }
- std::vector<ObjectData>& get_objects() { return m_objects; }
- BlackHole& get_sag_a() { return m_sag_a; }
- Camera& get_camera() { return m_camera; }
- bool& get_gravity() { return m_gravity; }
+ auto get_objects() -> std::vector<ObjectData>& { return m_objects; }
+ auto get_sag_a() -> BlackHole& { return m_sag_a; }
+ auto get_camera() -> Camera& { return m_camera; }
+ auto get_gravity() -> bool& { return m_gravity; }
- void update_performance(float delta_time);
- void set_target_fps(int fps) { m_target_fps = fps; }
- int get_target_fps() const { return m_target_fps; }
- float get_current_fps() const { return m_current_fps; }
+ auto update_performance(float delta_time) -> void;
+ auto set_target_fps(int fps) -> void { m_target_fps = fps; }
+ auto get_target_fps() const -> int { return m_target_fps; }
+ auto get_current_fps() const -> float { return m_current_fps; }
void set_compute_height(int height)
{
#ifdef __APPLE__
@@ -96,43 +96,43 @@ namespace Donut
#endif
m_compute_height = height;
}
- int get_compute_height() const { return m_compute_height; }
- int get_compute_width() const { return (m_width * m_compute_height) / m_height; }
- void update_compute_dimensions();
+ auto get_compute_height() const -> int { return m_compute_height; }
+ auto get_compute_width() const -> int { return (m_width * m_compute_height) / m_height; }
+ auto update_compute_dimensions() -> void;
- int get_max_steps_moving() const { return m_max_steps_moving; }
- int get_max_steps_static() const { return m_max_steps_static; }
- float get_early_exit_distance() const { return m_early_exit_distance; }
- void set_max_steps_moving(int steps) { m_max_steps_moving = steps; }
- void set_max_steps_static(int steps) { m_max_steps_static = steps; }
- void set_early_exit_distance(float distance) { m_early_exit_distance = distance; }
+ auto get_max_steps_moving() const -> int { return m_max_steps_moving; }
+ auto get_max_steps_static() const -> int { return m_max_steps_static; }
+ auto get_early_exit_distance() const -> float { return m_early_exit_distance; }
+ auto set_max_steps_moving(int steps) -> void { m_max_steps_moving = steps; }
+ auto set_max_steps_static(int steps) -> void { m_max_steps_static = steps; }
+ auto set_early_exit_distance(float distance) -> void { m_early_exit_distance = distance; }
- float get_disk_thickness() const { return m_disk_thickness; }
- void set_disk_thickness(float thickness) { m_disk_thickness = thickness; }
+ auto get_disk_thickness() const -> float { return m_disk_thickness; }
+ auto set_disk_thickness(float thickness) -> void { m_disk_thickness = thickness; }
- float get_disk_density() const { return m_disk_density; }
- void set_disk_density(float density) { m_disk_density = density; }
+ auto get_disk_density() const -> float { return m_disk_density; }
+ auto set_disk_density(float density) -> void { m_disk_density = density; }
- float get_rotation_speed() const { return m_rotation_speed; }
- void set_rotation_speed(float speed) { m_rotation_speed = speed; }
+ auto get_rotation_speed() const -> float { return m_rotation_speed; }
+ auto set_rotation_speed(float speed) -> void { m_rotation_speed = speed; }
- float get_blur_strength() const { return m_blur_strength; }
- void set_blur_strength(float strength) { m_blur_strength = strength; }
+ auto get_blur_strength() const -> float { return m_blur_strength; }
+ auto set_blur_strength(float strength) -> void { m_blur_strength = strength; }
- float get_glow_intensity() const { return m_glow_intensity; }
- void set_glow_intensity(float intensity) { m_glow_intensity = intensity; }
+ auto get_glow_intensity() const -> float { return m_glow_intensity; }
+ auto set_glow_intensity(float intensity) -> void { m_glow_intensity = intensity; }
- void load_objects_from_scene(const std::vector<Donut::Object>& objects);
- void export_high_res_frame(const std::string& filename, int width = 4096, int height = 3072);
- void print_object_info() const;
+ auto load_objects_from_scene(const std::vector<Donut::Object>& objects) -> void;
+ auto export_high_res_frame(const std::string& filename, int width = 4096, int height = 3072) -> void;
+ auto print_object_info() const -> void;
- void set_hdri_environment(Ref<CubemapTexture> hdri) { m_hdri_environment = hdri; }
- Ref<CubemapTexture> get_hdri_environment() const { return m_hdri_environment; }
+ auto set_hdri_environment(Ref<CubemapTexture> hdri) -> void { m_hdri_environment = hdri; }
+ auto get_hdri_environment() const -> Ref<CubemapTexture> { return m_hdri_environment; }
private:
- Ref<Shader> create_compute_program(const char* path);
+ auto create_compute_program(const char* path) -> Ref<Shader>;
std::pair<Ref<VertexArray>, Ref<Texture2D>> quad_vao();
- void draw_geodesic_pass(int cw, int ch);
+ auto draw_geodesic_pass(int cw, int ch) -> void;
private:
Ref<VertexArray> m_quad_vao;
Ref<Texture2D> m_texture;
diff --git a/src/engine/object.h b/src/engine/object.h
index 790fe25..8101540 100644
--- a/src/engine/object.h
+++ b/src/engine/object.h
@@ -7,67 +7,70 @@ namespace Donut
class Ray
{
public:
+ Ray(glm::vec3 o, glm::vec3 d)
+ : m_origin(o),
+ m_direction(glm::normalize(d)) { }
+
+ public:
glm::vec3 m_direction;
glm::vec3 m_origin;
-
- Ray(glm::vec3 o, glm::vec3 d)
- : m_origin(o),
- m_direction(glm::normalize(d)) { }
};
class Material
{
public:
- glm::vec3 m_color;
- float m_specular;
- float m_emission;
-
Material() : m_color(1.0f, 1.0f, 1.0f), m_specular(0.5f), m_emission(0.0f) { }
Material(glm::vec3 c, float s, float e)
- : m_color(c),
- m_specular(s),
+ : m_color(c),
+ m_specular(s),
m_emission(e) { }
+
+ public:
+ glm::vec3 m_color;
+ float m_specular;
+ float m_emission;
};
class Object
{
public:
- glm::vec3 m_centre;
- float m_radius;
- Material m_material;
-
Object() : m_centre(0.0f, 0.0f, 0.0f), m_radius(1.0f), m_material() { }
- Object(glm::vec3 c, float r, Material m)
- : m_centre(c),
- m_radius(r),
+ Object(glm::vec3 c, float r, Material m)
+ : m_centre(c),
+ m_radius(r),
m_material(m) { }
-
- bool intersect(Ray &ray, float &t)
+
+ auto intersect(Ray& ray, float& t) -> bool
{
glm::vec3 oc = ray.m_origin - m_centre;
- float a = glm::dot(ray.m_direction, ray.m_direction);
+ float a = glm::dot(ray.m_direction, ray.m_direction);
float b = 2.0f * glm::dot(oc, ray.m_direction);
float c = glm::dot(oc, oc) - m_radius * m_radius;
float discriminant = static_cast<float>(b*b - 4*a*c);
- if(discriminant < 0)
+ if (discriminant < 0)
return false;
-
+
float intercept = (-b - sqrt(discriminant)) / (2.0f*a);
- if(intercept < 0)
+ if (intercept < 0)
{
intercept = (-b + sqrt(discriminant)) / (2.0f*a);
- if(intercept<0)
+ if (intercept < 0)
return false;
}
t = intercept;
return true;
}
-
- glm::vec3 get_normal(glm::vec3 &point) const
+
+ auto get_normal(glm::vec3& point) const -> glm::vec3
{
return glm::normalize(point - m_centre);
}
+
+ public:
+ glm::vec3 m_centre;
+ float m_radius;
+ Material m_material;
};
};
diff --git a/src/engine/scene.h b/src/engine/scene.h
index 2ac9cd8..4b41203 100644
--- a/src/engine/scene.h
+++ b/src/engine/scene.h
@@ -7,63 +7,64 @@
namespace Donut
{
- class Scene
+ class Scene
{
public:
- std::vector<Object> objs;
- glm::vec3 m_light_pos;
-
- Scene()
+ Scene()
: m_light_pos(5.0f, 5.0f, 5.0f) { }
-
- glm::vec3 trace(Ray &ray)
+
+ auto trace(Ray& ray) -> glm::vec3
{
float closest = std::numeric_limits<float>::infinity();
const Object* hit_obj = nullptr;
-
- for(auto& obj : objs)
+
+ for (auto& obj : objs)
{
float t;
- if(obj.intersect(ray, t))
- if(t < closest)
+ if (obj.intersect(ray, t))
+ if (t < closest)
{
closest = t;
hit_obj = &obj;
}
}
-
- if(hit_obj)
+
+ if (hit_obj)
{
glm::vec3 hit_point = ray.m_origin + ray.m_direction * closest;
glm::vec3 normal = hit_obj->get_normal(hit_point);
glm::vec3 light_dir = glm::normalize(m_light_pos - hit_point);
-
+
float diff = std::max(glm::dot(normal, light_dir), 0.0f);
-
+
Ray shadow_ray(hit_point + normal * 0.001f, light_dir);
bool in_shadow = false;
-
- for(auto& obj : objs)
+
+ for (auto& obj : objs)
{
float t;
- if(obj.intersect(shadow_ray, t))
+ if (obj.intersect(shadow_ray, t))
{
in_shadow = true;
break;
}
}
-
+
glm::vec3 color = hit_obj->m_material.m_color;
float ambient = 0.1f;
-
- if (in_shadow)
+
+ if (in_shadow)
return color * ambient;
return color * (ambient + diff * 0.9f);
}
-
- return glm::vec3(0.0f, 0.0f, 0.1f);
+
+ return glm::vec3(0.0f, 0.0f, 0.1f);
}
+
+ public:
+ std::vector<Object> objs;
+ glm::vec3 m_light_pos;
};
};
<im@hachem.wtf>