FluffyWishbone

#include <FastLED.h>

#define LED_PIN 6
#define WIDTH 120
#define HEIGHT 70
#define NUM_LEDS (WIDTH * HEIGHT)
#define BRIGHTNESS 255

CRGB leds[NUM_LEDS];

// Cube vertices in 3D space
float vertices[8][3] = {
  {-1, -1, -1}, {1, -1, -1}, {1, 1, -1}, {-1, 1, -1},
  {-1, -1, 1}, {1, -1, 1}, {1, 1, 1}, {-1, 1, 1}
};

// Cube edges (pairs of vertex indices)
int edges[12][2] = {
  {0, 1}, {1, 2}, {2, 3}, {3, 0},  // Back face
  {4, 5}, {5, 6}, {6, 7}, {7, 4},  // Front face
  {0, 4}, {1, 5}, {2, 6}, {3, 7}   // Connecting edges
};

float rotated[8][3];
float projected[8][2];

float angleX = 0;
float angleY = 0;
float angleZ = 0;

void setup() {
  FastLED.addLeds<WS2812B,2,GRB>(leds,240); //1 240
  FastLED.addLeds<WS2812B,3,GRB>(leds,1*240,240); //2 480
  FastLED.addLeds<WS2812B,4,GRB>(leds,2*240,240); //3 720
  FastLED.addLeds<WS2812B,5,GRB>(leds,3*240,240); //4 960
  FastLED.addLeds<WS2812B,6,GRB>(leds,4*240,240);  //5 1200
  FastLED.addLeds<WS2812B,7,GRB>(leds,5*240,240);  //6 1440
  FastLED.addLeds<WS2812B,8,GRB>(leds,6*240,240);  //7 1680
  FastLED.addLeds<WS2812B,9,GRB>(leds,7*240,240); //8 1920
  FastLED.addLeds<WS2812B,10,GRB>(leds,8*240,240); //9
  FastLED.addLeds<WS2812B,11,GRB>(leds,9*240,240); //10
  FastLED.addLeds<WS2812B,24,GRB>(leds,10*240,240); //11
  FastLED.addLeds<WS2812B,25,GRB>(leds,11*240,240); //12
  FastLED.addLeds<WS2812B,26,GRB>(leds,12*240,240); //13
  FastLED.addLeds<WS2812B,27,GRB>(leds,13*240,240); //14
  FastLED.addLeds<WS2812B,28,GRB>(leds,14*240,240); //15
  FastLED.addLeds<WS2812B,29,GRB>(leds,15*240,240); //16
  FastLED.addLeds<WS2812B,30,GRB>(leds,16*240,240); //17
  FastLED.addLeds<WS2812B,31,GRB>(leds,17*240,240); //18
  FastLED.addLeds<WS2812B,32,GRB>(leds,18*240,240); //19
  FastLED.addLeds<WS2812B,33,GRB>(leds,19*240,240); //20
  FastLED.addLeds<WS2812B,34,GRB>(leds,20*240,240); //21
  FastLED.addLeds<WS2812B,35,GRB>(leds,21*240,240); //22
  FastLED.addLeds<WS2812B,36,GRB>(leds,22*240,240); //23
  FastLED.addLeds<WS2812B,37,GRB>(leds,23*240,240); //24
  FastLED.addLeds<WS2812B,38,GRB>(leds,24*240,240); //25
  FastLED.addLeds<WS2812B,39,GRB>(leds,25*240,240); //26
  FastLED.addLeds<WS2812B,40,GRB>(leds,26*240,240); //27
  FastLED.addLeds<WS2812B,41,GRB>(leds,27*240,240); //28
  FastLED.addLeds<WS2812B,13,GRB>(leds,28*240,240); //29
  FastLED.addLeds<WS2812B,14,GRB>(leds,29*240,240); //30
  FastLED.addLeds<WS2812B,15,GRB>(leds,30*240,240); //31
  FastLED.addLeds<WS2812B,16,GRB>(leds,31*240,240); //32
  FastLED.addLeds<WS2812B,17,GRB>(leds,32*240,240); //33
  FastLED.addLeds<WS2812B,18,GRB>(leds,33*240,240); //34
  FastLED.addLeds<WS2812B,19,GRB>(leds,34*240,240); //35

  FastLED.setCorrection(TypicalLEDStrip); //TypicalSMD5050  TypicalLEDStrip TypicalLEDStrip
  FastLED.setBrightness(75);
  //FastLED.setMaxPowerInVoltsAndMilliamps( 5, 5000); // optional current limiting [5V, 2000mA]
  FastLED.setDither(0);
  FastLED.clear();
  FastLED.show();
  Serial.begin(115200);                 // check serial monitor for current fps count
}

