make separate thread do sorting

Author: SirJosh3917

include/SortingVisualizer/Collection.hpp

@@ -32,6 +32,7 @@ using Decision = std::variant<Comparison, Swap>;
 class Collection
 {
 private:
+	std::vector<uint64_t> initialValues;
 	std::vector<uint64_t> values;
 	std::vector<Decision> decisions;
 
@@ -45,6 +46,7 @@ class Collection
 	Order compare(std::size_t leftIdx, std::size_t rightIdx);
 	void swap(std::size_t leftIdx, std::size_t rightIdx);
 	void randomize();
+	const std::vector<Decision> &getDecisions() const;
 
 	std::vector<uint64_t> contents() const;
 };

include/SortingVisualizer/Display.hpp

@@ -4,18 +4,20 @@
 #include <SFML/Graphics/RectangleShape.hpp>
 #include <SFML/Graphics/RenderTarget.hpp>
 #include <SortingVisualizer/Collection.hpp>
+#include <memory>
 #include <stdint.h>
 
 class Display
 {
 private:
 	sf::RenderTarget &renderTarget;
-	const Collection &collection;
+	std::shared_ptr<std::vector<uint64_t>> bars;
 	const uint64_t maxBarValue;
 
 public:
 	Display(sf::RenderTarget &renderTarget, Collection &collection);
 	void draw();
+	void setBars(std::vector<uint64_t> bars);
 };
 
 #endif

src/SortingVisualizer/Algorithms/BubbleSort.cpp

@@ -3,6 +3,25 @@
 
 const void bubbleSort(Collection &collection)
 {
+	// auto swapped = false;
+	// auto last = collection.length() - 1;
+
+	// do
+	// {
+	// 	swapped = false;
+
+	// 	for (auto i = 0; i < last; i++)
+	// 	{
+	// 		if (collection.compare(i, i + 1) == Order::GREATER_THAN)
+	// 		{
+	// 			collection.swap(i, i + 1);
+	// 			swapped = true;
+	// 		}
+	// 	}
+
+	// 	last -= 1;
+	// } while (swapped);
+
 	for (auto i = 0; i < collection.length(); i++)
 	{
 		for (auto j = i; j < collection.length(); j++)

src/SortingVisualizer/Collection.cpp

@@ -45,6 +45,8 @@ std::vector<uint64_t> Collection::contents() const { return this->values; }
 
 void Collection::randomize() { std::random_shuffle(this->values.begin(), this->values.end()); }
 
+const std::vector<Decision> &Collection::getDecisions() const { return this->decisions; }
+
 //  std::size_t length() ;
 //  void doParallel(std::initializer_list<std::function<void(Collection)>> parallelActions) ;
 

src/SortingVisualizer/Display.cpp

@@ -3,17 +3,19 @@
 #include <SortingVisualizer/Display.hpp>
 #include <algorithm>
 #include <iostream>
+#include <memory>
 #include <stdint.h>
 
 Display::Display(sf::RenderTarget &renderTarget, Collection &collection)
-	: renderTarget(renderTarget), collection(collection), maxBarValue(collection.max())
+	: renderTarget(renderTarget), bars(std::make_shared<std::vector<uint64_t>>(collection.contents())), maxBarValue(collection.max())
 {
 }
 
 void Display::draw()
 {
+	auto bars = *this->bars.get();
 	auto size = this->renderTarget.getSize();
-	auto barCount = (float)this->collection.length();
+	auto barCount = (float)bars.size();
 
 	// when we draw the bars, we want each bar to have one pixel of spacing inbetween each other,
 	// and one pixel of spacing at the start and the end
@@ -22,7 +24,7 @@ void Display::draw()
 	auto pixelsOfBoxes = size.x - pixelsOfSpacing;
 	auto barWidth = pixelsOfBoxes / barCount;
 
-	for (auto i = 0; auto bar : this->collection.contents())
+	for (auto i = 0; auto bar : bars)
 	{
 		auto barX = spacing + i * (barWidth + spacing);
 		auto barY = (float)bar / (float)maxBarValue * size.y;
@@ -36,4 +38,6 @@ void Display::draw()
 
 		++i;
 	}
-}
+}
+
+void Display::setBars(std::vector<uint64_t> bars) { *this->bars.get() = bars; }

src/SortingVisualizer/main.cpp

@@ -2,39 +2,94 @@
 #include <SortingVisualizer/Algorithms/BubbleSort.hpp>
 #include <SortingVisualizer/Collection.hpp>
 #include <SortingVisualizer/Display.hpp>
+#include <chrono>
 #include <iostream>
+#include <memory>
+#include <thread>
+#include <tuple>
+
+void sorter(std::tuple<Collection *, Display *> container)
+{
+	auto collectionPtr = std::get<0>(container);
+	auto displayPtr = std::get<1>(container);
+
+	if (collectionPtr == nullptr) throw "didn't expect nullptr for collection";
+	if (displayPtr == nullptr) throw "didn't expect nullptr for display";
+
+	auto collection = *collectionPtr;
+	auto display = *displayPtr;
+
+	auto bars = collection.contents();
+	bubbleSort(collection);
+
+	for (auto &decision : collection.getDecisions())
+	{
+		if (std::holds_alternative<Swap>(decision))
+		{
+			auto swap = std::get<Swap>(decision);
+			std::swap(bars[swap.leftIdx], bars[swap.rightIdx]);
+			display.setBars(bars);
+		}
+
+		std::this_thread::sleep_for(std::chrono::milliseconds(16));
+	}
+}
 
 int main()
 {
+	// seed RNG
+	std::srand(std::time(0));
+
 	sf::ContextSettings settings;
-	settings.antialiasingLevel = 16;
+	settings.antialiasingLevel = 4;
+	settings.majorVersion = 3;
 
-	sf::RenderWindow window(sf::VideoMode(800, 600), "Sorting Visualizer", sf::Style::Default, settings);
-	window.setActive(false);
+	auto window = sf::RenderWindow(sf::VideoMode(800, 600), "Sorting Visualizer", sf::Style::Default, settings);
 	window.setVerticalSyncEnabled(true);
+	window.setFramerateLimit(60);
 
-	Collection collection(10);
-	Display display(window, collection);
+	auto collection = Collection(100);
+	collection.randomize();
+
+	auto display = Display(window, collection);
+
+	auto dirty = true;
+
+	sf::Thread sortAlgo(&sorter, std::make_tuple<Collection *, Display *>(&collection, &display));
+	sortAlgo.launch();
 
 	while (window.isOpen())
 	{
 		sf::Event event;
 		while (window.pollEvent(event))
 		{
-			if (event.type == sf::Event::Closed) window.close();
 			if (event.type == sf::Event::Resized)
 			{
+				[[likely]]
 				// SFML views are useful in games, but for me, i'd prefer if i was dealing with everything
 				// as if it were regular window coordinates
 				window.setView(sf::View(sf::FloatRect(0.0f, 0.0f, event.size.width, event.size.height)));
+
+				// we modified the view, we want to guarantee a re-render
+				dirty = true;
+			}
+			else if (event.type == sf::Event::LostFocus)
+			{
+				window.setFramerateLimit(12);
+			}
+			else if (event.type == sf::Event::GainedFocus)
+			{
+				window.setFramerateLimit(60);
+			}
+			else if (event.type == sf::Event::Closed)
+			{
+				[[unlikely]] window.close();
+				exit(0);
 			}
 		}
 
 		window.clear();
-
-		collection.randomize();
 		display.draw();
-
 		window.display();
 	}