feat: add per-shape scaling and custom transformation matrices, with independent-axis ellipse and collider support

Author: JohnieWalkerCZ

desktop/main.cpp

@@ -4,11 +4,132 @@
 #include "Shapes/Polygon.hpp"
 #include "Shapes/Rectangle.hpp"
 #include "Shapes/RegularPolygon.hpp"
+#include "Texture.hpp"
 #include "Utils.hpp"
+#include <cassert>
 #include <cstdio>
 #include <memory>
 
+static bool isWhite(const Display &d, int x, int y) {
+    if (x < 0 || y < 0 || x >= d.width || y >= d.height)
+        return false;
+    const Color &c = d.pixels[y * d.width + x];
+    return c.r > 200 && c.g > 200 && c.b > 200;
+}
+
+static bool isRed(const Display &d, int x, int y) {
+    if (x < 0 || y < 0 || x >= d.width || y >= d.height)
+        return false;
+    const Color &c = d.pixels[y * d.width + x];
+    return c.r > 200 && c.g < 50 && c.b < 50;
+}
+
+static void testScaleAndMatrix() {
+    DrawOptions opts{200, 200, false};
+
+    {
+        Display disp;
+        disp.width = 200;
+        disp.height = 200;
+        disp.pixels.assign(200 * 200, Colors::BLACK);
+
+        Rectangle r(RectangleParams{10, 10, Colors::WHITE, 20, 20, false});
+        r.setScale(2.0f, 3.0f, 0, 0);
+        r.draw(disp, opts);
+
+        assert(isWhite(disp, 10 + (20 - 1) * 2, 10 + (20 - 1) * 3));
+        assert(!isWhite(disp, 10 + (20 - 1), 10 + (20 - 1)));
+    }
+
+    {
+        Display disp;
+        disp.width = 200;
+        disp.height = 200;
+        disp.pixels.assign(200 * 200, Colors::BLACK);
+
+        Rectangle r(RectangleParams{0, 0, Colors::WHITE, 5, 5, false});
+        Matrix2D m;
+        m.a = 1;
+        m.b = 0;
+        m.c = 0;
+        m.d = 1;
+        m.e = 100;
+        m.f = 120;
+        r.setTransformationMatrix(m);
+        r.draw(disp, opts);
+
+        assert(isWhite(disp, 100, 120));
+        assert(!isWhite(disp, 0, 0));
+    }
+
+    {
+        Circle c(CircleParams{0, 0, Colors::WHITE, 10});
+        c.setScale(3.0f, 1.0f); // rx=30, ry=10
+        c.addCollider();
+
+        PointCollider farOnX(25, 0);
+        PointCollider farOnY(0, 25);
+        assert(c.collider->intersects(&farOnX));
+        assert(!c.collider->intersects(&farOnY));
+    }
+
+    {
+        Rectangle r(RectangleParams{0, 0, Colors::WHITE, 10, 10, false});
+        r.addCollider();
+        r.setScale(4.0f, 4.0f);
+        PointCollider pt(35, 35);
+        assert(r.collider->intersects(&pt));
+    }
+
+    {
+        Display disp;
+        disp.width = 200;
+        disp.height = 200;
+        disp.pixels.assign(200 * 200, Colors::BLACK);
+
+        Circle c(CircleParams{100, 100, Colors::WHITE, 20});
+        c.setScale(2.0f, 0.5f); // rx=40, ry=10
+        c.draw(disp, opts);
+
+        assert(isWhite(disp, 140, 100));
+        assert(!isWhite(disp, 100, 60));
+    }
+
+    {
+        std::vector<Color, PsramAllocator<Color>> texPixels(16, Colors::BLACK);
+        texPixels[0] = Colors::RED; // marker at texel (0,0)
+        Texture tex(texPixels, 4, 4);
+        tex.setWrapMode("clamp");
+
+        Display disp;
+        disp.width = 200;
+        disp.height = 200;
+        disp.pixels.assign(200 * 200, Colors::MAGENTA);
+
+        Rectangle r(RectangleParams{0, 0, Colors::WHITE, 4, 4, true});
+        r.texture = &tex;
+        r.fixTexture = true;
+
+        Matrix2D m;
+        m.a = 1;
+        m.b = 0;
+        m.c = 0.3f; // skew
+        m.d = 1;
+        m.e = 50;
+        m.f = 60;
+        r.setTransformationMatrix(m);
+        r.draw(disp, opts);
+
+        assert(isRed(disp, 50, 60));
+        assert(!isRed(disp, 51, 60));
+    }
+
+    printf("scale/matrix/collider self-check passed\n");
+}
+
 int main() {
+    testScaleAndMatrix();
+
     const int W = 64, H = 64;
 
     Renderer renderer(W, H);

include/Collider.hpp

@@ -45,6 +45,8 @@ class Collider : public Collidable {
     float x;
     float y;
     float rotation;
+    float scaleX = 1.0f;
+    float scaleY = 1.0f;
 
     Collider(float x, float y) : x(x), y(y), rotation(0.0f) {}
     virtual ~Collider() = default;
@@ -62,7 +64,6 @@ class Collider : public Collidable {
     }
 
     virtual void rotate(float angleDegrees) { rotation += angleDegrees; }
-
 };
 
 namespace CollisionMath {
@@ -108,6 +109,15 @@ inline bool pointInPolygon(int x, int y,
     return inside;
 }
 
+inline bool pointInEllipse(float px, float py, float cx, float cy, float rx,
+                           float ry) {
+    if (rx <= 0.0f || ry <= 0.0f)
+        return false;
+    float dx = (px - cx) / rx;
+    float dy = (py - cy) / ry;
+    return dx * dx + dy * dy <= 1.0f;
+}
+
 inline bool lineIntersectLine(int x1, int y1, int x2, int y2, int x3, int y3,
                               int x4, int y4) {
     int denominator = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
@@ -121,7 +131,7 @@ inline bool lineIntersectLine(int x1, int y1, int x2, int y2, int x3, int y3,
 
     return ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1;
 }
-}
+} // namespace CollisionMath
 
 class IntersectionVisitor : public CollisionVisitor {
   private:
@@ -195,6 +205,9 @@ class CircleCollider : public Collider {
         IntersectionVisitor visitor(other);
         return this->accept(&visitor);
     }
+
+    float radiusX() const { return radius * scaleX; }
+    float radiusY() const { return radius * scaleY; }
 };
 
 class RectangleCollider : public Collider {
@@ -214,17 +227,20 @@ class RectangleCollider : public Collider {
         return this->accept(&visitor);
     }
 
+    float scaledWidth() const { return width * scaleX; }
+    float scaledHeight() const { return height * scaleY; }
+
     std::vector<std::pair<int, int>> getCorners() const {
         std::vector<std::pair<int, int>> corners;
         float rads = rotation * CollisionMath::DEG_TO_RAD;
+        float w = scaledWidth();
+        float h = scaledHeight();
 
         corners.push_back({(int)x, (int)y});
 
-        corners.push_back(CollisionMath::rotatePoint(x + width, y, x, y, rads));
-        corners.push_back(
-            CollisionMath::rotatePoint(x + width, y + height, x, y, rads));
-        corners.push_back(
-            CollisionMath::rotatePoint(x, y + height, x, y, rads));
+        corners.push_back(CollisionMath::rotatePoint(x + w, y, x, y, rads));
+        corners.push_back(CollisionMath::rotatePoint(x + w, y + h, x, y, rads));
+        corners.push_back(CollisionMath::rotatePoint(x, y + h, x, y, rads));
 
         return corners;
     }
@@ -254,8 +270,10 @@ class PolygonCollider : public Collider {
         float s = std::sin(rads);
 
         for (const auto &p : points) {
-            int rx = static_cast<int>(p.first * c + p.second * s);
-            int ry = static_cast<int>(-p.first * s + p.second * c);
+            float sx = p.first * scaleX;
+            float sy = p.second * scaleY;
+            int rx = static_cast<int>(sx * c + sy * s);
+            int ry = static_cast<int>(-sx * s + sy * c);
             worldPoints.push_back({rx + (int)x, ry + (int)y});
         }
         return worldPoints;
@@ -279,10 +297,13 @@ class LineSegmentCollider : public Collider {
         return this->accept(&visitor);
     }
     std::pair<int, int> getP2() const {
+        float scaledX2 = x + (x2 - x) * scaleX;
+        float scaledY2 = y + (y2 - y) * scaleY;
         if (rotation == 0.0f)
-            return {x2, y2};
+            return {static_cast<int>(scaledX2), static_cast<int>(scaledY2)};
         float rads = rotation * CollisionMath::DEG_TO_RAD;
-        return CollisionMath::rotatePoint(x2, y2, x, y, rads);
+        return CollisionMath::rotatePoint(
+            static_cast<int>(scaledX2), static_cast<int>(scaledY2), x, y, rads);
     }
 };
 

include/Shapes/Circle.hpp

@@ -27,8 +27,8 @@ class Circle : public Shape {
   private:
     void drawHorizontalLine(Display &displayGrid, int x1, int x2, int y,
                             const PaintCtx &ctx);
-    void drawAntiAliasedPoint(Display &displayGrid, int cx, int cy, int x,
-                              int y, float intensity, const PaintCtx &ctx);
-    void fillCircle(Display &displayGrid, int cx, int cy, int r,
+    void drawEllipsePoints(Display &displayGrid, int cx, int cy, int x, int y,
+                           float intensity, const PaintCtx &ctx);
+    void fillCircle(Display &displayGrid, int cx, int cy, float rx, float ry,
                     const PaintCtx &ctx);
 };

include/Shapes/Shape.hpp

@@ -4,6 +4,7 @@
 #include "../Texture.hpp"
 #include "Utils.hpp"
 #include <memory>
+#include <optional>
 #include <vector>
 
 struct DrawOptions {
@@ -71,6 +72,8 @@ class Shape {
     Matrix2D _cachedGlobalMatrix;
     bool _isDirty = true;
 
+    std::optional<Matrix2D> _customMatrix;
+
     std::pair<int, int> getTransformedPosition(int inputX, int inputY);
     PaintCtx makePaintCtx(const Color &color) const;
 
@@ -112,6 +115,15 @@ class Shape {
     void scaleY(float scaleY, float originY = -1);
     void setScaleOrigin(int x, int y);
 
+    void setTransformationMatrix(const Matrix2D &matrix) {
+        _customMatrix = matrix;
+        markDirty();
+    }
+    void clearTransformationMatrix() {
+        _customMatrix.reset();
+        markDirty();
+    }
+
     void addCollider(std::unique_ptr<Collider> newCollider = nullptr);
     void removeCollider();
     bool intersects(const std::shared_ptr<Shape> &other);

src/Collider.cpp

@@ -20,8 +20,8 @@ getRegularPolyVertices(const RegularPolygonCollider *rp) {
     for (int i = 0; i < sides; i++) {
         float angle = i * angleStep + startAngle;
 
-        float localX = rp->radius * std::cos(angle);
-        float localY = rp->radius * std::sin(angle);
+        float localX = rp->radius * std::cos(angle) * rp->scaleX;
+        float localY = rp->radius * std::sin(angle) * rp->scaleY;
 
         int finalX = static_cast<int>(localX * c + localY * s) + rp->x;
         int finalY = static_cast<int>(-localX * s + localY * c) + rp->y;
@@ -202,32 +202,33 @@ bool IntersectionVisitor::visitRegularPolygon(
 
 bool IntersectionVisitor::circleCircle(const CircleCollider *c1,
                                        const CircleCollider *c2) {
-    float distSq = CollisionMath::distanceSquared(c1->x, c1->y, c2->x, c2->y);
-    float radSum = c1->radius + c2->radius;
-    return distSq < radSum * radSum;
+    return CollisionMath::pointInEllipse(c2->x, c2->y, c1->x, c1->y,
+                                         c1->radiusX() + c2->radiusX(),
+                                         c1->radiusY() + c2->radiusY());
 }
 
 bool IntersectionVisitor::circleRectangle(const CircleCollider *circle,
                                           const RectangleCollider *rect) {
     if (rect->rotation == 0.0f) {
         // Fast AABB Check
+        float w = rect->scaledWidth();
+        float h = rect->scaledHeight();
         float testX = circle->x;
         float testY = circle->y;
 
         if (circle->x < rect->x)
             testX = rect->x;
-        else if (circle->x > rect->x + rect->width)
-            testX = rect->x + rect->width;
+        else if (circle->x > rect->x + w)
+            testX = rect->x + w;
 
         if (circle->y < rect->y)
             testY = rect->y;
-        else if (circle->y > rect->y + rect->height)
-            testY = rect->y + rect->height;
+        else if (circle->y > rect->y + h)
+            testY = rect->y + h;
 
-        float distX = circle->x - testX;
-        float distY = circle->y - testY;
-        return (distX * distX + distY * distY) <=
-               (circle->radius * circle->radius);
+        return CollisionMath::pointInEllipse(testX, testY, circle->x, circle->y,
+                                             circle->radiusX(),
+                                             circle->radiusY());
     } else {
         // Rotated Rectangle -> Treat as Polygon vs Circle
         auto corners = rect->getCorners();
@@ -247,9 +248,9 @@ bool IntersectionVisitor::circleRectangle(const CircleCollider *circle,
 
 bool IntersectionVisitor::circlePoint(const CircleCollider *circle,
                                       const PointCollider *point) {
-    return CollisionMath::distanceSquared(circle->x, circle->y, point->x,
-                                          point->y) <=
-           (circle->radius * circle->radius);
+    return CollisionMath::pointInEllipse(point->x, point->y, circle->x,
+                                         circle->y, circle->radiusX(),
+                                         circle->radiusY());
 }
 
 bool IntersectionVisitor::circleLine(const CircleCollider *circle,
@@ -269,9 +270,9 @@ bool IntersectionVisitor::circleLine(const CircleCollider *circle,
                                           lineLenSq));
     float closestX = line->x + t * (x2 - line->x);
     float closestY = line->y + t * (y2 - line->y);
-    return CollisionMath::distanceSquared(circle->x, circle->y, closestX,
-                                          closestY) <
-           (circle->radius * circle->radius);
+    return CollisionMath::pointInEllipse(closestX, closestY, circle->x,
+                                         circle->y, circle->radiusX(),
+                                         circle->radiusY());
 }
 
 bool IntersectionVisitor::circlePolygon(const CircleCollider *circle,
@@ -311,8 +312,10 @@ bool IntersectionVisitor::rectangleRectangle(const RectangleCollider *r1,
                                              const RectangleCollider *r2) {
     // Optimization: If BOTH are unrotated, use fast AABB
     if (r1->rotation == 0.0f && r2->rotation == 0.0f) {
-        return !(r1->x >= r2->x + r2->width || r1->x + r1->width <= r2->x ||
-                 r1->y >= r2->y + r2->height || r1->y + r1->height <= r2->y);
+        float w1 = r1->scaledWidth(), h1 = r1->scaledHeight();
+        float w2 = r2->scaledWidth(), h2 = r2->scaledHeight();
+        return !(r1->x >= r2->x + w2 || r1->x + w1 <= r2->x ||
+                 r1->y >= r2->y + h2 || r1->y + h1 <= r2->y);
     }
 
     auto p1 = r1->getCorners();
@@ -323,8 +326,10 @@ bool IntersectionVisitor::rectangleRectangle(const RectangleCollider *r1,
 bool IntersectionVisitor::rectanglePoint(const RectangleCollider *rect,
                                          const PointCollider *point) {
     if (rect->rotation == 0.0f) {
-        return point->x >= rect->x && point->x <= rect->x + rect->width &&
-               point->y >= rect->y && point->y <= rect->y + rect->height;
+        return point->x >= rect->x &&
+               point->x <= rect->x + rect->scaledWidth() &&
+               point->y >= rect->y &&
+               point->y <= rect->y + rect->scaledHeight();
     }
     auto corners = rect->getCorners();
     return CollisionMath::pointInPolygon(point->x, point->y, corners);