// Get LED index from x, y coordinates
int XY(int x, int y) {
  if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return -1;

  // Adjust based on your matrix wiring (zigzag vs straight)
  if (y & 1) {
    // Odd rows run backwards
    return y * WIDTH + (WIDTH - 1 - x);
  } else {
    // Even rows run forwards
    return y * WIDTH + x;
  }
}

// Wu's algorithm for anti-aliased pixel drawing
void wu_pixel(float x, float y, CRGB color) {
  int x0 = (int)x;
  int y0 = (int)y;

  float fx = x - x0;
  float fy = y - y0;

  // Calculate weights for the 4 surrounding pixels
  float w00 = (1 - fx) * (1 - fy);
  float w10 = fx * (1 - fy);
  float w01 = (1 - fx) * fy;
  float w11 = fx * fy;

  // Draw the 4 pixels with appropriate brightness
  int idx;

  idx = XY(x0, y0);
  if (idx >= 0) leds[idx] += CRGB(color.r * w00, color.g * w00, color.b * w00);

  idx = XY(x0 + 1, y0);
  if (idx >= 0) leds[idx] += CRGB(color.r * w10, color.g * w10, color.b * w10);

  idx = XY(x0, y0 + 1);
  if (idx >= 0) leds[idx] += CRGB(color.r * w01, color.g * w01, color.b * w01);

  idx = XY(x0 + 1, y0 + 1);
  if (idx >= 0) leds[idx] += CRGB(color.r * w11, color.g * w11, color.b * w11);
}

