Finish refactor/cleanup

Author: stevenewald

CMakeLists.txt

@@ -17,8 +17,11 @@ include(cmake/variables.cmake)
 
 add_library(
     fractal-generator_lib OBJECT
-    source/graphics/basic_display.cpp
-    source/graphics/color_conversions.cpp
+    source/graphics/display/display.cpp
+    source/graphics/selection_window/selection_window.cpp
+    source/mandelbrot/mandelbrot_window.cpp
+    source/graphics/color_conversions/color_conversions.cpp
+    source/graphics/aspect_ratio/aspect_ratio.cpp
 )
 
 target_include_directories(

source/config.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "coordinates.hpp"
+#include "units.hpp"
 
 #include <cstddef>
 
@@ -19,4 +20,7 @@ constexpr complex_domain START_COMPLEX_DOMAIN{
     {complex_underlying{-2}, complex_underlying{-1.5}},
     {complex_underlying{1},  complex_underlying{1.5} }
 };
+
+const complex_underlying MANDELBROT_DIVERGENCE_NORM = 4;
+const iteration_count MANDELBROT_MAX_ITERATIONS = 256;
 } // namespace fractal

source/graphics/ends.hpp source/graphics/aspect_ratio/aspect_ratio.cpp

@@ -1,11 +1,9 @@
-#pragma once
-
-#include "coordinates.hpp"
+#include "aspect_ratio.hpp"
 
 namespace fractal {
-inline display_coordinate calculate_end_points(
-    display_coordinate start, display_coordinate current,
-    float target_aspect_ratio = 800.0f / 600.0f
+
+display_coordinate calculate_rectangle_end_point(
+    display_coordinate start, display_coordinate current, float target_aspect_ratio
 )
 {
     auto width = static_cast<float>(std::abs(current.first - start.first));

source/graphics/aspect_ratio/aspect_ratio.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "coordinates.hpp"
+
+namespace fractal {
+display_coordinate calculate_rectangle_end_point(
+    display_coordinate start, display_coordinate current,
+    float target_aspect_ratio = 800.0f / 600.0f
+);
+} // namespace fractal

source/graphics/color_conversions.cpp source/graphics/color_conversions/color_conversions.cpp

@@ -62,10 +62,11 @@ color hsv_to_rgb(float hue, float saturation, float value)
 
 color ratio_to_rgb(float ratio)
 {
-    if (ratio < 0 || ratio > 1) {
+    if (ratio < 0 || ratio > 1) [[unlikely]] {
         throw std::out_of_range(fmt::format("Ratio out of range: {}", ratio));
     }
-    float hue = static_cast<float>(ratio) * 360.0f;
+
+    float hue = ratio * 360.0f;
     float saturation = 1.0f;
     float value = 1.0f;
 

source/graphics/color_conversions.hpp source/graphics/color_conversions/color_conversions.hpp

@@ -1,12 +1,18 @@
-#include "basic_display.hpp"
+#include "display.hpp"
 
 #include <fmt/format.h>
 
 #include <cmath>
 
 namespace fractal {
+PixelDisplay::PixelDisplay()
+{
+    window_.clear(sf::Color::Black);
+    window_.setFramerateLimit(FRAME_RATE);
+    window_.display();
+}
 
-void BasicDisplay::handle_event_(const sf::Event& event)
+void PixelDisplay::handle_event_(const sf::Event& event)
 {
     switch (event.type) {
         case sf::Event::MouseMoved:
@@ -31,35 +37,33 @@ void BasicDisplay::handle_event_(const sf::Event& event)
             );
             return;
         default:
-            break;
+            return;
     }
 }
 
-void BasicDisplay::add_observer(std::unique_ptr<DisplayEventObserver> observer)
+void PixelDisplay::add_observer(std::unique_ptr<DisplayEventObserver> observer)
 {
     observers_.push_back(std::move(observer));
 }
 
-void BasicDisplay::poll_window_events()
+void PixelDisplay::poll_window_events()
 {
     sf::Event event{};
     while (window_.pollEvent(event)) {
         handle_event_(event);
     }
 }
 
-void BasicDisplay::display_window()
+void PixelDisplay::display_window()
 {
-    window_.clear(sf::Color::Black);
-
     auto draw_from_observer = [this](const auto& observer) {
         if (auto opt = observer->get_drawable(); opt) {
             window_.draw(*(opt.value()));
         }
     };
 
+    window_.clear(sf::Color::Black);
     std::for_each(observers_.begin(), observers_.end(), draw_from_observer);
-
     window_.display();
 }
 } // namespace fractal

source/graphics/basic_display.cpp source/graphics/display/display.cpp

@@ -4,22 +4,22 @@
 #include "graphics/display_event_observer.hpp"
 
 #include <SFML/Graphics.hpp>
+#include <SFML/Graphics/Color.hpp>
 #include <SFML/Graphics/RectangleShape.hpp>
 #include <SFML/System/Vector2.hpp>
 
 #include <memory>
-#include <utility>
 #include <vector>
 
 namespace fractal {
-class BasicDisplay {
+class PixelDisplay {
     sf::RenderWindow window_{sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "SFML Window"};
     std::vector<std::unique_ptr<DisplayEventObserver>> observers_;
 
     void handle_event_(const sf::Event& event);
 
 public:
-    explicit BasicDisplay() { window_.setFramerateLimit(FRAME_RATE); }
+    explicit PixelDisplay();
 
     void add_observer(std::unique_ptr<DisplayEventObserver> observer);
 

source/graphics/basic_display.hpp source/graphics/display/display.hpp

@@ -0,0 +1,48 @@
+#include "selection_window.hpp"
+
+#include "coordinates.hpp"
+#include "graphics/aspect_ratio/aspect_ratio.hpp"
+
+namespace fractal {
+
+void SelectionWindow::on_mouse_moved(const sf::Event::MouseMoveEvent& event)
+{
+    current_mouse_x_ = static_cast<float>(event.x);
+    current_mouse_y_ = static_cast<float>(event.y);
+}
+
+void SelectionWindow::on_mouse_button_pressed(const sf::Event::MouseButtonEvent& event)
+{
+    if (event.button != sf::Mouse::Left) {
+        return;
+    }
+    selection_start_x_ = static_cast<float>(event.x);
+    selection_start_y_ = static_cast<float>(event.y);
+    left_mouse_down_ = true;
+}
+
+void SelectionWindow::on_mouse_button_released(const sf::Event::MouseButtonEvent& event)
+{
+    if (event.button != sf::Mouse::Left) {
+        return;
+    }
+    left_mouse_down_ = false;
+}
+
+std::optional<std::unique_ptr<sf::Drawable>> SelectionWindow::get_drawable()
+{
+    if (!left_mouse_down_)
+        return std::nullopt;
+    display_coordinate end_point = calculate_rectangle_end_point(
+        {selection_start_x_, selection_start_y_}, {current_mouse_x_, current_mouse_y_}
+    );
+
+    auto rectangle = std::make_unique<sf::RectangleShape>(sf::Vector2f{
+        static_cast<float>(end_point.first) - selection_start_x_,
+        static_cast<float>(end_point.second) - selection_start_y_
+    });
+    rectangle->setPosition(selection_start_x_, selection_start_y_);
+    rectangle->setFillColor(sf::Color(255, 0, 0, 127));
+    return rectangle;
+}
+} // namespace fractal

source/graphics/selection.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "graphics/display_event_observer.hpp"
+
+#include <SFML/Graphics/Drawable.hpp>
+#include <SFML/Graphics/RectangleShape.hpp>
+#include <SFML/System/Vector2.hpp>
+
+namespace fractal {
+class SelectionWindow : public DisplayEventObserver {
+    float selection_start_x_{};
+    float selection_start_y_{};
+    float current_mouse_x_{};
+    float current_mouse_y_{};
+    bool left_mouse_down_ = false;
+
+    void on_mouse_moved(const sf::Event::MouseMoveEvent& event) override;
+
+    void on_mouse_button_pressed(const sf::Event::MouseButtonEvent& event) override;
+
+    void on_mouse_button_released(const sf::Event::MouseButtonEvent& event) override;
+
+    std::optional<std::unique_ptr<sf::Drawable>> get_drawable() override;
+};
+} // namespace fractal

source/graphics/selection_window/selection_window.cpp

@@ -1,16 +1,16 @@
-#include "graphics/basic_display.hpp"
-#include "graphics/selection.hpp"
-#include "mandelbrot.hpp"
+#include "graphics/display/display.hpp"
+#include "graphics/selection_window/selection_window.hpp"
+#include "mandelbrot/mandelbrot_window.hpp"
 
 #include <argparse/argparse.hpp>
 
 namespace fractal {
 
 void display_mandelbrot()
 {
-    BasicDisplay display;
+    PixelDisplay display;
 
-    display.add_observer(std::make_unique<Mandelbrot>());
+    display.add_observer(std::make_unique<MandelbrotWindow>());
     display.add_observer(std::make_unique<SelectionWindow>());
 
     while (true) {