minor cleanup

FEATURES.md

@@ -0,0 +1,19 @@
+shapes:
+  triangles:
+    point
+    line
+      solid
+      gradient
+    rectangle
+      solid
+      gradient
+      blitter (tilemaps)
+    triangle
+      solid
+      gradient
+      perspective mapping (3D!!!)
+    quad
+      solid
+      gradient (charts)
+      blitter (isometric)
+      affine mapping (sprite rotation and scaling)

STYLEGUIDE.md

@@ -0,0 +1,127 @@
+# UwUGL Styleguide
+
+This document describes the coding conventions used in UwUGL, inferred from the existing codebase. It prioritizes readability and simplicity for a small graphics library.
+
+---
+
+## 1. File Organization
+
+- **Single monolithic header**: `uwugl.h` is the public entry point and includes all implementation files.
+- **Header-like `.cpp` files**: Every implementation file begins with `#pragma once` and is designed to be `#include`d directly by `uwugl.h` (or by other `.cpp` files). There are no traditional separate `.h`/`.cpp` pairs.
+- **No separate headers for internal modules**: Classes and structs are declared and defined directly in `.cpp` files.
+- **Exception**: `shaders/shaders.h` is a small aggregator file that includes the shader `.cpp` files.
+- **Directory layout**:
+  - `primatives/` — shape classes (`Line`, `Point`, `Rectangle`, `Trapezoid`, `Triangle`)
+  - `shaders/` — shader classes and base
+  - `waymini/` — external Wayland helper library (C)
+
+## 2. Naming Conventions
+
+- **Namespace**: All library code lives in `namespace UwU`.
+- **Classes / structs**: PascalCase (`Buffer`, `ColorShader`, `Rectangle`, `Helpers`).
+- **Functions / methods**: camelCase (`drawPixel`, `lerpColor`, `bresenham`, `shouldClose`).
+- **Member variables**: lowercase with no prefix (`pixels`, `width`, `x0`, `c`).
+- **Template parameters**: PascalCase ending in `T` (`ShaderT`).
+- **Enums**: PascalCase type name; UPPER_SNAKE_CASE values (`ShaderType`, `COLOR`, `HGRADIENT`, `VGRADIENT`).
+- **Constants in code**: prefer lowercase; UPPER_SNAKE_CASE may be used for local compile-time-ish constants in comments or test code.
+- **Filenames**: lowercase and descriptive (`buffer.cpp`, `colorshader.cpp`, `line.cpp`).
+
+## 3. Formatting
+
+- **Indentation**: 2 spaces.
+- **Brace style**: K&R — opening brace on the same line as the class/function/control statement.
+- **Pointer/reference syntax**: attach `*` and `&` to the variable name:
+  - `uint8_t* pixels`
+  - `ShaderBase<ShaderT>& shader`
+- **Empty parameter lists**: use `()` for default constructors, e.g., `Color() {}`.
+- **Spacing around operators**: use spaces around binary operators for readability (`x + y` instead of `x+y`).
+- **Explicit `return;` at end of void functions**: Acceptable, but not required.
+- **Comments**: use `//` for both inline and block-style comments. Keep them informal and focused on intent or known issues.
+
+## 4. Includes
+
+Include order within a file:
+
+1. `#pragma once`
+2. C/C++ standard headers (`<stdint.h>`, `<stdio.h>`, `<algorithm>`)
+3. Project implementation files via relative paths (`"../datatypes.cpp"`, `"../buffer.cpp"`)
+
+External C library headers (e.g., `"waymini/waymini.h"`) are included where needed.
+
+## 5. Code Patterns
+
+- **Composition over inheritance**: primitives hold data; shaders are passed into `draw()`.
+- **CRTP for shaders**: `ShaderBase<ShaderT>` uses the Curiously Recurring Template Pattern for static polymorphism.
+- **Template `draw` methods**: every primitive's `draw()` is templated on `ShaderT` and takes `(Buffer buffer, ShaderBase<ShaderT>& shader)`.
+- **Manual memory management**: `new uint8_t[...]` in `Buffer`; no smart pointers.
+- **C-style casts**: `(uint16_t)x`, `(uint8_t*)ptr`.
+- **Bounds checks**: primitives guard `draw()` with `if (x > buffer.width || y > buffer.height) {return;};`.
+- **Unused parameter suppression**: use `(void)param;` to silence warnings.
+
+## 6. C++ Feature Usage
+
+### Used
+
+- Classes and structs
+- Namespaces
+- Templates (`template <class ShaderT>`)
+- CRTP (Curiously Recurring Template Pattern)
+- Function overloading (constructors)
+- References
+- C-style casts
+- `new` / `new[]` for dynamic allocation
+- Raw pointers
+- Stack-allocated arrays
+- C standard headers (`<stdint.h>`, `<stdio.h>`, `<stdlib.h>`, `<string.h>`, `<time.h>`, `<algorithm>`)
+
+### Not Used but Allowed
+- Smart pointers (`std::unique_ptr`, `std::shared_ptr`)
+- Standard containers (`std::vector`, `std::array`, etc.)
+- `enum class`
+- Exceptions
+- `std::string`
+- `std::chrono`
+- `std::function`
+
+### Not Used
+
+The following features are intentionally not used. This keeps the codebase small, predictable, and easy to reason about.
+
+- `auto`
+- Range-based `for` loops
+- `nullptr`
+- Lambda expressions
+- `constexpr` / `consteval`
+- `using` type aliases
+- Move semantics / rvalue references
+- Default member initializers
+- Delegating constructors
+- `override` / `final`
+- Named casts (`static_cast`, `reinterpret_cast`, etc.)
+- Structured bindings
+- Concepts / `requires` (C++20)
+- Virtual functions / runtime polymorphism / abstract base classes
+- Operator overloading
+- RTTI / `dynamic_cast` / `typeid`
+- `<iostream>` (use C-style `printf`/`fflush`)
+
+## 7. Build System
+
+- **Makefile-based**.
+- C library (`waymini`) compiled with `gcc`.
+- Main example compiled with `g++`.
+- Flags: `-Wall -Wextra -O3`, plus Wayland client flags from `pkg-config`.
+
+## 8. Known Inconsistencies and Recommendations
+
+The codebase currently has a few inconsistencies. The following recommendations aim to improve readability without adding complexity:
+
+- **Indentation consistency**: some blocks are not aligned (e.g., `line.cpp` inner loop). Keep all indentation strictly at 2 spaces per level.
+- **Spacing consistency**: standardize on spaces around binary operators and after commas.
+- **Include consistency**: some primitives include `../shaders/shaders.h` while `rectangle.cpp` also includes `../shaders/shaderbase.cpp` directly. Prefer the aggregator `shaders.h` everywhere.
+- **`return;` at end of void functions**: acceptable, but can be omitted when it adds no clarity.
+- **Bounds check style**: the pattern `if (...) {return;};` has a redundant semicolon. Prefer `if (...) { return; }`.
+
+---
+
+This guide should evolve with the project. When in doubt, favor simplicity and consistency with the existing code.

