got triangles kinda working... will probably refactor

test.cpp

@@ -11,6 +11,7 @@
 
 #include "datatypes.cpp"
 #include "helpers.cpp"
+// #include "triangle.cpp"
 
 // this should be handled elsewhere, eventually, maybe, probably
 static void on_key(void *user, uint32_t keycode, uint32_t state) {
@@ -25,83 +26,20 @@ namespace UwU {
   class Draw {
     private:
 
+      uint8_t *pixels;
+
       void putPixel(uint32_t x, uint32_t y, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xff) {
-          size_t i = (size_t)y * waymini_get_stride(this->wm) + (size_t)x * 4;
+          size_t i = (size_t)y * waymini_get_stride(wm) + (size_t)x * 4;
-          uint8_t b0 = this->pixels[i + 0];
+          uint8_t b0 = pixels[i + 0];
-          uint8_t g0 = this->pixels[i + 1];
+          uint8_t g0 = pixels[i + 1];
-          uint8_t r0 = this->pixels[i + 2];
+          uint8_t r0 = pixels[i + 2];
           b = Helpers::lerp8(b0, b, a);
           g = Helpers::lerp8(g0, g, a);
           r = Helpers::lerp8(r0, r, a);
-          this->pixels[i + 0] = b;    // B
+          pixels[i + 0] = b;    // B
-          this->pixels[i + 1] = g;    // G
+          pixels[i + 1] = g;    // G
-          this->pixels[i + 2] = r;    // R
+          pixels[i + 2] = r;    // R
-          this->pixels[i + 3] = 0xff; // A
+          pixels[i + 3] = 0xff; // A
-      }
-
-      void bresenhamLow(int16_t y0, uint16_t x1, int16_t y1, int16_t* LUT) {
-        int16_t dx = int16_t(x1);
-        int16_t dy = y1 - y0;
-        int16_t yi = 1;
-        if (dy < 0) {
-          yi = -1;
-          dy = -dy;
-        }
-        int16_t d = (2 * dy) - dx;
-        int16_t y = y0;
-        for (uint16_t x = 0; x <= x1; x++) {
-          LUT[x] = y;
-          if (d > 0) {
-            y += yi;
-            d += (2 * (dy - dx));
-          } else {
-            d += (2 * dy);
-          }
-        }
-        return;
-      }
-
-      void bresenhamHigh(uint16_t x0, int16_t y0, uint16_t x1, int16_t y1, int16_t* LUT) {
-        int16_t dx = (int16_t)x1 - (int16_t)x0;
-        int16_t dy = y1 - y0;
-        int16_t xi = 1;
-        if (dx < 0) {
-          xi = -1;
-          dx = -dx;
-        }
-        int16_t d = (2 * dx) - dy;
-        int16_t x = (int16_t)x0;
-        for (int16_t y = y0; y <= y1; y++) {
-          LUT[x] = y;
-          if (d > 0) {
-            x += xi;
-            d += (2 * (dx - dy));
-          } else {
-            d += (2 * dx);
-          }
-        }
-        return;
-      }
-
-      void bresenham(int16_t y0, uint16_t x1, int16_t y1, int16_t* LUT) {
-        int16_t dy = y1 - y0;
-        if (dy == 0) {
-          // catch hline condition
-          for (uint16_t i = 0; i <= x1; i++) {
-            LUT[i] = y0;
-          }
-          return;
-        }
-        if (abs(y1 - y0) <= x1) {
-          bresenhamLow(y0, x1, y1, LUT);
-        } else {
-          if (y0 > y1) {
-            bresenhamHigh(x1, y1, 0, y0, LUT);
-          } else {
-            bresenhamHigh(0, y0, x1, y1, LUT);
-          }
-        }
-        return;
       }
 
       // plot lines if m <= 1
@@ -150,39 +88,17 @@ namespace UwU {
         return;
       }
     
-      // Draw a horizontally bounded trapezoid
-      // coords.y1 >= coords.y0
-      void pTrapezoid (Trapezoid coords, Color color) {
-        uint16_t height = 1 + coords.y1 - coords.y0;
-        int16_t LeftBound[height];
-        int16_t RightBound[height];
-  
-        this->bresenham(coords.xl0, coords.y1 - coords.y0, coords.xl1, LeftBound);
-        this->bresenham(coords.xr0, coords.y1 - coords.y0, coords.xr1, RightBound);
-  
-        for (uint16_t i = 0; i <= height; i++) {
-          for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
-            this->putPixel((uint32_t)x, (uint32_t)i + coords.y0, color.r, color.g, color.b, color.a);
-          }
-        }
-        return;
-      }
-    
     public:
-      struct waymini* wm;
+
-      uint32_t width;
-      uint32_t height;
-      uint32_t stride;
-      uint8_t *pixels;
       
       Draw(uint32_t width, uint32_t height, waymini_key_cb on_key) {
         this->wm = waymini_create(width, height, on_key, NULL);
         if (!this->wm) exit(1);
         
-        this->width = waymini_get_width(this->wm);
+        // this->width = waymini_get_width(this->wm);
-        this->height = waymini_get_height(this->wm);
+        // this->height = waymini_get_height(this->wm);
-        this->stride = waymini_get_stride(this->wm);
+        // this->stride = waymini_get_stride(this->wm);
-        printf("surface: %ux%u stride=%u\n", this->width, this->height, this->stride);
+        printf("surface: %ux%u stride=%u\n", waymini_get_width(this->wm), waymini_get_height(this->wm), waymini_get_stride(this->wm));
         
         this->pixels = (uint8_t *)waymini_get_pixels(this->wm);
         if (!this->pixels) {
@@ -191,9 +107,33 @@ namespace UwU {
         }
       }
 
+      struct waymini* wm;
+
+      uint32_t getWidth() {
+        return waymini_get_width(wm);
+      }
+
+      uint32_t getHeight() {
+        return waymini_get_height(wm);
+      }
+
+      uint32_t getStride() {
+        return waymini_get_stride(wm);
+      }
+
+      void present() {
+        waymini_present(wm);
+        return;
+      }
+
+      void destroy() {
+        waymini_destroy(wm);
+        return;
+      }
+      
       // Draw a rectangle (duh)
       void rectangle(Coord2 point0, Coord2 point1, Color color) {
-        if (point0.x > this->width || point0.y > this->height || point1.x > this->width || point1.y > this->height) {return;};
+        if (point0.x > getWidth() || point0.y > getHeight() || point1.x > getWidth() || point1.y > getHeight()) {return;};
         for (uint32_t y = point0.y; y < point1.y; y++) {
           for (uint32_t x = point0.x; x < point1.x; x++) {
             putPixel(x, y, color.r, color.g, color.b, color.a);
@@ -228,8 +168,8 @@ namespace UwU {
         int16_t yGrad[h];
 
         // calculate gradient coefficients
-        this->bresenham(0, w - 1, 255, xGrad);
+        Helpers::bresenham(0, w - 1, 255, xGrad);
-        this->bresenham(0, h - 1, 255, yGrad);
+        Helpers::bresenham(0, h - 1, 255, yGrad);
 
         // for each point calculate, alpha blend and print color
         Color Lmix = Color();
@@ -248,77 +188,159 @@ namespace UwU {
       
       // Fill a simple gradient. Each row is stride bytes.
       void rainbow() {
-        for (uint32_t y = 0; y < this->height; y++) {
+        for (uint32_t y = 0; y < getHeight(); y++) {
-          for (uint32_t x = 0; x < this->width; x++) {
+          for (uint32_t x = 0; x < getWidth(); x++) {
-            size_t i = (size_t)y * waymini_get_stride(this->wm) + (size_t)x * 4;
+            size_t i = (size_t)y * getStride() + (size_t)x * 4;
-            this->pixels[i + 0] = (uint8_t)(y * 255 / this->height);  // B
+            pixels[i + 0] = (uint8_t)(y * 255 / getHeight());  // B
-            this->pixels[i + 1] = 0x00;                               // G
+            pixels[i + 1] = 0x00;                               // G
-            this->pixels[i + 2] = (uint8_t)(x * 255 / this->width);   // R
+            pixels[i + 2] = (uint8_t)(x * 255 / getWidth());   // R
-            this->pixels[i + 3] = 0xFF;                               // A
+            pixels[i + 3] = 0xFF;                               // A
           }
         }
       }
 
       // Draw a single point
       void point (Coord2 point, Color color) {
-        if (point.x > this->width || point.y > this->height) {return;};
+        if (point.x > getWidth() || point.y > getHeight()) {return;};
         putPixel(point.x, point.y, color.r, color.g, color.b, color.a);
       }
 
       // Uses Bresenham's line algorithm to draw line of any slope
       void line (Coord2 point0, Coord2 point1, Color color) {
-        if (point0.x > this->width || point0.y > this->height || point1.x > this->width || point1.y > this->height) {return;};
+        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) {
-            this->lineLow(x1, y1, x0, y0, color);
+            lineLow(x1, y1, x0, y0, color);
           } else {
-            this->lineLow(x0, y0, x1, y1, color);
+            lineLow(x0, y0, x1, y1, color);
           }
         } else {
           if (y0 > y1) {
-            this->lineHigh(x1, y1, x0, y0, color);
+            lineHigh(x1, y1, x0, y0, color);
           } else {
-            this->lineHigh(x0, y0, x1, y1, color);
+            lineHigh(x0, y0, x1, y1, color);
           }
         }
       }
 
-      // Draws a horizontally bounded trapezoid
+      // Draw a horizontally bounded trapezoid
-      // TODO: FIX
+      // coords.y1 >= coords.y0
+      // todo move to private and add public checks
       void trapezoid (Trapezoid coords, Color color) {
-        // UwU::Trapezoid saneCoords = coords;
+        printf("(%u, %u, %u, %u, %u, %u)", coords.y0, coords.y1, coords.xl0, coords.xl1, coords.xr0, coords.xr1);
-        // if (coords.y0 > coords.y1) {
+        uint16_t height = 1 + coords.y1 - coords.y0;
-        //   saneCoords.y0 = coords.y1;
+        int16_t LeftBound[height];
-        //   saneCoords.y1 = coords.y0;
+        int16_t RightBound[height];
-        //   saneCoords.xl0 = coords.xl1;
+  
-        //   saneCoords.xl1 = coords.xl0;
+        Helpers::bresenham(coords.xl0, coords.y1 - coords.y0, coords.xl1, LeftBound);
-        //   saneCoords.xr0 = coords.xr1;
+        Helpers::bresenham(coords.xr0, coords.y1 - coords.y0, coords.xr1, RightBound);
-        //   saneCoords.xr1 = coords.xr0;
+  
-        // }
+        for (uint16_t i = 0; i <= height; i++) {
-        // uint16_t tempVal;
+          for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
-        // bool hflip0 = false;
+            // printf("(%u, %u)", x, i + coords.y0);
-        // if (saneCoords.xl0 > saneCoords.xr0) {
+            putPixel((uint32_t)x, (uint32_t)i + coords.y0, color.r, color.g, color.b, color.a);
-        //   tempVal = saneCoords.xl0;
+          }
-        //   saneCoords.xl0 = saneCoords.xr0;
+        }
-        //   saneCoords.xr0 = tempVal;
+        return;
-        //   hflip0 = true;
+      }
-        // }
+
-        // if (saneCoords.xl1 > saneCoords.xr1) {
+      // Draw a triangle
-        //   if (!hflip0) {
+      void triangle (Triangle coords, Color color) {
-        //     // invalid geometry; emit console warning and don't attempt to draw
+        Coord2 top = Coord2();
-        //     // possible options are: don't draw, lazy draw (incorrect geometry) -
+        Coord2 mid = Coord2();
-        //     // or split into two (way more work)
+        Coord2 btm = Coord2();
-        //     return;
+        // cases: flat top, flat bottom, left point, right point
-        //   }
+        if (coords.y0 < coords.y1 && coords.y0 < coords.y2) {
-        //   tempVal = saneCoords.xl1;
+          top.x = coords.x0;
-        //   saneCoords.xl1 = saneCoords.xr1;
+          top.y = coords.y0;
-        //   saneCoords.xr1 = tempVal;
+          if (coords.y1 < coords.y2) {
-        // }
+            mid.x = coords.x1;
-        this->pTrapezoid(coords, color);
+            mid.y = coords.y1;
+            btm.x = coords.x2;
+            btm.y = coords.y2;
+          } else {
+            mid.x = coords.x2;
+            mid.y = coords.y2;
+            btm.x = coords.x1;
+            btm.y = coords.y1;
+          }
+        } else if (coords.y1 < coords.y0 && coords.y1 < coords.y2) {
+          top.x = coords.x1;
+          top.y = coords.y1;
+          if (coords.y0 < coords.y2) {
+            mid.x = coords.x0;
+            mid.y = coords.y0;
+            btm.x = coords.x2;
+            btm.y = coords.y2;
+          } else {
+            mid.x = coords.x2;
+            mid.y = coords.y2;
+            btm.x = coords.x0;
+            btm.y = coords.y0;
+          }
+        } else {
+          top.x = coords.x2;
+          top.y = coords.y2;
+          if (coords.y0 < coords.y1) {
+            mid.x = coords.x0;
+            mid.y = coords.y0;
+            btm.x = coords.x1;
+            btm.y = coords.y1;
+          } else {
+            mid.x = coords.x1;
+            mid.y = coords.y1;
+            btm.x = coords.x0;
+            btm.y = coords.y0;
+          }
+        }
+
+        // handle case where top or bottom is flat
+        if (mid.y == top.y) {
+          // flat top
+          if (mid.x < top.x) {
+            trapezoid(Trapezoid(top.y, btm.y, mid.x, btm.x, top.x, btm.x), color);
+            return;
+          } else {
+            trapezoid(Trapezoid(top.y, btm.y, top.x, btm.x, mid.x, btm.x), color);
+            return;
+          }
+        } else if (mid.y == btm.y) {
+          // flat bottom
+          if (mid.x < btm.x) {
+            trapezoid(Trapezoid(top.y, btm.y, top.x, mid.x, top.x, btm.x), color);
+            return;
+          } else {
+            trapezoid(Trapezoid(top.y, btm.y, top.x, btm.x, top.x, mid.x), color);
+            return;
+          }
+        }
+
+        // calculate midpoint of straight line
+        int32_t dy = (int32_t)btm.y - (int32_t)top.y;
+        if (dy == 0) {
+          return; // shouldn't be possible, should be detected earlier
+        }
+        int32_t dx = (int32_t)btm.x - (int32_t)top.x;
+        dx *= (mid.y - top.y);
+        dx /= dy;
+        dx += top.x;
+        uint16_t oppx = (uint16_t)dx;
+
+        // split triangle into two trapezoids
+        if (mid.x < oppx) {
+          trapezoid(Trapezoid(top.y, mid.y, top.x, mid.x, top.x, oppx), color);
+          trapezoid(Trapezoid(mid.y, btm.y, mid.x, btm.x, oppx, btm.x), color);
+          return;
+        } else {
+          trapezoid(Trapezoid(top.y, mid.y, top.x, oppx, top.x, mid.x), color);
+          trapezoid(Trapezoid(mid.y, btm.y, oppx, btm.x, mid.x, btm.x), color);
+          return;
+        }
+        return; // nothing should ever reach this
       }
     };
   }
@@ -341,7 +363,8 @@ int main(void) {
   draw.rectangle(UwU::Coord2(69, 69), UwU::Coord2(420, 420), fuchsia);
   draw.rectangleGradient(UwU::Coord2(200, 200), UwU::Coord2(600, 400), red, blue, alpha, red);
 
-  // draw.trapezoid(UwU::Trapezoid(400, 500, 360, 360, 400, 601), green);
+  draw.trapezoid(UwU::Trapezoid(300, 400, 360, 380, 600, 400), green);
+  draw.triangle(UwU::Triangle(200, 100, 240, 200, 320, 300), green);
 
 
   draw.point(UwU::Coord2(387, 43), green);
@@ -353,12 +376,12 @@ int main(void) {
   draw.line(UwU::Coord2(250, 300), UwU::Coord2(100, 469), green);
   draw.line(UwU::Coord2(100, 300), UwU::Coord2(469, 250), green);
   draw.line(UwU::Coord2(469, 300), UwU::Coord2(100, 250), green);
-  waymini_present(draw.wm);
+  draw.present();
 
   while (!waymini_should_close(draw.wm)) {
     if (waymini_dispatch(draw.wm) < 0) break;
   }
 
-  waymini_destroy(draw.wm);
+  draw.destroy();
   return 0;
 }