UwUGL/test.cpp

/* 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>


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 {
    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(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint8_t r, uint8_t g, uint8_t b) {
        if (x0 > this->width || y0 > this->height || x1 > this->width || y1 > this->height) {return;};
        for (uint32_t y = y0; y < y1; y++) {
          for (uint32_t x = x0; x < x1; x++) {
            size_t i = (size_t)y * waymini_get_stride(this->wm) + (size_t)x * 4;
            this->pixels[i + 0] = b;    // B
            this->pixels[i + 1] = g;    // G
            this->pixels[i + 2] = r;    // R
            this->pixels[i + 3] = 0xFF; // 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
          }
        }
      }

      void point (uint32_t x, uint32_t y, uint8_t r, uint8_t g, uint8_t b) {
        if (x > this->width || y > this->height) {return;};
        size_t i = (size_t)y * waymini_get_stride(this->wm) + (size_t)x * 4;
        this->pixels[i + 0] = b;    // B
        this->pixels[i + 1] = g;    // G
        this->pixels[i + 2] = r;    // R
        this->pixels[i + 3] = 0xFF; // A
      }

      // // Uses Bresenham's line algorithm to draw line of any slope
      // void line (uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint8_t r, uint8_t g, uint8_t b) {
      //   if (x0 > this->width || y0 > this->height || x1 > this->width || y1 > this->height) {return;};
      //   int32_t dx = (int32_t)x1 - (int32_t)x0;
      //   int32_t dy = (int32_t)y1 - (int32_t)y1;
      //   int32_t yi = 1;
      //   if (dy < 0) {
      //     yi = -1;
      //     dy = -dy;
      //   }
      //   int32_t d = (2 * dy) - dx;
      //   int32_t y = y0
      //   for (uint32_t x = x0; x < x1; x++) {

      //   }
      //   size_t i = (size_t)y * waymini_get_stride(this->wm) + (size_t)x * 4;
      //   this->pixels[i + 0] = b;    // B
      //   this->pixels[i + 1] = g;    // G
      //   this->pixels[i + 2] = r;    // R
      //   this->pixels[i + 3] = 0xFF; // A
      // }
    };
  }

int main(void) {
  uint32_t w = 800, h = 480;

  // struct waymini *wm = waymini_create(w, h, on_key, NULL);
  UwU::Draw draw = UwU::Draw(w, h, on_key);

  draw.rainbow();

  waymini_present(draw.wm);
  draw.rectangle(69, 69, 420, 420, 0xB0, 0x0B, 0x69);
  draw.point(387, 43, 0x00, 0xff, 0x00);

  while (!waymini_should_close(draw.wm)) {
    if (waymini_dispatch(draw.wm) < 0) break;
  }

  waymini_destroy(draw.wm);
  return 0;
}