UwUGL/draw.cpp

#pragma once

#include "waymini.h"

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "datatypes.cpp"
#include "helpers.cpp"
#include "triangle.cpp"
#include "buffer.cpp"
#include "surface.cpp"
#include "trapezoid.cpp"
#include "line.cpp"
#include "rectangle.cpp"

namespace UwU {

  class Draw {
    public:
      
      Draw(uint16_t width, uint16_t height, waymini_key_cb onKey)
        : surface(width, height, onKey) {}
      
      class Surface surface;

      bool shouldClose() {
        return surface.shouldClose();
      }

      void updateSize() {
        surface.updateSize();
        return;
      }

      uint16_t getWidth() {
        return surface.getWidth();
      }

      uint16_t getHeight() {
        return surface.getHeight();
      }

      uint16_t getStride() {
        return surface.getStride();
      }

      void present() {
        surface.present();
        return;
      }

      void destroy() {
        surface.destroy();
        return;
      }
      
      // Draw a rectangle (duh)
      void rectangle(Coord2 point0, Coord2 point1, Color color) {
        Rectangle rectangle = Rectangle(point0.x, point0.y, point1.x, point1.y);
        rectangle.draw(surface.buffer, color);
        return;
      }

      // Draws a rectangle with a 4-point color gradient
      void rectangleGradient(Coord2 point0, Coord2 point1, Color colorUL, Color colorUR, Color colorLL, Color colorLR) {
        // convert to int32_t and ensure x1>x0 && y1>y0
        int32_t x0, y0, x1, y1;
        if (point0.x > point1.x) {
          x0 = (int32_t)point1.x;
          x1 = (int32_t)point0.x;
        } else {
          x0 = (int32_t)point0.x;
          x1 = (int32_t)point1.x;
        }
        if (point0.y > point1.y) {
          y0 = (int32_t)point1.y;
          y1 = (int32_t)point0.y;
        } else {
          y0 = (int32_t)point0.y;
          y1 = (int32_t)point1.y;
        }

        // setup gradient coefficient arrays
        int32_t w = x1 - x0 + 1;
        int32_t h = y1 - y0 + 1;
        int16_t xGrad[w];
        int16_t yGrad[h];

        // calculate gradient coefficients
        Helpers::bresenham(0, 0, w - 1, 255, xGrad);
        Helpers::bresenham(0, 0, h - 1, 255, yGrad);

        // for each point calculate, alpha blend and print color
        Color Lmix = Color();
        Color Rmix = Color();
        Color Xmix = Color();
        for (int32_t y = y0; y <= y1; y++) {
          Lmix = Helpers::lerpColor(colorUL, colorLL, (uint8_t)yGrad[y - y0]);
          Rmix = Helpers::lerpColor(colorUR, colorLR, (uint8_t)yGrad[y - y0]);
          for (int32_t x = x0; x <= x1; x++) {
            Xmix = Helpers::lerpColor(Lmix, Rmix, (uint8_t)xGrad[x - x0]);
            // putPixel(x, y, Xmix.r, Xmix.g, Xmix.b, Xmix.a);
            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), Xmix);
          }
        }
        return;
      }
      
      // Fill a simple gradient. Each row is stride bytes.
      void rainbow() {
        for (uint32_t y = 0; y < getHeight(); y++) {
          for (uint32_t x = 0; x < getWidth(); x++) {
            surface.buffer.drawPixel(Coord2((uint16_t)x, (uint16_t)y), Color(
              (uint8_t)(y * 255 / getHeight()),
              0x00,
              (uint8_t)(x * 255 / getWidth()),
              0xff));
            // size_t i = (size_t)y * getStride() + (size_t)x * 4;
            // pixels[i + 0] = (uint8_t)(y * 255 / getHeight());  // B
            // pixels[i + 1] = 0x00;                               // G
            // pixels[i + 2] = (uint8_t)(x * 255 / getWidth());   // R
            // pixels[i + 3] = 0xFF;                               // A
          }
        }
      }

      // Draw a single point
      void point (Coord2 point, Color color) {
        if (point.x > getWidth() || point.y > getHeight()) {return;};
        // putPixel(point.x, point.y, color.r, color.g, color.b, color.a);
        surface.buffer.drawPixel(point, color);
      }

      // // Uses Bresenham's line algorithm to draw line of any slope
      // void line (Coord2 point0, Coord2 point1, Color color) {
      //   if (point0.x > getWidth() || point0.y > getHeight() || point1.x > getWidth() || point1.y > getHeight()) {return;};
      //   int32_t x0 = (int32_t)point0.x;
      //   int32_t y0 = (int32_t)point0.y;
      //   int32_t x1 = (int32_t)point1.x;
      //   int32_t y1 = (int32_t)point1.y;
      //   if (abs(y1 - y0) < abs(x1 - x0)) {
      //     if (x0 > x1) {
      //       lineLow(x1, y1, x0, y0, color);
      //     } else {
      //       lineLow(x0, y0, x1, y1, color);
      //     }
      //   } else {
      //     if (y0 > y1) {
      //       lineHigh(x1, y1, x0, y0, color);
      //     } else {
      //       lineHigh(x0, y0, x1, y1, color);
      //     }
      //   }
      // }

      // // Draw a horizontally bounded trapezoid
      // // coords.y1 >= coords.y0
      // // todo move to private and add public checks
      // void trapezoid (Trapezoid coords, Color color) {
      //   printf("(%u, %u, %u, %u, %u, %u)", coords.y0, coords.y1, coords.xl0, coords.xl1, coords.xr0, coords.xr1);
      //   uint16_t height = 1 + coords.y1 - coords.y0;
      //   int16_t LeftBound[height];
      //   int16_t RightBound[height];
  
      //   Helpers::bresenham(0, coords.xl0, coords.y1 - coords.y0, coords.xl1, LeftBound);
      //   Helpers::bresenham(0, coords.xr0, coords.y1 - coords.y0, coords.xr1, RightBound);
  
      //   printf("leftbound\n");
      //   for (uint16_t i = 0; i < height; i++) {
      //     printf("(%u, %u)\n", i, LeftBound[i]);
      //   }
      //   printf("rightbound\n");
      //   for (uint16_t i = 0; i < height; i++) {
      //     printf("(%u, %u)\n", i, RightBound[i]);
      //   }

      //   for (uint16_t i = 0; i < height; i++) {
      //     for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
      //       // printf("(%u, %u)", x, i + coords.y0);
      //       surface.buffer.drawPixel(Coord2(x, i + coords.y0), color);
      //     }
      //   }
      //   return;
      // }

      void line (Line line, Color color) {
        line.draw(surface.buffer, color);
        return;
      }

      void trapezoid (Trapezoid coords, Color color) {
        coords.draw(surface.buffer, color);
        return;
      }

      // Draw a triangle
      void triangle (uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, Color color) {
        Triangle triangle = Triangle(x0, y0, x1, y1, x2, y2);
        triangle.draw(surface.buffer, color);
        return;
      }
    };
  }