changed the way pixels are added to the framebuffer into a single vector with given size and custom PSRAM allocator

Author: JohnieWalkerCZ

include/Renderer.hpp

@@ -11,22 +11,20 @@ class Renderer {
     int width;
     int height;
     Color backgroundColor;
+    Display displayGrid;
 
   public:
     Renderer(int width, int height,
              const Color &backgroundColor = Color(0, 0, 0, 1.0f));
 
-    void render(Pixels &pixels,
-                const std::vector<std::shared_ptr<Collection>> &collections,
+    void render(const std::vector<std::shared_ptr<Collection>> &collections,
                 const DrawOptions &options);
 
-    void drawText(Pixels &pixels, const std::string &text, int x, int y,
-                  const Font &font, const Color &color, bool wrap = false);
-
-    static Pixels blendPixels(const Pixels &pixels);
-    static Pixel blendPixel(const Pixel &background, const Pixel &foreground);
+    void drawText(const std::string &text, int x, int y, const Font &font,
+                  const Color &color, bool wrap = false);
 
     int getWidth() const { return width; }
     int getHeight() const { return height; }
-    const Color &getBackgroundColor() const { return backgroundColor; }
+    const Display &getDisplayGrid() const { return displayGrid; }
+    void clear();
 };

include/Shapes/Circle.hpp

@@ -18,20 +18,20 @@ class Circle : public Shape {
   public:
     Circle(const CircleParams &params);
     Collider *defaultCollider() override;
-    void drawAntiAliased(Pixels &pixels) override;
-    void drawAliased(Pixels &pixels) override;
+    void drawAntiAliased(Display &displayGrid) override;
+    void drawAliased(Display &displayGrid) override;
     int getRadius() const;
 
   private:
     std::vector<std::pair<int, int>> getPointsToDraw(int cx, int cy, int x,
                                                      int y);
     // Helpers
-    void drawHorizontalLine(Pixels &pixels, int x1, int x2, int y);
-    void drawOctantPointsAA(Pixels &pixels, int cx, int cy, int x, int y,
+    void drawHorizontalLine(Display &displayGrid, int x1, int x2, int y);
+    void drawOctantPointsAA(Display &displayGrid, int cx, int cy, int x, int y,
                             float alpha);
 
-    void drawCirclePoints(Pixels &points, int cx, int cy, int x, int y);
-    void drawAntiAliasedPoint(Pixels &points, int cx, int cy, int x, int y,
-                              float intensity);
-    void fillCircle(Pixels &points, int cx, int cy, int r);
+    void drawCirclePoints(Display &displayGrid, int cx, int cy, int x, int y);
+    void drawAntiAliasedPoint(Display &displayGrid, int cx, int cy, int x,
+                              int y, float intensity);
+    void fillCircle(Display &displayGrid, int cx, int cy, int r);
 };

include/Shapes/Collection.hpp

@@ -13,8 +13,8 @@ class Collection : public Shape {
     void addShape(std::shared_ptr<Shape> shape);
     void removeShape(std::shared_ptr<Shape> shape);
 
-    void drawAliased(Pixels &pixels) override;
-    void drawAntiAliased(Pixels &pixels) override;
+    void drawAliased(Display &displayGrid) override;
+    void drawAntiAliased(Display &displayGrid) override;
 
     void clear();
 

include/Shapes/LineSegment.hpp

@@ -18,6 +18,6 @@ class LineSegment : public Shape {
   public:
     LineSegment(const LineSegmentParams &params);
     Collider *defaultCollider() override;
-    void drawAntiAliased(Pixels &pixels) override;
-    void drawAliased(Pixels &pixels) override;
+    void drawAntiAliased(Display &displayGrid) override;
+    void drawAliased(Display &displayGrid) override;
 };

include/Shapes/Point.hpp

@@ -5,6 +5,6 @@ class Point : public Shape {
   public:
     Point(const ShapeParams &params);
     Collider *defaultCollider() override;
-    void drawAntiAliased(Pixels &pixels) override;
-    void drawAliased(Pixels &pixels) override;
+    void drawAntiAliased(Display &displayGrid) override;
+    void drawAliased(Display &displayGrid) override;
 };

include/Shapes/Polygon.hpp

@@ -21,12 +21,12 @@ class Polygon : public Shape {
   public:
     Polygon(const PolygonParams &params);
     Collider *defaultCollider() override;
-    void drawAntiAliased(Pixels &pixels) override;
-    void drawAliased(Pixels &pixels) override;
+    void drawAntiAliased(Display &displayGrid) override;
+    void drawAliased(Display &displayGrid) override;
 
   private:
     std::vector<std::pair<int, int>> getTransformedVertices();
     std::vector<LineSegment *> getSegments();
-    void getInsidePoints(Pixels &points,
+    void getInsidePoints(Display &displayGrid,
                          const std::vector<std::pair<int, int>> &vertices);
 };

include/Shapes/Rectangle.hpp

@@ -21,13 +21,13 @@ class Rectangle : public Shape {
   public:
     Rectangle(const RectangleParams &params);
     Collider *defaultCollider() override;
-    void drawAntiAliased(Pixels &pixels) override;
-    void drawAliased(Pixels &pixels) override;
+    void drawAntiAliased(Display &displayGrid) override;
+    void drawAliased(Display &displayGrid) override;
     int getWidth() const { return width; }
     int getHeight() const { return height; }
 
   private:
     std::vector<std::pair<int, int>> getVertices();
-    void getInsidePoints(Pixels &points,
+    void getInsidePoints(Display &displayGrid,
                          const std::vector<std::pair<int, int>> &vertices);
 };

include/Shapes/RegularPolygon.hpp

@@ -36,8 +36,8 @@ class RegularPolygon : public Shape {
     RegularPolygon(const RegularPolygonSideParams &params);
     RegularPolygon(const RegularPolygonRadiusParams &params);
     Collider *defaultCollider() override;
-    void drawAntiAliased(Pixels &pixels) override;
-    void drawAliased(Pixels &pixels) override;
+    void drawAntiAliased(Display &displayGrid) override;
+    void drawAliased(Display &displayGrid) override;
     int getSides() const;
     int getRadius();
 
@@ -48,6 +48,6 @@ class RegularPolygon : public Shape {
     int calculateRadiusFromSideLength(int sideLength);
     std::vector<std::pair<int, int>> getVertices();
     std::vector<LineSegment *> getSegments();
-    void getInsidePoints(Pixels &points,
+    void getInsidePoints(Display &displayGrid,
                          const std::vector<std::pair<int, int>> &vertices);
 };

include/Shapes/Shape.hpp

@@ -2,8 +2,8 @@
 #include "../Collider.hpp"
 #include "../Texture.hpp"
 #include "Utils.hpp"
-#include <vector>
 #include <memory>
+#include <vector>
 
 struct DrawOptions {
     int screen_width;
@@ -75,10 +75,12 @@ class Shape {
 
     // Protected helper methods
     std::pair<int, int> getTransformedPosition(int inputX, int inputY);
-    void bresenhamLine(Pixels &points, int x0, int y0, int x1, int y1);
-    void wuLine(Pixels &points, int x0, int y0, int x1, int y1);
-    void addPixel(Pixels &points, int x, int y, float alpha);
-    void getInsidePoints(Pixels &points,
+
+    void setPixelSafe(Display &displayGrid, int x, int y, const Color &c);
+    void bresenhamLine(Display &points, int x0, int y0, int x1, int y1);
+    void wuLine(Display &points, int x0, int y0, int x1, int y1);
+    void addPixel(Display &points, int x, int y, float alpha);
+    void getInsidePoints(Display &points,
                          const std::vector<std::pair<int, int>> &vertices);
     void getUVAt(int x, int y, float &outU, float &outV);
 
@@ -91,12 +93,12 @@ class Shape {
     std::pair<int, int> transformPoint(int x, int y, const Matrix2D &m);
 
     // Pure virtual methods
-    virtual void drawAntiAliased(Pixels &pixels) = 0;
-    virtual void drawAliased(Pixels &pixels) = 0;
+    virtual void drawAntiAliased(Display &pixels) = 0;
+    virtual void drawAliased(Display &pixels) = 0;
     virtual Collider *defaultCollider() = 0;
 
     // Drawing
-    void draw(Pixels &pixels, const DrawOptions &options);
+    void draw(Display &pixels, const DrawOptions &options);
 
     // Position and transformation methods
     void setPosition(int x, int y);

include/Utils.hpp

@@ -1,5 +1,7 @@
 #pragma once
-#include <cstdint>
+#include "esp_heap_caps.h"
+#include "esp_log.h"
+#include <cstdlib>
 #include <vector>
 
 struct Color {
@@ -16,19 +18,32 @@ struct Color {
 bool operator==(const Color &lhs, const Color &rhs);
 bool operator!=(const Color &lhs, const Color &rhs);
 
-struct Pixel {
-    int x;
-    int y;
-    Color color;
-
-    Pixel() : x(0), y(0), color() {}
-    Pixel(int x, int y, Color color) : x(x), y(y), color(color) {}
+template <class T> struct PsramAllocator {
+    typedef T value_type;
+
+    PsramAllocator() = default;
+    template <class U>
+    constexpr PsramAllocator(const PsramAllocator<U> &) noexcept {}
+
+    T *allocate(std::size_t n) {
+        void *p = heap_caps_malloc(n * sizeof(T), MALLOC_CAP_SPIRAM);
+        if (!p) {
+            ESP_LOGE("PSRAM",
+                     "CRITICAL: Failed to allocate %zu bytes in PSRAM!",
+                     n * sizeof(T));
+            std::abort();
+        }
+        return static_cast<T *>(p);
+    }
+
+    void deallocate(T *p, std::size_t) noexcept { heap_caps_free(p); }
 };
 
-bool operator==(const Pixel &lhs, const Pixel &rhs);
-bool operator!=(const Pixel &lhs, const Pixel &rhs);
-
-using Pixels = std::vector<Pixel>;
+struct Display {
+    std::vector<Color, PsramAllocator<Color>> pixels;
+    int width = 0;
+    int height = 0;
+};
 
 class Texture;