/* Example program that links against the waymini library. * No external dependencies beyond waymini itself and the C standard library. */ #include "waymini.h" #include #include #include #include // this should be handled elsewhere, eventually, maybe, probably static void on_key(void *user, uint32_t keycode, uint32_t state) { (void)user; const char *label = state ? "down" : "up "; printf("key %s: %u\n", label, keycode); fflush(stdout); } namespace UwU { // Color datatype returns individual channel values from rgba hexcode struct Color { Color(uint32_t hex) { this->a = hex & 0x000000ff; this->b = (hex & 0x0000ff00) >> 8; this->g = (hex & 0x00ff0000) >> 16; this->r = (hex & 0xff000000) >> 24; } Color() {} uint8_t r; uint8_t g; uint8_t b; uint8_t a; }; // Coord2 datatype for xy coordinates, from top-left of surface struct Coord2 { Coord2(uint32_t x, uint32_t y) { this->x = x; this->y = y; } uint32_t x; uint32_t y; }; class Draw { private: uint8_t lerp8(uint8_t a, uint8_t b, uint8_t t) { uint16_t product = (a * (255 - t)) + (b * t); return product / 255; } Color lerpColor(Color a, Color b, uint8_t t) { Color mixed = Color(); mixed.r = this->lerp8(a.r, b.r, t); mixed.g = this->lerp8(a.g, b.g, t); mixed.b = this->lerp8(a.b, b.b, t); mixed.a = this->lerp8(a.a, b.a, t); return mixed; } 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; uint8_t b0 = this->pixels[i + 0]; uint8_t g0 = this->pixels[i + 1]; uint8_t r0 = this->pixels[i + 2]; b = lerp8(b0, b, a); g = lerp8(g0, g, a); r = lerp8(r0, r, a); this->pixels[i + 0] = b; // B this->pixels[i + 1] = g; // G this->pixels[i + 2] = r; // R this->pixels[i + 3] = 0xff; // A } // plot lines if m <= 1 void lineLow(int32_t x0, int32_t y0, int32_t x1, int32_t y1, Color color) { int32_t dx = x1 - x0; int32_t dy = y1 - y0; int32_t yi = 1; if (dy < 0) { yi = -1; dy = -dy; } int32_t d = (2 * dy) - dx; int32_t y = y0; for (int32_t x = x0; x < x1; x++) { putPixel(x, y, color.r, color.g, color.b, color.a); if (d > 0) { y += yi; d += (2 * (dy - dx)); } else { d += (2 * dy); } } return; } // plot lines if m >1 void lineHigh(int32_t x0, int32_t y0, int32_t x1, int32_t y1, Color color) { int32_t dx = x1 - x0; int32_t dy = y1 - y0; int32_t xi = 1; if (dx < 0) { xi = -1; dx = -dx; } int32_t d = (2 * dx) - dy; int32_t x = x0; for (int32_t y = y0; y < y1; y++) { putPixel(x, y, color.r, color.g, color.b, color.a); if (d > 0) { x += xi; d += (2 * (dx - dy)); } else { d += (2 * dx); } } return; } // plot gradients' lerp t value if m <= 1 void gradLow(int32_t x1, uint8_t* gradLut) { int32_t dx = x1; int32_t dy = 256; int32_t d = (2 * dy) - dx; int32_t y = 0; for (int32_t x = 0; x < x1; x++) { gradLut[x] = (uint8_t)y; if (d > 0) { y++; d += (2 * (dy -dx)); } else { d += (2 * dy); } } return; } // plot gradients' lerp t value if m >1 void gradHigh(int32_t x1, uint8_t* gradLut) { int32_t dx = x1; int32_t dy = 256; int32_t d = (2 * dx) - dy; int32_t x = 0; for (int32_t y = 0; y < 256; y++) { gradLut[x] = (uint8_t)y; if (d > 0) { x++; d += (2 * (dx -dy)); } else { d += (2 * dx); } } 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->height = waymini_get_height(this->wm); this->stride = waymini_get_stride(this->wm); printf("surface: %ux%u stride=%u\n", this->width, this->height, this->stride); this->pixels = (uint8_t *)waymini_get_pixels(this->wm); if (!this->pixels) { waymini_destroy(this->wm); exit(1); } } // 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;}; 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); } } 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; int32_t h = y1 - y0; uint8_t xGrad[w]; uint8_t yGrad[h]; // determine m and calculate horizontal gradient coefficient if (w < 256) { this->gradHigh(w, xGrad); } else { this->gradLow(w, xGrad); } // determine m and calculate vertical gradient coefficient if (h < 256) { this->gradHigh(h, yGrad); } else { this->gradLow(h, 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 = this->lerpColor(colorUL, colorLL, yGrad[y - y0]); Rmix = this->lerpColor(colorUR, colorLR, yGrad[y - y0]); for (int32_t x = x0; x < x1; x++) { Xmix = this->lerpColor(Lmix, Rmix, xGrad[x - x0]); putPixel(x, y, Xmix.r, Xmix.g, Xmix.b, Xmix.a); } } return; } // Fill a simple gradient. Each row is stride bytes. void rainbow() { for (uint32_t y = 0; y < this->height; y++) { for (uint32_t x = 0; x < this->width; x++) { size_t i = (size_t)y * waymini_get_stride(this->wm) + (size_t)x * 4; this->pixels[i + 0] = (uint8_t)(y * 255 / this->height); // B this->pixels[i + 1] = 0x00; // G this->pixels[i + 2] = (uint8_t)(x * 255 / this->width); // R this->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;}; 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;}; 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); } else { this->lineLow(x0, y0, x1, y1, color); } } else { if (y0 > y1) { this->lineHigh(x1, y1, x0, y0, color); } else { this->lineHigh(x0, y0, x1, y1, color); } } } }; } int main(void) { uint32_t w = 800, h = 480; UwU::Color fuchsia = UwU::Color(0xb00b6940); UwU::Color red = UwU::Color(0xff0000ff); UwU::Color green = UwU::Color(0x00ff00ff); UwU::Color blue = UwU::Color(0x0000ffff); UwU::Color alpha = UwU::Color(0xffffff00); printf("r: %u, g:%u, b:%u, a:%u\n", fuchsia.r, fuchsia.g, fuchsia.b, fuchsia.a); // struct waymini *wm = waymini_create(w, h, on_key, NULL); UwU::Draw draw = UwU::Draw(w, h, on_key); draw.rainbow(); draw.rectangle(UwU::Coord2(69, 69), UwU::Coord2(420, 420), fuchsia); draw.rectangleGradient(UwU::Coord2(200, 200), UwU::Coord2(600, 400), red, blue, blue, red); draw.point(UwU::Coord2(387, 43), green); draw.line(UwU::Coord2(300, 100), UwU::Coord2(250, 469), green); draw.line(UwU::Coord2(250, 100), UwU::Coord2(300, 469), green); draw.line(UwU::Coord2(300, 100), UwU::Coord2(469, 250), green); draw.line(UwU::Coord2(469, 100), UwU::Coord2(300, 250), green); draw.line(UwU::Coord2(100, 300), UwU::Coord2(250, 469), green); 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); while (!waymini_should_close(draw.wm)) { if (waymini_dispatch(draw.wm) < 0) break; } waymini_destroy(draw.wm); return 0; }