// Draw anti-aliased line using Wu's algorithm
void wu_line(float x0, float y0, float x1, float y1, CRGB color) {
  bool steep = abs(y1 - y0) > abs(x1 - x0);

  if (steep) {
    float tmp;
    tmp = x0; x0 = y0; y0 = tmp;
    tmp = x1; x1 = y1; y1 = tmp;
  }

  if (x0 > x1) {
    float tmp;
    tmp = x0; x0 = x1; x1 = tmp;
    tmp = y0; y0 = y1; y1 = tmp;
  }

  float dx = x1 - x0;
  float dy = y1 - y0;
  float gradient = (dx == 0) ? 1 : dy / dx;

  // Handle first endpoint
  float xend = round(x0);
  float yend = y0 + gradient * (xend - x0);
  float xgap = 1 - fmod(x0 + 0.5, 1);
  int xpxl1 = xend;
  int ypxl1 = (int)yend;

  if (steep) {
    wu_pixel(ypxl1, xpxl1, CRGB(color.r * (1 - fmod(yend, 1)) * xgap,
                                  color.g * (1 - fmod(yend, 1)) * xgap,
                                  color.b * (1 - fmod(yend, 1)) * xgap));
    wu_pixel(ypxl1 + 1, xpxl1, CRGB(color.r * fmod(yend, 1) * xgap,
                                      color.g * fmod(yend, 1) * xgap,
                                      color.b * fmod(yend, 1) * xgap));
  } else {
    wu_pixel(xpxl1, ypxl1, CRGB(color.r * (1 - fmod(yend, 1)) * xgap,
                                  color.g * (1 - fmod(yend, 1)) * xgap,
                                  color.b * (1 - fmod(yend, 1)) * xgap));
    wu_pixel(xpxl1, ypxl1 + 1, CRGB(color.r * fmod(yend, 1) * xgap,
                                      color.g * fmod(yend, 1) * xgap,
                                      color.b * fmod(yend, 1) * xgap));
  }

  float intery = yend + gradient;

  // Handle second endpoint
  xend = round(x1);
  yend = y1 + gradient * (xend - x1);
  xgap = fmod(x1 + 0.5, 1);
  int xpxl2 = xend;
  int ypxl2 = (int)yend;

  if (steep) {
    wu_pixel(ypxl2, xpxl2, CRGB(color.r * (1 - fmod(yend, 1)) * xgap,
                                  color.g * (1 - fmod(yend, 1)) * xgap,
                                  color.b * (1 - fmod(yend, 1)) * xgap));
    wu_pixel(ypxl2 + 1, xpxl2, CRGB(color.r * fmod(yend, 1) * xgap,
                                      color.g * fmod(yend, 1) * xgap,
                                      color.b * fmod(yend, 1) * xgap));
  } else {
    wu_pixel(xpxl2, ypxl2, CRGB(color.r * (1 - fmod(yend, 1)) * xgap,
                                  color.g * (1 - fmod(yend, 1)) * xgap,
                                  color.b * (1 - fmod(yend, 1)) * xgap));
    wu_pixel(xpxl2, ypxl2 + 1, CRGB(color.r * fmod(yend, 1) * xgap,
                                      color.g * fmod(yend, 1) * xgap,
                                      color.b * fmod(yend, 1) * xgap));
  }

  // Main loop
  if (steep) {
    for (int x = xpxl1 + 1; x < xpxl2; x++) {
      wu_pixel((int)intery, x, CRGB(color.r * (1 - fmod(intery, 1)),
                                      color.g * (1 - fmod(intery, 1)),
                                      color.b * (1 - fmod(intery, 1))));
      wu_pixel((int)intery + 1, x, CRGB(color.r * fmod(intery, 1),
                                          color.g * fmod(intery, 1),
                                          color.b * fmod(intery, 1)));
      intery += gradient;
    }
  } else {
    for (int x = xpxl1 + 1; x < xpxl2; x++) {
      wu_pixel(x, (int)intery, CRGB(color.r * (1 - fmod(intery, 1)),
                                      color.g * (1 - fmod(intery, 1)),
                                      color.b * (1 - fmod(intery, 1))));
      wu_pixel(x, (int)intery + 1, CRGB(color.r * fmod(intery, 1),
                                          color.g * fmod(intery, 1),
                                          color.b * fmod(intery, 1)));
      intery += gradient;
    }
  }
}

// 3D rotation and projection
void rotateCube() {
  float cosX = cos(angleX), sinX = sin(angleX);
  float cosY = cos(angleY), sinY = sin(angleY);
  float cosZ = cos(angleZ), sinZ = sin(angleZ);

  for (int i = 0; i < 8; i++) {
    float x = vertices[i][0];
    float y = vertices[i][1];
    float z = vertices[i][2];

    // Rotate around X axis
    float y1 = y * cosX - z * sinX;
    float z1 = y * sinX + z * cosX;

    // Rotate around Y axis
    float x2 = x * cosY + z1 * sinY;
    float z2 = -x * sinY + z1 * cosY;

    // Rotate around Z axis
    float x3 = x2 * cosZ - y1 * sinZ;
    float y3 = x2 * sinZ + y1 * cosZ;

    rotated[i][0] = x3;
    rotated[i][1] = y3;
    rotated[i][2] = z2;

    // Perspective projection
    float scale = 22.0; //20.0 / (4.0 + z2)
    projected[i][0] = x3 * scale + WIDTH / 2.0;
    projected[i][1] = y3 * scale + HEIGHT / 2.0;
  }
}

void loop() {
  FastLED.clear();

  rotateCube();

  // Draw all edges with rainbow colors
  for (int i = 0; i < 12; i++) {
    int v0 = edges[i][0];
    int v1 = edges[i][1];

    CRGB color = CHSV(i * 21, 255, 255);

    wu_line(projected[v0][0], projected[v0][1],
            projected[v1][0], projected[v1][1],
            color);
  }

  FastLED.show();

  // Update rotation angles
  angleX += 0.02;
  angleY += 0.03;
  angleZ += 0.01;

  delay(20);
}