TODO

@@ -1,5 +1,15 @@
-[ ] write a monolithic header file
+[x] write a monolithic header file
 [x] refactor example code using composition
 [x] remove draw class entirely
 [x] create shader classes with polymorphism
-[ ] optimize shader/primative performance (repeat myself!)
+[x] optimize shader/primative performance (repeat myself!)
+[x] finish implementing gradient shaders to primatives
+[x] implement buffer shader
+[ ] implement more primatives
+[ ] fix off by one with buffer shader (and probably certain primatives)
+[ ] fix memory leak and arrays in stack issue
+[ ] fix shader offset limitations and headache
+[ ] maybe add blitter primative?
+[ ] support for lower color depths
+[ ] support for transparency
+[ ] 15bpp + dither "shader"

buffer.cpp

@@ -4,15 +4,14 @@
 
 #include "datatypes.cpp"
 #include "helpers.cpp"
-#include "shader.cpp"
+// #include "shader.cpp"
 
 namespace UwU {
       // Buffer object - can be a wayland surface or a virtual buffer
   class Buffer {
     public:
         Buffer(uint16_t width, uint16_t height) {
-        uint8_t pixels[width * height * 4];
-        this->pixels = pixels;
+        this->pixels = new uint8_t[width * height * 4];
         this->width = width;
         this->height = height;
         this->stride = width * 4;

datatypes.cpp

@@ -37,30 +37,30 @@ namespace UwU {
   };
 
   // Vec2 datatype for signed x, y coordinates
-  struct Vec2 {
-    Vec2(int16_t x, int16_t y) {
-      this->x = x;
-      this->y = y;
-    }
-    Vec2() {}
-    int16_t x;
-    int16_t y;
-  };
+  // struct Vec2 {
+  //   Vec2(int16_t x, int16_t y) {
+  //     this->x = x;
+  //     this->y = y;
+  //   }
+  //   Vec2() {}
+  //   int16_t x;
+  //   int16_t y;
+  // };
 
-  // 2x2 matrix, Q15.16 signed fixed point
-  struct Matrix4 {
-    Matrix4(int32_t xx, int32_t xy, int32_t yx, int32_t yy) {
-      this->xx = xx;
-      this->xy = xy;
-      this->yx = yx;
-      this->yy = yy;
-    }
-    Matrix4() {}
-    int32_t xx;  // x' = x*xx + y*xy
-    int32_t xy;
-    int32_t yx;  // y' = x*yx + y*yy
-    int32_t yy;
-  };
+  // // 2x2 matrix, Q15.16 signed fixed point
+  // struct Matrix4 {
+  //   Matrix4(int32_t xx, int32_t xy, int32_t yx, int32_t yy) {
+  //     this->xx = xx;
+  //     this->xy = xy;
+  //     this->yx = yx;
+  //     this->yy = yy;
+  //   }
+  //   Matrix4() {}
+  //   int32_t xx;  // x' = x*xx + y*xy
+  //   int32_t xy;
+  //   int32_t yx;  // y' = x*yx + y*yy
+  //   int32_t yy;
+  // };
 
   // class Mapper {
   //   public:
@@ -74,7 +74,8 @@ namespace UwU {
   enum ShaderType {
     COLOR,
     HGRADIENT,
-    VGRADIENT
+    VGRADIENT,
+    BUFFER
   };
 
   enum Direction {

example.cpp

@@ -7,18 +7,10 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "datatypes.cpp"
-#include "helpers.cpp"
-#include "buffer.cpp"
-#include "surface.cpp"
-#include "primatives/line.cpp"
-#include "primatives/point.cpp"
-#include "primatives/rectangle.cpp"
-#include "primatives/trapezoid.cpp"
-#include "primatives/triangle.cpp"
-#include "shader.cpp"
-
+#include "uwugl.h"
 #include <time.h>
+#include "font.cpp"
+
 
 static void onKey(void *user, uint32_t keycode, uint32_t state) {
   if (keycode == 1) {
@@ -32,52 +24,67 @@ static void onKey(void *user, uint32_t keycode, uint32_t state) {
 
 int main(void) {
   uint16_t w = 800, h = 480;
-  UwU::Shader fuchsia = UwU::Shader(UwU::Direction::H, 360, 600, UwU::Color(0xb00b69ff), UwU::Color(0x00000000));
-  UwU::Shader red = UwU::Shader(UwU::Direction::V, 69, 420, UwU::Color(0xff0000ff), UwU::Color(0x00000000));
-  UwU::Shader warmup = UwU::Shader(UwU::Color(0xb00b69ff));
-  UwU::Color green = UwU::Color(0x00ff00ff);
-  UwU::Color blue = UwU::Color(0x0000ff80);
-  // UwU::Color alpha = UwU::Color(0x00000000);
   
   UwU::Surface surface = UwU::Surface(w, h, onKey);
-  // UwU::Buffer buffer = UwU::Buffer(surface.getWidth(), surface.getHeight());
-  
+
+  // UwU::Color fuchsia = UwU::Color(0xb00b69ff);
+  UwU::Color red = UwU::Color(0xff0000ff);
+  UwU::Color green = UwU::Color(0x00ff00ff);
+  UwU::Color blue = UwU::Color(0x0000ffff);
+
+  // UwU::ColorTexture fuchsia = UwU::ColorTexture(UwU::Color(0xb00b69ff));
+  UwU::HGradientTexture bisexual = UwU::HGradientTexture(180, red, blue);
+  UwU::OffsetMapper offsetMapper = UwU::OffsetMapper();
+  UwU::Tilemap myTilemap = UwU::Tilemap();
+  myTilemap.tilemap[0] = 0x0000;
+  myTilemap.tilemap[1] = 0x0001;
+  myTilemap.tilemap[2] = 0x0000;
+  myTilemap.tilemap[3] = 0x0002;
+  myTilemap.tilemap[4] = 0x0003;
+  UwU::Buffer fontBuffer = font();
+  UwU::TilemapTexture textMap = UwU::TilemapTexture(myTilemap, fontBuffer);
   UwU::Rectangle rectangle = UwU::Rectangle(69, 69, 420, 420);
-  UwU::Trapezoid trapezoid = UwU::Trapezoid(300, 400, 360, 380, 600, 480);
-  UwU::Triangle triangle = UwU::Triangle(280, 100, 240, 290, 320, 300);
-  UwU::Point point = UwU::Point(387, 43);
+  rectangle.draw(surface.buffer, offsetMapper, textMap);
 
-  rectangle.draw(surface.buffer, red);
+  UwU::ColorTexture greenTexture = UwU::ColorTexture(green);
+  UwU::NullMapper nullMapper = UwU::NullMapper();
+  UwU::Point point = UwU::Point(187, 37);
+  point.draw(surface.buffer, nullMapper, greenTexture);
 
-  // Benchmarking
-  struct timespec start, end;
-  const int WARMUP = 100;
-  const int BATCH = 1000;
-  const int SAMPLES = 10;
+  UwU::ColorTexture blueTexture = UwU::ColorTexture(blue);
+  UwU::Trapezoid trapezoid = UwU::Trapezoid(100, 300, 690, 320, 720, 780);
+  trapezoid.draw(surface.buffer, nullMapper, blueTexture);
 
-  for (int i = 0; i < WARMUP; i++) {
-    trapezoid.draw(surface.buffer, fuchsia);
-  }
-  long times[SAMPLES];
-  for (int s = 0; s < SAMPLES; s++) {
-    clock_gettime(CLOCK_MONOTONIC, &start);
-    for (int i = 0; i < BATCH; i++) {
-      trapezoid.draw(surface.buffer, fuchsia);
-    }
-    clock_gettime(CLOCK_MONOTONIC, &end);
-    times[s] = (end.tv_sec - start.tv_sec) * 1000000000L + (end.tv_nsec - start.tv_nsec);
-  }
-  long timeAvg = 0;
-  for (int i = 0; i < SAMPLES; i++) {
-    timeAvg += times[i];
-  }
-  timeAvg /= SAMPLES;
-  timeAvg /= BATCH;
-  printf("Elapsed: %ld ns\n", timeAvg);
+  UwU::ColorTexture redTexture = UwU::ColorTexture(red);
+  UwU::Triangle triangle = UwU::Triangle(140, 140, 60, 400, 240, 240);
+  triangle.draw(surface.buffer, offsetMapper, bisexual);
   
-  triangle.draw(surface.buffer, blue);
+  // // Benchmarking
+  // struct timespec start, end;
+  // const int WARMUP = 100;
+  // const int BATCH = 1000;
+  // const int SAMPLES = 10;
+  
+  // for (int i = 0; i < WARMUP; i++) {
+  //   rectangle.draw(surface.buffer, gradientBuffer);
+  // }
+  // long times[SAMPLES];
+  // for (int s = 0; s < SAMPLES; s++) {
+  //   clock_gettime(CLOCK_MONOTONIC, &start);
+  //   for (int i = 0; i < BATCH; i++) {
+  //     rectangle.draw(surface.buffer, gradientBuffer);
+  //   }
+  //   clock_gettime(CLOCK_MONOTONIC, &end);
+  //   times[s] = (end.tv_sec - start.tv_sec) * 1000000000L + (end.tv_nsec - start.tv_nsec);
+  // }
+  // long timeAvg = 0;
+  // for (int i = 0; i < SAMPLES; i++) {
+  //   timeAvg += times[i];
+  // }
+  // timeAvg /= SAMPLES;
+  // timeAvg /= BATCH;
+  // printf("Elapsed: %ld ns\n", timeAvg);
   
-  point.draw(surface.buffer, green);
   
   UwU::Line lines[8] {
     UwU::Line(300, 100, 250, 469),
@@ -91,7 +98,7 @@ int main(void) {
   };
 
   for (uint16_t i = 0; i < 8; i++) {
-    lines[i].draw(surface.buffer, green);
+    lines[i].draw(surface.buffer, nullMapper, blueTexture);
   }
 
 

font.cpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "buffer.cpp"
+
+
+
+UwU::Buffer font() {
+  const uint32_t fontInt[9] = {
+    0xcc003f00,
+    0xcc004300,
+    0xcf33c300,
+    0xcf33c300,
+    0xcf33df00,
+    0xcf33cf00,
+    0xcf33cf00,
+    0xcf33cf00,
+    0x7ffeffe0
+  };
+
+  UwU::Buffer font = UwU::Buffer(32, 9);
+  uint32_t t;
+  uint32_t b;
+  for (uint16_t y = 0; y < 9; y++) {
+    t = fontInt[y];
+    for (uint16_t x = 0; x < 32; x++) {
+      b = t & 0x80000000;
+      if (b == 0x80000000) {
+        font.pixels[(y * 128) + (x * 4) + 0] = 0xff;
+        font.pixels[(y * 128) + (x * 4) + 1] = 0xff;
+        font.pixels[(y * 128) + (x * 4) + 2] = 0xff;
+        font.pixels[(y * 128) + (x * 4) + 3] = 0xff;
+      } else {
+        font.pixels[(y * 128) + (x * 4) + 0] = 0x00;
+        font.pixels[(y * 128) + (x * 4) + 1] = 0x00;
+        font.pixels[(y * 128) + (x * 4) + 2] = 0x00;
+        font.pixels[(y * 128) + (x * 4) + 3] = 0x00;
+      }
+      t = t << 1;
+    }
+  }
+  return font;
+}

helpers.cpp

@@ -90,5 +90,9 @@ namespace UwU {
         }
         return;
       }
+
+      // plot a 90 degree arc
+      static void fastArc(uint16_t radius, uint16_t* LUT) {
+      }
   };
 }

mappers/mapperbase.cpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+
+namespace UwU {
+  template <class MapperT>
+  class MapperBase {
+    public:
+      Coord2 map(uint16_t x0, uint16_t y0, uint16_t x, uint16_t y) {
+        return static_cast<MapperT*>(this)->map(x0, y0, x, y);
+     }
+  };
+}

mappers/mappers.h

@@ -0,0 +1,4 @@
+#include "mapperbase.cpp"
+#include "nullmapper.cpp"
+#include "offsetmapper.cpp"
+// #include "tilemapper.cpp"

mappers/nullmapper.cpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "mapperbase.cpp"
+
+namespace UwU {
+  class NullMapper : public MapperBase<NullMapper> {
+    public:
+      NullMapper() {}
+
+      Coord2 map(uint16_t x0, uint16_t y0, uint16_t x, uint16_t y) {
+        (void)x0;
+        (void)y0;
+        return Coord2(x, y);
+     }
+  };
+}

mappers/offsetmapper.cpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "mapperbase.cpp"
+
+namespace UwU {
+  class OffsetMapper : public MapperBase<OffsetMapper> {
+    public:
+      OffsetMapper() {}
+
+      Coord2 map(uint16_t x0, uint16_t y0, uint16_t x, uint16_t y) {
+        uint16_t u = x -x0;
+        uint16_t v = y -y0;
+        return Coord2(u, v);
+     }
+  };
+}

primatives/line.cpp

@@ -5,13 +5,16 @@
 #include "../datatypes.cpp"
 #include "../helpers.cpp"
 #include "../buffer.cpp"
+#include "../mappers/mappers.h"
+#include "../textures/textures.h"
 
 namespace UwU {
   // line
   class Line {
     private:
       // plot lines if m <= 1
-      void lineLow(int16_t ix0, int16_t iy0, int16_t ix1, int16_t iy1, Buffer buffer, Color color) {
+      template <class MapperT, class TextureT>
+      void lineLow(int16_t ix0, int16_t iy0, int16_t ix1, int16_t iy1, Buffer buffer, MapperBase<MapperT>& mapper, TextureBase<TextureT>& texture) {
         int16_t dx = ix1 - ix0;
         int16_t dy = iy1 - iy0;
         int16_t yi = 1;
@@ -21,8 +24,12 @@ namespace UwU {
         }
         int16_t d = (2 * dy) - dx;
         int16_t y = iy0;
+
+        Coord2 uv;
+
         for (int16_t x = ix0; x < ix1; x++) {
-          buffer.drawPixel((uint16_t)x, (uint16_t)y, color);
+          uv = mapper.map(ix0, iy0, x, y);
+          buffer.drawPixel((uint16_t)x, (uint16_t)y, texture.texel(uv.x, uv.y));
           if (d > 0) {
             y += yi;
             d += (2 * (dy - dx));
@@ -34,7 +41,8 @@ namespace UwU {
       }
 
       // plot lines if m >1
-      void lineHigh(int16_t ix0, int16_t iy0, int16_t ix1, int16_t iy1, Buffer buffer, Color color) {
+      template <class MapperT, class TextureT>
+      void lineHigh(int16_t ix0, int16_t iy0, int16_t ix1, int16_t iy1, Buffer buffer, MapperBase<MapperT>& mapper, TextureBase<TextureT>& texture) {
         int16_t dx = ix1 - ix0;
         int16_t dy = iy1 - iy0;
         int16_t xi = 1;
@@ -44,16 +52,20 @@ namespace UwU {
         }
         int16_t d = (2 * dx) - dy;
         int16_t x = ix0;
+
+        Coord2 uv;
+
         for (int16_t y = iy0; y < iy1; y++) {
-          buffer.drawPixel((uint16_t)x, (uint16_t)y, color);
+          uv = mapper.map(ix0, iy0, x, y);
+          buffer.drawPixel((uint16_t)x, (uint16_t)y, texture.texel(uv.x, uv.y));
           if (d > 0) {
             x += xi;
             d += (2 * (dx - dy));
           } else {
             d += (2 * dx);
           }
-        }
-        return;
+      }
+      return;
       }
 
     public:
@@ -70,7 +82,8 @@ namespace UwU {
       uint16_t y1;
 
       // Uses Bresenham's line algorithm to draw line of any slope
-      void draw (Buffer buffer, Color color) {
+      template <class MapperT, class TextureT>
+      void draw (Buffer buffer, MapperBase<MapperT>& mapper, TextureBase<TextureT>& texture) {
         if (x0 > buffer.width || y0 > buffer.height || x1 > buffer.width || y1 > buffer.height) {return;};
         int16_t ix0 = x0;
         int16_t iy0 = y0;
@@ -78,15 +91,15 @@ namespace UwU {
         int16_t iy1 = y1;
         if (abs(iy1 - iy0) < abs(ix1 - ix0)) {
           if (ix0 > ix1) {
-            lineLow(ix1, iy1, ix0, iy0, buffer, color);
+            lineLow(ix1, iy1, ix0, iy0, buffer, mapper, texture);
           } else {
-            lineLow(ix0, iy0, ix1, iy1, buffer, color);
+            lineLow(ix0, iy0, ix1, iy1, buffer, mapper, texture);
           }
         } else {
           if (iy0 > iy1) {
-            lineHigh(ix1, iy1, ix0, iy0, buffer, color);
+            lineHigh(ix1, iy1, ix0, iy0, buffer, mapper, texture);
           } else {
-            lineHigh(ix0, iy0, ix1, iy1, buffer, color);
+            lineHigh(ix0, iy0, ix1, iy1, buffer, mapper, texture);
           }
         }
         return;

primatives/point.cpp

@@ -5,6 +5,8 @@
 #include "../datatypes.cpp"
 #include "../helpers.cpp"
 #include "../buffer.cpp"
+#include "../mappers/mappers.h"
+#include "../textures/textures.h"
 
 namespace UwU {
   // point
@@ -18,10 +20,12 @@ namespace UwU {
       uint16_t x;
       uint16_t y;
       
-      // Draw a rectangle
-      void draw (Buffer buffer, Color color) {
+      // Draw a point
+      template <class MapperT, class TextureT>
+      void draw (Buffer buffer, MapperBase<MapperT>& mapper, TextureBase<TextureT>& texture) {
         if (x > buffer.width || y > buffer.height) {return;};
-        buffer.drawPixel(x, y, color);
+        Coord2 uv = mapper.map(x, y, x, y);
+        buffer.drawPixel(x, y, texture.texel(uv.x, uv.y));
         return;
       }
   };

primatives/primatives.h

@@ -0,0 +1,5 @@
+#include "point.cpp"
+#include "line.cpp"
+#include "rectangle.cpp"
+#include "trapezoid.cpp"
+#include "triangle.cpp"

primatives/rectangle.cpp

@@ -5,7 +5,8 @@
 #include "../datatypes.cpp"
 #include "../helpers.cpp"
 #include "../buffer.cpp"
-#include "../shader.cpp"
+#include "../mappers/mappers.h"
+#include "../textures/textures.h"
 
 namespace UwU {
   // rectangle
@@ -24,43 +25,16 @@ namespace UwU {
       uint16_t y1;
       
       // Draw a rectangle
-      void draw (Buffer buffer, Shader shader) {
-        if (shader.shaderType == COLOR) {
-          if (x0 > buffer.width || y0 > buffer.height || x1 > buffer.width || y1 > buffer.height) {return;};
-          for (uint16_t y = y0; y < y1; y++) {
-            for (uint16_t x = x0; x < x1; x++) {
-              buffer.drawPixel(x, y, shader.c0);
-            }
+      template <class MapperT, class TextureT>
+      void draw (Buffer buffer, MapperBase<MapperT>& mapper, TextureBase<TextureT>& texture) {
+        if (x0 > buffer.width || y0 > buffer.height || x1 > buffer.width || y1 > buffer.height) {return;};
+        for (uint16_t y = y0; y <= y1; y++) {
+          for (uint16_t x = x0; x <= x1; x++) {
+            Coord2 uv = mapper.map(x0, y0, x, y);
+            buffer.drawPixel(x, y, texture.texel(uv.x, uv.y));
           }
-          return;
-
-        } else if (shader.shaderType == HGRADIENT) {
-          if (x0 > buffer.width || y0 > buffer.height || x1 > buffer.width || y1 > buffer.height) {return;};
-
-          // Precompute gradient LUT
-          Color cols[x1 - x0];
-          for (uint16_t x = x0; x < x1; x++) {
-            cols[x - x0] = ShaderMethods::gradient(shader.u0, shader.scale, shader.c0, shader.c1, x);
-          }
-          
-          for (uint16_t y = y0; y < y1; y++) {
-            for (uint16_t x = x0; x < x1; x++) {
-            buffer.drawPixel(x, y, cols[x - x0]);
-            }
-          }
-          return;
-          
-        } else if (shader.shaderType == VGRADIENT) {
-          if (x0 > buffer.width || y0 > buffer.height || x1 > buffer.width || y1 > buffer.height) {return;};
-          for (uint16_t y = y0; y < y1; y++) {
-            Color c = ShaderMethods::gradient(shader.v0, shader.scale, shader.c0, shader.c1, y);
-            for (uint16_t x = x0; x < x1; x++) {
-              buffer.drawPixel(x, y, c);
-            }
-          }
-          return;
         }
-          
+        return;
       }
   };
 }

primatives/trapezoid.cpp

@@ -1,11 +1,13 @@
 #pragma once
 
 #include <stdint.h>
+#include <algorithm>
 
 #include "../datatypes.cpp"
 #include "../helpers.cpp"
 #include "../buffer.cpp"
-#include "../shader.cpp"
+#include "../mappers/mappers.h"
+#include "../textures/textures.h"
 
 namespace UwU {
   // trapezoid (horizontally constrained)
@@ -29,59 +31,22 @@ namespace UwU {
       
       // Draw a horizontally bounded trapezoid
       // y1 >= y0
-      void draw (Buffer buffer, Shader shader) {
+      template <class MapperT, class TextureT>
+      void draw (Buffer buffer, MapperBase<MapperT>& mapper, TextureBase<TextureT>& texture) {
         uint16_t height = 1 + y1 - y0;
         int16_t LeftBound[height];
         int16_t RightBound[height];
         
         Helpers::bresenham(0, xl0, y1 - y0, xl1, LeftBound);
         Helpers::bresenham(0, xr0, y1 - y0, xr1, RightBound);
+
+        uint16_t x0 = std::min(xl0, xl1);
         
-        if (shader.shaderType == COLOR) {
-          for (uint16_t i = 0; i < height; i++) {
-            for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
-              buffer.drawPixel(x, i + y0, shader.c0);
-            }
+        for (uint16_t i = 0; i < height; i++) {
+          for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
+            Coord2 uv = mapper.map(x0, y0, x, i + y0);
+            buffer.drawPixel(x, i + y0, texture.texel(uv.x, uv.y));
           }
-          return;
-
-        } else if (shader.shaderType == HGRADIENT) {
-          // find left-right boundaries
-          uint16_t leftmost, rightmost;
-          if (xl0 < xl1) {
-            leftmost = xl0;
-          } else {
-            leftmost = xl1;
-          }
-          if (xr0 > xr1) {
-            rightmost = xr0;
-          } else {
-            rightmost = xr1;
-          }
-
-          // precompute gradient LUT
-          Color cols[rightmost - leftmost];
-          for (uint16_t x = leftmost; x < rightmost; x++) {
-            cols[x - leftmost] = ShaderMethods::gradient(shader.u0, shader.scale, shader.c0, shader.c1, x);
-          }
-
-          for (uint16_t i = 0; i < height; i++) {
-            for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
-              buffer.drawPixel(x, i + y0, cols[x - leftmost]);
-            }
-          }
-          return;
-
-        } else if (shader.shaderType == VGRADIENT) {
-          Color c;
-          for (uint16_t i = 0; i < height; i++) {
-            c = ShaderMethods::gradient(shader.v0, shader.scale, shader.c0, shader.c1, i + y0);
-            for (uint16_t x = LeftBound[i]; x <= RightBound[i]; x++) {
-              buffer.drawPixel(x, i + y0, c);
-            }
-          }
-          return;
-
         }
         return;
       }

primatives/triangle.cpp

@@ -1,15 +1,17 @@
 #pragma once
 
 #include <stdint.h>
+#include <algorithm>
 
 #include "../datatypes.cpp"
 #include "../helpers.cpp"
 #include "../buffer.cpp"
+#include "../mappers/mappers.h"
+#include "../textures/textures.h"
 
 namespace UwU {
   class Triangle {
     private:
-      
 
     public:
       Triangle(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
@@ -29,93 +31,84 @@ namespace UwU {
       uint16_t y2;
       
       // Draw a triangle
-      void draw (Buffer buffer, Color color) {
-        Coord2 top = Coord2();
-        Coord2 mid = Coord2();
-        Coord2 btm = Coord2();
-        // cases: left-handed, right-handed
+      template <class MapperT, class TextureT>
+      void draw (Buffer buffer, MapperBase<MapperT>& mapper, TextureBase<TextureT>& texture) {
+        uint16_t topX, topY, midX, midY, btmX, btmY;
+        // Find top, middle and bottom points of triangle
         if (y0 <= y1 && y0 <= y2) {
-          top.x = x0;
-          top.y = y0;
+          topX = x0;
+          topY = y0;
           if (y1 < y2) {
-            mid.x = x1;
-            mid.y = y1;
-            btm.x = x2;
-            btm.y = y2;
+            midX = x1;
+            midY = y1;
+            btmX = x2;
+            btmY = y2;
           } else {
-            mid.x = x2;
-            mid.y = y2;
-            btm.x = x1;
-            btm.y = y1;
+            midX = x2;
+            midY = y2;
+            btmX = x1;
+            btmY = y1;
           }
         } else if (y1 <= y0 && y1 <= y2) {
-          top.x = x1;
-          top.y = y1;
+          topX = x1;
+          topY = y1;
           if (y0 < y2) {
-            mid.x = x0;
-            mid.y = y0;
-            btm.x = x2;
-            btm.y = y2;
+            midX = x0;
+            midY = y0;
+            btmX = x2;
+            btmY = y2;
           } else {
-            mid.x = x2;
-            mid.y = y2;
-            btm.x = x0;
-            btm.y = y0;
+            midX = x2;
+            midY = y2;
+            btmX = x0;
+            btmY = y0;
           }
         } else {
-          top.x = x2;
-          top.y = y2;
+          topX = x2;
+          topY = y2;
           if (y0 < y1) {
-            mid.y = y0;
-            mid.x = x0;
-            btm.x = x1;
-            btm.y = y1;
+            midY = y0;
+            midX = x0;
+            btmX = x1;
+            btmY = y1;
           } else {
-            mid.x = x1;
-            mid.y = y1;
-            btm.x = x0;
-            btm.y = y0;
+            midX = x1;
+            midY = y1;
+            btmX = x0;
+            btmY = y0;
           }
         }
-        // printf("top: (%u, %u)\n", top.x, top.y);
-        // printf("mid: (%u, %u)\n", mid.x, mid.y);
-        // printf("btm: (%u, %u)\n", btm.x, btm.y);
+
+
         
-        uint16_t height = 1 + btm.y - top.y;
+        uint16_t height = 1 + btmY - topY;
         int16_t longBound[height];
         int16_t splitBound[height];
-        // int16_t rightBound[height];
-        Helpers::bresenham(0, top.x, height - 1, btm.x, longBound);
-        // printf("longBound\n");
-        if ((int16_t)mid.x < longBound[mid.y - top.y]) {
-          // left-handed triangle
-          // printf("left-handed\n");
-          // rightBound = longBound;
-          Helpers::bresenham(0, top.x, mid.y - top.y, mid.x, splitBound);
-          // printf("splitTop\n");
-          Helpers::bresenham(mid.y - top.y, mid.x, height - 1, btm.x, splitBound);
-          // printf("splitBtm\n");
-          // for (uint16_t i = 0; i < height; i++) {
-          //   printf("(%u, %u)\n", i, splitBound[i]);
-          // }
+
+        // Calculate LUT for longest vertical line (from top to bottom)
+        Helpers::bresenham(0, topX, height - 1, btmX, longBound);
+        
+        // Calculate LUT for short two lines
+        Helpers::bresenham(0, topX, midY - topY, midX, splitBound);
+        Helpers::bresenham(midY - topY, midX, height - 1, btmX, splitBound);
+
+        Coord2 uv;
+        uint16_t leftX = std::min(topX, std::min(midX, btmX));
+
+        // Left-handed triangle case (midpoint is left of triangle)
+        if ((int16_t)midX < longBound[midY - topY]) {
           for (uint16_t i = 0; i < height; i++) {
             for (uint16_t x = (uint16_t)splitBound[i]; x <= (uint16_t)longBound[i]; x++) {
-              // Helpers::putPixel(buffer, x, i + (uint32_t)top.y, color.r, color.g, color.b, color.a);
-              buffer.drawPixel(x, i + (uint16_t)top.y, color);
+              uv = mapper.map(leftX, topY, x, i + (uint16_t)topY);
+              buffer.drawPixel(x, i + (uint16_t)topY, texture.texel(uv.x, uv.y));
             }
           }
+          // Right-handed triangle case (midpoint is right of triangle)
         } else {
-          // right-handed triangle
-          // printf("right-handed\n");
-          // leftBound = longBound;
-          Helpers::bresenham(0, top.x, mid.y - top.y, mid.x, splitBound);
-          // printf("splitTop\n");
-          Helpers::bresenham(mid.y - top.y, mid.x, height - 1, btm.x, splitBound);
-          // printf("splitBtm\n");
           for (uint16_t i = 0; i < height; i++) {
             for (uint16_t x = (uint16_t)longBound[i]; x <= (uint16_t)splitBound[i]; x++) {
-              // Helpers::putPixel(buffer, x, i + (uint32_t)top.y, color.r, color.g, color.b, color.a);
-              buffer.drawPixel(x, i + (uint16_t)top.y, color);
+              uv = mapper.map(leftX, topY, x, i + (uint16_t)topY);
+              buffer.drawPixel(x, i + (uint16_t)topY, texture.texel(uv.x, uv.y));
             }
           }
         }

shader.cpp

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-#include "datatypes.cpp"
-#include "helpers.cpp"
-#include "buffer.cpp"
-
-namespace UwU {
-  // shader prototype
-  class Shader {
-    public:
-      //COLOR Shader
-      Shader(Color color) {
-        this->shaderType = COLOR;
-        this->c0 = color;
-      }
-
-      //HGRADIENT or VGRADIENT shader
-      Shader(Direction direction, uint16_t uv0, uint16_t uv1, Color c0, Color c1) {
-        this->c0 = c0;
-        this->c1 = c1;
-        switch (direction) {
-          case H:
-            shaderType = HGRADIENT;
-            this->u0 = uv0;
-            this->scale = 0xffffffff / (1 + (uint32_t)uv1 - (uint32_t)uv0);
-            break;
-          case V:
-            shaderType = VGRADIENT;
-            this->v0 = uv0;
-            this->scale = 0xffffffff / (1 + (uint32_t)uv1 - (uint32_t)uv0);
-            break;
-        }
-      }
-
-      // BUFFER shader
-      // Shader(uint16_t u, uint16_t v, Buffer buffer) {
-      //   this->shaderType = BUFFER;
-      //   this->u0 = u;
-      //   this->v0 = v;
-      // }
-
-      ShaderType shaderType;
-      uint16_t u0;
-      uint16_t v0;
-      Color c0;
-      Color c1;
-      uint32_t scale;
-  };
-
-  class ShaderMethods {
-    public:
-      static Color gradient(uint16_t uv0, uint32_t scale, Color c0, Color c1, uint16_t uv) {
-        uint32_t t = (((uint32_t)uv - (uint32_t)uv0) * scale) / 0x01000000;
-        return Helpers::lerpColor(c0, c1, (uint8_t)t);
-      }
-  };
-}

shaders/shaderbase.cpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+
+namespace UwU {
+  template <class ShaderT>
+  class ShaderBase {
+    public:
+      Color shade(uint16_t x, uint16_t y) {
+        return static_cast<ShaderT*>(this)->shade(x, y);
+     }
+  };
+}

shaders/shaders.h

@@ -0,0 +1 @@
+#include "shaderbase.cpp"

textures/bitmaptexture.cpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+#include "texturebase.cpp"
+
+namespace UwU {
+  class BitmapTexture : public TextureBase<BitmapTexture> {
+    private:
+      Buffer buffer;
+
+    public:
+      BitmapTexture(Buffer buffer) {
+        this->buffer = buffer;
+      }
+
+      Color texel(uint16_t u, uint16_t v) {
+        uint32_t index = (v * buffer.stride) + (u * 4);
+        Color c = Color(buffer.pixels[index + 2], buffer.pixels[index + 1], buffer.pixels[index], buffer.pixels[index + 3]);
+        return c;
+     }
+  };
+}

textures/colortexture.cpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+#include "texturebase.cpp"
+
+namespace UwU {
+  class ColorTexture : public TextureBase<ColorTexture> {
+    private:
+      Color color;
+
+    public:
+      ColorTexture(Color color) {
+        this->color = color;
+      }
+
+      Color texel(uint16_t u, uint16_t v) {
+        (void)u;
+        (void)v;
+        return color;
+     }
+  };
+}

textures/gradienttexture.cpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+#include "texturebase.cpp"
+
+namespace UwU {
+  class GradientTexture : public TextureBase<GradientTexture> {
+    public:
+      GradientTexture(uint16_t width, Color c0, Color c1) {
+        this->uScale = 0xffffffff / (1 + (uint32_t)width);
+        this->c0 = c0;
+        this->c1 = c1;
+      }
+      uint32_t uScale;
+      Color c0;
+      Color c1;
+
+      Color texel(uint16_t u, uint16_t v) {
+        (void)v;
+        uint32_t t = (((uint32_t)u) * uScale) / 0x01000000;
+        return Helpers::lerpColor(c0, c1, (uint8_t)t);
+     }
+  };
+}

textures/hgradienttexture.cpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+#include "texturebase.cpp"
+
+namespace UwU {
+  class HGradientTexture : public TextureBase<HGradientTexture> {
+    public:
+      HGradientTexture(uint16_t width, Color c0, Color c1) {
+        this->uScale = 0xffffffff / (1 + (uint32_t)width);
+        this->c0 = c0;
+        this->c1 = c1;
+      }
+      uint32_t uScale;
+      Color c0;
+      Color c1;
+
+      Color texel(uint16_t u, uint16_t v) {
+        (void)v;
+        uint32_t t = (((uint32_t)u) * uScale) / 0x01000000;
+        return Helpers::lerpColor(c0, c1, (uint8_t)t);
+     }
+  };
+}

textures/texturebase.cpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+
+namespace UwU {
+  template <class TextureT>
+  class TextureBase {
+    public:
+      Color texel(uint16_t u, uint16_t v) {
+        return static_cast<TextureT*>(this)->texel(u, v);
+     }
+  };
+}

textures/textures.h

@@ -0,0 +1,7 @@
+#include "texturebase.cpp"
+#include "colortexture.cpp"
+#include "bitmaptexture.cpp"
+#include "tilemaptexture.cpp"
+#include "hgradienttexture.cpp"
+#include "vgradienttexture.cpp"
+// #include "gradienttexture.cpp"

textures/tilemaptexture.cpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+#include "texturebase.cpp"
+#include "../tilemap.cpp"
+
+namespace UwU {
+  class TilemapTexture : public TextureBase<TilemapTexture> {
+    private:
+      Buffer buffer;
+      Tilemap tilemap;
+
+    public:
+      TilemapTexture(Tilemap tilemap, Buffer buffer) {
+        this->buffer = buffer;
+        this->tilemap = tilemap;
+      }
+
+      Color texel(uint16_t u, uint16_t v) {
+        Coord2 bitmapUV = tilemap.map(u, v);
+        uint32_t index = (bitmapUV.y * buffer.stride) + (bitmapUV.x * 4);
+        Color c = Color(buffer.pixels[index + 2], buffer.pixels[index + 1], buffer.pixels[index], buffer.pixels[index + 3]);
+        return c;
+     }
+  };
+}

textures/vgradienttexture.cpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "../datatypes.cpp"
+#include "../helpers.cpp"
+#include "../buffer.cpp"
+#include "texturebase.cpp"
+
+namespace UwU {
+  class VGradientTexture : public TextureBase<VGradientTexture> {
+    public:
+      VGradientTexture(uint16_t height, Color c0, Color c1) {
+        this->vScale = 0xffffffff / (1 + (uint32_t)height);
+        this->c0 = c0;
+        this->c1 = c1;
+      }
+      uint32_t vScale;
+      Color c0;
+      Color c1;
+
+      Color texel(uint16_t u, uint16_t v) {
+        (void)u;
+        uint32_t t = (((uint32_t)v) * vScale) / 0x01000000;
+        return Helpers::lerpColor(c0, c1, (uint8_t)t);
+     }
+  };
+}

tilemap.cpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "datatypes.cpp"
+#include "helpers.cpp"
+
+namespace UwU {
+  class Tilemap {
+    public:
+      Tilemap() {
+        this->tilemap = new uint16_t[16384]; // the map of tile positions 128x128 8x8 tiles from a 512x512 bitmap space
+      }
+      uint16_t* tilemap;
+
+      Coord2 map(uint16_t u, uint16_t v) {
+        // returns uv coordinates that point to a specific pixel of a specific tile on a tilesheet buffer
+        uint16_t mapX = (u & 0x03f8) >> 3;
+        uint16_t mapY = (v & 0x03f8) << 4;
+        uint16_t tileIndex = tilemap[mapY + mapX];
+        uint16_t u1 = (tileIndex & 0x003f) << 3;
+        u1 += (u & 0x0007);
+        uint16_t v1 = (tileIndex & 0x0fc0) >> 3;
+        v1 += (v & 0x0007);
+        return Coord2(u1, v1);
+     }
+  };
+}

uwugl.h

@@ -0,0 +1,9 @@
+#include "datatypes.cpp"
+#include "helpers.cpp"
+#include "buffer.cpp"
+#include "surface.cpp"
+#include "primatives/primatives.h"
+#include "mappers/mappers.h"
+#include "textures/textures.h"
+#include "tilemap.cpp"
+// #include "shaders/shaders.h"