Added HUB75 display output

Author: JohnieWalkerCZ

components/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

main/CMakeLists.txt

@@ -15,7 +15,8 @@ idf_component_register(SRCS
     INCLUDE_DIRS 
     "include"
     "include/Shapes"
-    REQUIRES)
+    REQUIRES ESP32-HUB75-MatrixPanel-I2S-DMA
+    PRIV_REQUIRES esp_timer)
 
 target_compile_options(${COMPONENT_LIB} PRIVATE 
     -Wno-narrowing

main/include/Utils.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "ESP32-HUB75-MatrixPanel-I2S-DMA.h"
 #include <cstdint>
 #include <vector>
 
@@ -26,5 +27,65 @@ using Pixels = std::vector<Pixel>;
 
 class Texture;
 
-// Note: loadTexture is omitted as it requires file system access
-// You'll need to implement this based on your texture loading needs
+namespace Colors {
+static const Color BLACK(0, 0, 0);
+static const Color WHITE(255, 255, 255);
+static const Color RED(255, 0, 0);
+static const Color GREEN(0, 255, 0);
+static const Color BLUE(0, 0, 255);
+static const Color YELLOW(255, 255, 0);
+static const Color MAGENTA(255, 0, 255);
+static const Color CYAN(0, 255, 255);
+} // namespace Colors
+
+class HUB75Display {
+  private:
+    MatrixPanel_I2S_DMA *display;
+    int width;
+    int height;
+    bool initialized;
+    static const char *TAG;
+
+    HUB75_I2S_CFG::i2s_pins getDefaultPins() {
+        return {
+            .r1 = 4,   // R1 - Red for upper half
+            .g1 = 5,   // G1 - Green for upper half
+            .b1 = 6,   // B1 - Blue for upper half
+            .r2 = 7,   // R2 - Red for lower half
+            .g2 = 15,  // G2 - Green for lower half
+            .b2 = 16,  // B2 - Blue for lower half
+            .a = 18,   // A - Address line
+            .b = 8,    // B - Address line
+            .c = 3,    // C - Address line
+            .d = 42,   // D - Address line
+            .e = 17,   // E - Address line (set to -1 for 32x32 panels)
+            .lat = 40, // LAT - Latch pin
+            .oe = 2,   // OE - Output Enable pin
+            .clk = 41  // CLK - Clock pin
+        };
+    }
+
+  public:
+    HUB75Display(int panelWidth = 64, int panelHeight = 32,
+                 int chainLength = 1);
+
+    ~HUB75Display();
+
+    void setPixel(int x, int y, const Color &color);
+
+    void setPixel(int x, int y, uint8_t r, uint8_t g, uint8_t b);
+
+    void setPixels(const Pixels &pixels);
+
+    void setBuffer(const Pixels &pixels);
+
+    void fill(const Color &color);
+
+    void clear();
+
+    void setBrightness(uint8_t brightness);
+
+    bool isInitialized() const;
+
+    bool isValidCoordinate(int x, int y) const;
+};

main/main.cpp

@@ -2,116 +2,97 @@
 #include "Shapes/Circle.hpp"
 #include "Shapes/Collection.hpp"
 #include "Shapes/Rectangle.hpp"
+#include "Utils.hpp"
+#include "esp_timer.h"
+#include "freertos/projdefs.h"
+#include <cstdint>
 #include <cstdio>
 #include <stdio.h>
 #include <vector>
 
-// Function to generate a predictable test scene
-void generateTestScene(std::vector<Collection *> &collections) {
-    // Simple test scene with known positions and colors
-    Collection *testCollection =
-        new Collection(ShapeParams{0, 0, Color(0, 0, 0, 1.0f), 0});
+void runSolarSystem() {
+    const int width = 64;
+    const int height = 64;
+    Renderer renderer(width, height, Color(0, 0, 0, 1.0f));
 
-    // Add a red circle at known position
-    Circle *circle1 =
-        new Circle(CircleParams{10, 10, Color(155, 0, 0, 1.0f), 10, true});
-    testCollection->addShape(circle1);
+    std::vector<Collection *> collections;
 
-    // Add a blue rectangle
-    Rectangle *rect1 = new Rectangle(
-        RectangleParams{20, 20, Color(0, 0, 255, 1.0f), 8, 6, true});
-    testCollection->addShape(rect1);
+    Collection *sunCollection =
+        new Collection(ShapeParams{32, 32, Color(0, 0, 0, 1.0f), 0});
+    sunCollection->setPivot(32.0f, 32.0f);
+    collections.push_back(sunCollection);
 
-    // Add a green circle
-    Circle *circle2 =
-        new Circle(CircleParams{35, 15, Color(0, 255, 0, 1.0f), 5, false});
-    testCollection->addShape(circle2);
+    Circle *sun =
+        new Circle(CircleParams{32, 32, Color(255, 204, 0, 1.0f), 8, true});
+    sunCollection->addShape(sun);
 
-    collections.push_back(testCollection);
-}
+    Collection *earthCollection =
+        new Collection(ShapeParams{32, 32, Color(0, 0, 0, 1.0f), 0});
+    earthCollection->setPivot(32.0f, 32.0f);
 
-// Function to output pixels in a consistent format
-void outputPixelsForComparison(const Pixels &pixels, const char *testName) {
-    printf("=== %s ===\n", testName);
-    printf("Total pixels: %zu\n", pixels.size());
-
-    // Sort pixels for consistent output (x, then y)
-    Pixels sorted = pixels;
-    // Simple bubble sort (good enough for testing)
-    for (size_t i = 0; i < sorted.size(); ++i) {
-        for (size_t j = i + 1; j < sorted.size(); ++j) {
-            if (sorted[j].x < sorted[i].x ||
-                (sorted[j].x == sorted[i].x && sorted[j].y < sorted[i].y)) {
-                std::swap(sorted[i], sorted[j]);
-            }
-        }
-    }
+    Circle *earth = new Circle(
+        CircleParams{32 + 20, 32, Color(0, 100, 255, 1.0f), 4, true});
+    earthCollection->addShape(earth);
 
-    // Output first 50 pixels (or all if less)
-    size_t maxOutput = (sorted.size() > 50) ? 50 : sorted.size();
-    printf("First %zu pixels:\n", maxOutput);
+    Circle *alien = new Circle(
+        CircleParams{32 - 20, 32, Color(0, 255, 100, 1.0f), 4, true});
+    earthCollection->addShape(alien);
 
-    for (size_t i = 0; i < maxOutput; i++) {
-        const Pixel &p = sorted[i];
-        printf("Pixel[%zu]: (%d,%d) RGBA(%d,%d,%d,%.3f)\n", i, p.x, p.y,
-               p.color.r, p.color.g, p.color.b, p.color.a);
-    }
+    Collection *moonCollection =
+        new Collection(ShapeParams{32 + 20, 32, Color(0, 0, 0, 1.0f), 0});
+    Circle *moon = new Circle(
+        CircleParams{32 + 20 + 8, 32, Color(200, 200, 200, 1.0f), 2, true});
+    moonCollection->addShape(moon);
 
-    if (sorted.size() > maxOutput) {
-        printf("... and %zu more pixels\n", sorted.size() - maxOutput);
-    }
-    printf("Checksum: %zu pixels\n\n", sorted.size());
-}
+    earthCollection->addShape(moonCollection);
+    sunCollection->addShape(earthCollection);
 
-uint32_t calculatePixelChecksum(const Pixels &pixels) {
-    uint32_t sum = 0;
-    for (const auto &pixel : pixels) {
-        sum += pixel.x;
-        sum += pixel.y;
-        sum += pixel.color.r;
-        sum += pixel.color.g;
-        sum += pixel.color.b;
-        sum += static_cast<uint32_t>(pixel.color.a * 1000.0f);
-    }
-    return sum;
-}
-void runComparisonTest() {
-    printf("Starting C++/TypeScript Comparison Test\n");
-    printf("=======================================\n");
-
-    const int width = 64;
-    const int height = 64;
-    Renderer renderer(width, height, Color(255, 255, 255, 1.0f));
+    Circle *earthOrbit =
+        new Circle(CircleParams{32, 32, Color(100, 100, 100, 0.3f), 20, false});
+    Circle *moonOrbit = new Circle(
+        CircleParams{32 + 20, 32, Color(100, 100, 100, 0.3f), 8, false});
+    sunCollection->addShape(earthOrbit);
+    earthCollection->addShape(moonOrbit);
 
-    // Test 1: Simple static scene
-    printf("TEST 1: Simple Static Scene\n");
-    std::vector<Collection *> scene1;
-    generateTestScene(scene1);
+    DrawOptions options = {width, height, true}; // Anti-aliased
 
-    DrawOptions options = {width, height, false}; // Aliased for consistency
-    Pixels pixels1 = renderer.render(scene1, options);
-    outputPixelsForComparison(pixels1, "Static Scene Aliased");
-    printf("Calculated checksum: 0x%08lX\n", calculatePixelChecksum(pixels1));
+    HUB75Display display(width, height);
+    if (!display.isInitialized()) {
+        printf("Display not initialized. Skipping display output.\n");
+        return;
+    }
 
-    // Test 2: Same scene with anti-aliasing
-    printf("TEST 2: Anti-Aliased Version\n");
-    options.antialias = true;
-    Pixels pixels2 = renderer.render(scene1, options);
-    outputPixelsForComparison(pixels2, "Static Scene Anti-Aliased");
-    printf("Calculated checksum: 0x%08lX\n", calculatePixelChecksum(pixels2));
+    display.clear();
+    int counter = 0;
+    uint64_t sumTime = 0;
+    while (true) {
+        earthCollection->rotate(1.5f);
+        moonCollection->rotate(3.0f);
+        uint64_t startTime = esp_timer_get_time();
+        Pixels pixels = renderer.render(collections, options);
+        uint64_t endTime = esp_timer_get_time();
+        sumTime += (endTime - startTime);
+        counter++;
+        if (counter % 30 == 0) {
+            float avgTimeMs = (sumTime / counter) / 1000.0f;
+            printf("Average render time over %d frames: %.2f ms\n", counter,
+                   avgTimeMs);
+            counter = 0;
+            sumTime = 0;
+        }
+        display.setBuffer(pixels);
+        vTaskDelay(pdMS_TO_TICKS(20));
+    }
 
     // Cleanup
-    for (auto collection : scene1) {
+    for (auto collection : collections) {
         delete collection;
     }
-
-    printf("Comparison test completed.\n");
-    printf("Copy this output and compare with TypeScript version.\n");
 }
 
 extern "C" void app_main(void) {
     printf("C++/TypeScript Output Comparison\n");
     printf("================================\n");
 
-    runComparisonTest();
+    runSolarSystem();
 }

main/src/Utils.cpp

@@ -0,0 +1,106 @@
+#include "Utils.hpp"
+#include "ESP32-HUB75-MatrixPanel-I2S-DMA.h"
+
+HUB75Display::HUB75Display(int panelWidth, int panelHeight, int chainLength)
+    : display(nullptr), width(panelWidth * chainLength), height(panelHeight),
+      initialized(false) {
+
+    ESP_LOGI(TAG, "Creating HUB75 display: %dx%d (chain: %d)", width, height,
+             chainLength);
+
+    HUB75_I2S_CFG mxconfig(panelWidth, panelHeight, chainLength,
+                           getDefaultPins(), HUB75_I2S_CFG::SHIFTREG,
+                           HUB75_I2S_CFG::TYPE138,
+                           false, // double buffer
+                           HUB75_I2S_CFG::HZ_10M, DEFAULT_LAT_BLANKING,
+                           true, // clock phase
+                           120,  // min refresh rate
+                           8     // pixel color depth
+    );
+
+    // Create display instance
+    display = new MatrixPanel_I2S_DMA(mxconfig);
+
+    // Initialize display
+    if (display->begin()) {
+        initialized = true;
+        display->setBrightness8(90);
+        display->clearScreen();
+        ESP_LOGI(TAG, "Display initialized successfully");
+    } else {
+        ESP_LOGE(TAG, "Failed to initialize display");
+    }
+}
+
+HUB75Display::~HUB75Display() {
+    if (display) {
+        delete display;
+    }
+}
+
+// Set a pixel with Color struct (supports alpha blending)
+void HUB75Display::setPixel(int x, int y, const Color &color) {
+    if (!initialized || !isValidCoordinate(x, y)) {
+        return;
+    }
+
+    display->drawPixelRGB888(x, y, color.r * color.a, color.g * color.a,
+                             color.b * color.a);
+}
+
+// Set a pixel with RGB values (convenience method)
+void HUB75Display::setPixel(int x, int y, uint8_t r, uint8_t g, uint8_t b) {
+    setPixel(x, y, Color(r, g, b));
+}
+
+void HUB75Display::setPixels(const Pixels &pixels) {
+    if (!initialized)
+        return;
+
+    for (const auto &pixel : pixels) {
+        setPixel(pixel.x, pixel.y, pixel.color);
+    }
+}
+
+void HUB75Display::setBuffer(const Pixels &pixels) {
+    if (!initialized)
+        return;
+    display->clearScreen();
+    for (const auto &pixel : pixels) {
+        setPixel(pixel.x, pixel.y, pixel.color);
+    }
+}
+
+// Fill the entire display with a color
+void HUB75Display::fill(const Color &color) {
+    if (!initialized)
+        return;
+
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            setPixel(x, y, color);
+        }
+    }
+}
+
+// Clear the display (fill with black)
+void HUB75Display::clear() {
+    if (initialized) {
+        display->clearScreen();
+    }
+}
+
+bool HUB75Display::isInitialized() const { return initialized; }
+
+// Set display brightness (0-255)
+void HUB75Display::setBrightness(uint8_t brightness) {
+    if (initialized) {
+        display->setBrightness8(brightness);
+    }
+}
+
+bool HUB75Display::isValidCoordinate(int x, int y) const {
+    return x >= 0 && x < width && y >= 0 && y < height;
+}
+
+const char *HUB75Display::TAG = "HUB75Display";