Clean up code (#9)

* Clean up code

* Add suggested changes

* fix minor typo

* remove unused file: <fstream.h> from export.h

Author: wwsmiff

Diff for: src/export.cpp

@@ -1 +1,103 @@
+#include <cstdlib>
+#include <iostream>
+#include <string>
+#include <fstream>
+
 #include "export.h"
+
+/* Implementation of Rgba */
+Rgba::Rgba(uint32_t hex)
+	:r((hex & 0xFF'00'00'00) >> 24),
+	 g((hex & 0x00'FF'00'00) >> 16),
+	 b((hex & 0x00'00'FF'00) >> 8),
+	 a(hex & 0x00'00'00'FF)
+{
+}
+
+Rgba::Rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+	:r(r),
+	 g(g),
+	 b(b),
+	 a(a)
+{
+}
+
+constexpr uint32_t Rgba::to_hex(const Rgba &rgba)
+{
+	return ((rgba.r << 24) | 
+					(rgba.g << 16) | 
+					(rgba.b << 8) |
+					(rgba.a));
+}
+
+/* --- End --- */
+
+/* Implementation of Image */
+Image::Image(uint32_t width, uint32_t height)
+	:extent{width, height},
+	 pixels(width * height, Rgba(0))
+{
+}
+
+void Image::export_to_ppm(const Image &input, const std::string &path)
+{
+	std::ofstream output(path);
+	output << "P3\n";
+	output << "# " << path << '\n';
+	output << input.extent.width << " " << input.extent.height << '\n';
+	output << "255\n"; 
+	
+	for(uint32_t y = 0; y < input.extent.height; ++y)
+	{
+		for(uint32_t x = 0; x < input.extent.width; ++x)
+		{
+			Rgba current = input.pixels.at(y * input.extent.width + x);
+			output << static_cast<uint32_t>(current.r) << '\n' 
+							<< static_cast<uint32_t>(current.g) << '\n' 
+							<< static_cast<uint32_t>(current.b) << '\n';
+		}
+	}
+
+	output.close();
+}
+
+
+Rgba &Image::operator[](Index2D index)
+{
+	return this->pixels.at(index.y * this->extent.width + index.x);
+}
+
+const Rgba &Image::operator[](Index2D index) const
+{
+	return this->pixels.at(index.y * this->extent.width + index.x);
+}
+
+/* --- End --- */
+
+Image upscale(const Image &input, uint32_t scale)
+{
+	uint32_t target_width_v = input.extent.width * scale;
+	uint32_t target_height_v = input.extent.height * scale;	
+	uint32_t x_index{0}, y_index{0};
+	Image target_image(target_width_v, target_height_v);
+
+	for(y_index = 0; y_index < input.extent.height; ++y_index)
+	{
+		for(x_index = 0; x_index < input.extent.width; ++x_index)
+		{
+			Rgba current = input[Index2D{x_index, y_index}];
+			if(Rgba::to_hex(current))
+			{
+				for(uint32_t i = y_index * scale; i < ((y_index + 1) * scale); ++i)
+				{
+					for(uint32_t j = x_index * scale; j < ((x_index + 1) * scale); ++j)
+					{
+						target_image[Index2D{j, i}] = current;
+					}
+				}
+			}
+		}
+	}
+
+	return target_image;
+}

Diff for: src/export.h

@@ -1,15 +1,23 @@
 #pragma once
 
 #include <vector>
-#include <span>
 #include <cstdint>
+#include <string>
 
 using std::uint8_t;
 using std::uint32_t;
 
 struct Rgba
 {
+	Rgba(uint32_t hex);
+	Rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
 	uint8_t r{0}, g{0}, b{0}, a{0};
+	static constexpr uint32_t to_hex(const Rgba &rgba);
+};
+
+struct Index2D
+{
+	uint32_t x{0}, y{0};
 };
 
 struct Extent
@@ -19,8 +27,13 @@ struct Extent
 
 struct Image
 {
-	std::vector<Rgba> pixels;
+	Image(uint32_t width, uint32_t height);
+	static void export_to_ppm(const Image &input, const std::string &path);
+	Rgba &operator[](Index2D index);
+	const Rgba &operator[](Index2D index) const;
+	
 	Extent extent;
+	std::vector<Rgba> pixels;
 };
 
-Image upscale(std::span<Rgba const> input, uint32_t scale);
+Image upscale(const Image &input, uint32_t scale);

Diff for: src/main.cpp

@@ -1,11 +1,6 @@
 #include "export.h"
 
-constexpr uint32_t image_width_v = 512;
-constexpr uint32_t image_height_v = 512;
-constexpr uint32_t input_extent_v = 1;
-constexpr uint32_t output_extent_v = 32;
-
 int main()
 {
 	return 0;
-}
+}