rectangle-shape.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
 
#include "flint/graphics/shape.h"
#include "flint/graphics/types/color.h"
#include "flint/math/types.h"
 
#include <algorithm>
#include <cmath>
 
namespace Flint {
 
  class RectangleShape : public Shape {
    public:
      RectangleShape() = default;
 
      RectangleShape(Vec2f size, Color fill = {255, 255, 255, 255});
 
      void setSize(Vec2f newSize);
 
      void setOrigin(Vec2f newOrigin) {
        m_origin = newOrigin;
      }
 
      void setScale(Vec2f newScale) {
        m_scale = newScale;
      }
 
      void setRotation(float newRotation) {
        m_rotation = newRotation;
      }
 
      [[nodiscard]] Vec2f getSize() const {
        return m_size;
      }
 
      [[nodiscard]] const Vec2f &getOrigin() const {
        return m_origin;
      }
 
      [[nodiscard]] const Vec2f &getScale() const {
        return m_scale;
      }
 
      [[nodiscard]] float getRotation() const {
        return m_rotation;
      }
 
      [[nodiscard]] FloatRect getGlobalBounds() const override {
        const Vec2f scaledSize{m_size.x * m_scale.x, m_size.y * m_scale.y};
        const Vec2f scaledOrigin{m_origin.x * m_scale.x, m_origin.y * m_scale.y};
        const Vec2f topLeft = m_position - scaledOrigin;
 
        if (m_rotation == 0.f) {
          return FloatRect(topLeft, scaledSize);
        }
 
        const float c = std::cos(m_rotation);
        const float s = std::sin(m_rotation);
 
        const auto rotate = [&](const Vec2f &point) {
          const Vec2f local = point - m_position;
 
          return Vec2f{m_position.x + local.x * c - local.y * s,
                       m_position.y + local.x * s + local.y * c};
        };
 
        const Vec2f p0 = rotate(topLeft);
        const Vec2f p1 = rotate({topLeft.x + scaledSize.x, topLeft.y});
        const Vec2f p2 = rotate({topLeft.x + scaledSize.x, topLeft.y + scaledSize.y});
        const Vec2f p3 = rotate({topLeft.x, topLeft.y + scaledSize.y});
 
        const float minX = std::min({p0.x, p1.x, p2.x, p3.x});
        const float minY = std::min({p0.y, p1.y, p2.y, p3.y});
        const float maxX = std::max({p0.x, p1.x, p2.x, p3.x});
        const float maxY = std::max({p0.y, p1.y, p2.y, p3.y});
 
        return FloatRect({minX, minY}, {maxX - minX, maxY - minY});
      }
 
      void emit(RenderQueue &queue) const override;
 
    private:
      Vec2f m_size{0.f, 0.f};
      Vec2f m_origin{0.f, 0.f};
      Vec2f m_scale{1.f, 1.f};
      float m_rotation = 0.f;
  };
 
}