updating to latest

Author: InterstellarDragonDev

.gitignore

@@ -30,3 +30,7 @@
 *.exe
 *.out
 *.app
+
+# directory and vs code files
+build/
+.vscode/

Image-Converter.h

@@ -0,0 +1,120 @@
+#ifndef IMAGE_CONVERTER_H
+#define IMAGE_CONVERTER_H
+
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <tuple>
+#include <png.h>
+#include "Render-Engine.h"
+
+using namespace std;
+
+// function declaration
+std::vector<std::vector<png_byte>> read_png_file(const char* filename, int& width, int& height);
+
+void get_image_data(const char* image_name) {
+    int width, height;
+    std::vector<std::vector<png_byte>> pixel_data = read_png_file(image_name, width, height);
+
+    for (int y = 0; y < height; y++) {
+        png_bytep row = pixel_data[y].data();
+        for (int x = 0; x < width; x++) {
+
+            // this checks if we have gone past the limits of the canvas
+            if (x > WIDTH || y > HEIGHT) {
+            break;
+            }
+
+            png_bytep px = &(row[x * 4]);
+            // px[0] = red, px[1] = green, px[2] = blue, px[3] = alpha
+            if ((int)px[3] == 0) {
+               continue;  
+            }
+            Color pixel_colour = {(int)px[0], (int)px[1], (int)px[2]};
+            pixel_matrix[y][x] = pixel_colour;
+        }
+    }
+}
+
+
+// Function to read PNG file and get pixel data
+std::vector<std::vector<png_byte>> read_png_file(const char* filename, int& width, int& height) {
+    FILE* fp = fopen(filename, "rb");
+    if (!fp) {
+        throw std::runtime_error("Error: Could not open file.");
+    }
+
+    // Create and initialize the png_struct with the default error handling.
+    png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!png) {
+        fclose(fp);
+        throw std::runtime_error("Error: png_create_read_struct failed.");
+    }
+
+    png_infop info = png_create_info_struct(png);
+    if (!info) {
+        png_destroy_read_struct(&png, NULL, NULL);
+        fclose(fp);
+        throw std::runtime_error("Error: png_create_info_struct failed.");
+    }
+
+    if (setjmp(png_jmpbuf(png))) {
+        png_destroy_read_struct(&png, &info, NULL);
+        fclose(fp);
+        throw std::runtime_error("Error: setjmp(png_jmpbuf(png)) failed.");
+    }
+
+    png_init_io(png, fp);
+    png_read_info(png, info);
+
+    width = png_get_image_width(png, info);
+    height = png_get_image_height(png, info);
+    png_byte color_type = png_get_color_type(png, info);
+    png_byte bit_depth = png_get_bit_depth(png, info);
+
+    // Read any color_type into 8bit depth, RGBA format.
+    if (bit_depth == 16)
+        png_set_strip_16(png);
+
+    if (color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_palette_to_rgb(png);
+
+    // PNG_COLOR_TYPE_GRAY_ALPHA is always 8 or 16bit depth.
+    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+        png_set_expand_gray_1_2_4_to_8(png);
+
+    if (png_get_valid(png, info, PNG_INFO_tRNS))
+        png_set_tRNS_to_alpha(png);
+
+    if (color_type == PNG_COLOR_TYPE_RGB ||
+        color_type == PNG_COLOR_TYPE_GRAY ||
+        color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_filler(png, 0xFF, PNG_FILLER_AFTER);
+
+    if (color_type == PNG_COLOR_TYPE_GRAY ||
+        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+        png_set_gray_to_rgb(png);
+
+    png_read_update_info(png, info);
+
+    std::vector<std::vector<png_byte>> pixel_data(height, std::vector<png_byte>(png_get_rowbytes(png, info)));
+    std::vector<png_bytep> row_pointers(height);
+
+    for (int y = 0; y < height; y++) {
+        row_pointers[y] = pixel_data[y].data();
+    }
+
+    png_read_image(png, row_pointers.data());
+
+    fclose(fp);
+    png_destroy_read_struct(&png, &info, NULL);
+
+    return pixel_data;
+}
+
+
+
+
+
+#endif

Makefile

@@ -0,0 +1,22 @@
+pixel_engine:main.cpp
+	g++ -o build/pixel_engine main.cpp Render-Engine.h Image-Converter.h -lm -lpthread -lX11 -lpng -Wall -Wextra
+
+# CXX = g++
+# CXXFLAGS = -Wall -Wextra -std=c++11
+# LDFLAGS = -lm -lpthread -lX11 -lpng
+
+# SOURCES = main.cpp
+# HEADERS = Render-Engine.h Image-Converter.h
+# OBJECTS = $(SOURCES:.cpp=.o)
+# TARGET = build/pixel_engine
+
+# all: $(TARGET)
+
+# $(TARGET): $(OBJECTS)
+# 	$(CXX) $(CXXFLAGS) -o $@ $(OBJECTS) $(LDFLAGS)
+
+# %.o: %.cpp $(HEADERS)
+# 	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+# clean:
+# 	rm -f $(OBJECTS) $(TARGET)

Render-Engine.h

@@ -0,0 +1,91 @@
+#ifndef RENDER_ENGINE_H
+#define RENDER_ENGINE_H
+
+
+
+#include <unordered_map>
+#include <iostream>
+#include <unistd.h> 
+#include <utility>
+#include <cstdlib>
+#include <vector>
+#include <string>
+
+
+
+struct Color {
+    int r, g, b;
+};
+
+const int WIDTH = 200;
+const int HEIGHT = 200;
+
+const Color NULL_COLOR = {-1, -1, -1};
+
+std::unordered_map<char, Color> colour_map = {
+    {'R', {255, 0, 0}},      // Bright red
+    {'G', {0, 255, 0}},      // Bright green
+    {'B', {0, 0, 255}},      // Bright blue
+    {'Y', {255, 255, 0}},    // Yellow
+    {'M', {255, 0, 255}},    // Magenta
+    {'C', {0, 255, 255}},    // Cyan
+    {'g', {100, 100, 100}},      // Grey
+};
+
+Color pixel_matrix[WIDTH][HEIGHT];
+
+
+//* ----------------------------------------------------------------------------------------------------------------------------- Functions start here
+
+Color random_color(){
+   return {(rand() % 255) + 1, (rand() % 255) + 1, (rand() % 255) + 1} ;
+}
+
+// Function to compare two Color structs
+bool operator==(const Color& c1, const Color& c2) {
+    return (c1.r == c2.r && c1.g == c2.g && c1.b == c2.b);
+}
+
+void initialize() {
+    // this sets a new seed for the random number generation
+    srand((unsigned) time(0));
+
+    for (int y = 0; y < HEIGHT; y++){
+        for (int x = 0; x < WIDTH; x++){
+            pixel_matrix[y][x] = NULL_COLOR; 
+        }
+    }   
+}
+
+void print_single_pixel(Color CLin) {
+    // ANSI escape code for setting text color with RGB values   
+    std::cout << "\033[38;2;" << CLin.r << ";" << CLin.g << ";" << CLin.b << "m" << "██" << "\033[0m";
+}
+
+void render() {
+    for (int y = 0; y < HEIGHT; y++){
+        for (int x = 0; x < WIDTH; x++){
+            if (pixel_matrix[y][x] == NULL_COLOR) {
+                std::cout << "  ";
+                continue;
+            }
+            print_single_pixel(pixel_matrix[y][x]); 
+        }
+        std::cout << "\n";
+    }
+}
+
+// prints out the test to make sure pixel rendering is working
+void test_pixels() {
+    std::cout << "rendering test: ";
+    for(auto i:colour_map) {
+        std::cout << i.first << " : ";
+        print_single_pixel(i.second);
+        std::cout << " ";
+    }
+    std::cout << "\n";
+}
+
+
+
+#endif

main.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+#include "Render-Engine.h" 
+#include "Image-Converter.h"
+
+//* compile command: g++ -o build/pixel_engine main.cpp Render-Engine.h Image-Converter.h -lm -lpthread -lX11 -lpng -Wall -Wextra
+
+int main(int argc, char* argv[]) {
+
+    if (argc != 2) {
+        std::cerr << "Usage: " << argv[0] << " <image_file>" << "\n";
+        return 1;
+    }
+    const char* image_name = argv[1];
+
+    initialize();
+
+    get_image_data(image_name);
+
+    render();
+    //std::vector<std::vector<png_byte>> pixel_data = read_png_file(image_name, width, height);
+
+    // Process the pixel data
+    // for (int y = 0; y < height; y++) {
+    //     png_bytep row = pixel_data[y].data();
+    //     for (int x = 0; x < width; x++) {
+    //         png_bytep px = &(row[x * 4]);
+    //         // px[0] = red, px[1] = green, px[2] = blue, px[3] = alpha
+    //         std::cout << "Pixel at (" << x << ", " << y << "): R=" << (int)px[0] << " G=" << (int)px[1] << " B=" << (int)px[2] << " A=" << (int)px[3] << std::endl;
+    //     }
+    // }
+    
+    return 0;
+}