388 lines
12 KiB
C++
388 lines
12 KiB
C++
/* Example program that links against the waymini library.
|
|
* No external dependencies beyond waymini itself and the C standard library.
|
|
*/
|
|
|
|
#include "waymini.h"
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#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) {
|
|
(void)user;
|
|
const char *label = state ? "down" : "up ";
|
|
printf("key %s: %u\n", label, keycode);
|
|
fflush(stdout);
|
|
}
|
|
|
|
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(wm) + (size_t)x * 4;
|
|
uint8_t b0 = pixels[i + 0];
|
|
uint8_t g0 = pixels[i + 1];
|
|
uint8_t r0 = pixels[i + 2];
|
|
b = Helpers::lerp8(b0, b, a);
|
|
g = Helpers::lerp8(g0, g, a);
|
|
r = Helpers::lerp8(r0, r, a);
|
|
pixels[i + 0] = b; // B
|
|
pixels[i + 1] = g; // G
|
|
pixels[i + 2] = r; // R
|
|
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;
|
|
}
|
|
|
|
public:
|
|
|
|
|
|
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", 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) {
|
|
waymini_destroy(this->wm);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
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 > 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);
|
|
}
|
|
}
|
|
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, w - 1, 255, xGrad);
|
|
Helpers::bresenham(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);
|
|
}
|
|
}
|
|
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++) {
|
|
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);
|
|
}
|
|
|
|
// 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(coords.xl0, coords.y1 - coords.y0, coords.xl1, LeftBound);
|
|
Helpers::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++) {
|
|
// printf("(%u, %u)", x, i + coords.y0);
|
|
putPixel((uint32_t)x, (uint32_t)i + coords.y0, color.r, color.g, color.b, color.a);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Draw a triangle
|
|
void triangle (Triangle coords, Color color) {
|
|
Coord2 top = Coord2();
|
|
Coord2 mid = Coord2();
|
|
Coord2 btm = Coord2();
|
|
// cases: flat top, flat bottom, left point, right point
|
|
if (coords.y0 < coords.y1 && coords.y0 < coords.y2) {
|
|
top.x = coords.x0;
|
|
top.y = coords.y0;
|
|
if (coords.y1 < coords.y2) {
|
|
mid.x = coords.x1;
|
|
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
|
|
}
|
|
};
|
|
}
|
|
|
|
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(0x00000000);
|
|
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, alpha, red);
|
|
|
|
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);
|
|
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);
|
|
draw.present();
|
|
|
|
while (!waymini_should_close(draw.wm)) {
|
|
if (waymini_dispatch(draw.wm) < 0) break;
|
|
}
|
|
|
|
draw.destroy();
|
|
return 0;
|
|
}
|