rect.c

#include "config.h"

#include "rect.h"

#include <limits.h>
#include <stdint.h>

static bool Int64ToInt(int64_t value, int *out) {
  if (value < INT_MIN || value > INT_MAX) {
    return false;
  }
  *out = (int)value;
  return true;
}

static bool RectEndChecked(int start, int size, int *end) {
  if (size < 0) {
    return false;
  }
  return Int64ToInt((int64_t)start + (int64_t)size, end);
}

static bool RectIsEmpty(Rect rect) { return rect.w <= 0 || rect.h <= 0; }

static int64_t RectRight(Rect rect) { return (int64_t)rect.x + rect.w; }

static int64_t RectBottom(Rect rect) { return (int64_t)rect.y + rect.h; }

bool RectIntersect(Rect a, Rect b, Rect *out) {
  int rect_right = 0;
  int rect_bottom = 0;
  int clip_right = 0;
  int clip_bottom = 0;
  if (RectIsEmpty(a) || RectIsEmpty(b) ||
      !RectEndChecked(a.x, a.w, &rect_right) ||
      !RectEndChecked(a.y, a.h, &rect_bottom) ||
      !RectEndChecked(b.x, b.w, &clip_right) ||
      !RectEndChecked(b.y, b.h, &clip_bottom)) {
    return false;
  }

  int left = a.x > b.x ? a.x : b.x;
  int top = a.y > b.y ? a.y : b.y;
  int right = rect_right < clip_right ? rect_right : clip_right;
  int bottom = rect_bottom < clip_bottom ? rect_bottom : clip_bottom;
  if (right <= left || bottom <= top) {
    return false;
  }
  int width = 0;
  int height = 0;
  if (!Int64ToInt((int64_t)right - (int64_t)left, &width) ||
      !Int64ToInt((int64_t)bottom - (int64_t)top, &height)) {
    return false;
  }

  *out = (Rect){
      .x = left,
      .y = top,
      .w = width,
      .h = height,
  };
  return true;
}

bool RectContainsPoint(Rect rect, int x, int y) {
  int right = 0;
  int bottom = 0;
  return !RectIsEmpty(rect) && RectEndChecked(rect.x, rect.w, &right) &&
         RectEndChecked(rect.y, rect.h, &bottom) && x >= rect.x && x < right &&
         y >= rect.y && y < bottom;
}

size_t RectSubtract(Rect old_rect, Rect new_rect, Rect out[4]) {
  if (RectIsEmpty(old_rect)) {
    return false;
  }

  Rect intersection;
  if (!RectIntersect(old_rect, new_rect, &intersection)) {
    out[0] = old_rect;
    return true;
  }

  size_t count = 0;
  int64_t old_right = RectRight(old_rect);
  int64_t old_bottom = RectBottom(old_rect);
  int64_t intersection_right = RectRight(intersection);
  int64_t intersection_bottom = RectBottom(intersection);

  if (intersection.y > old_rect.y) {
    out[count++] = (Rect){
        .x = old_rect.x,
        .y = old_rect.y,
        .w = old_rect.w,
        .h = intersection.y - old_rect.y,
    };
  }

  if (intersection_bottom < old_bottom) {
    out[count++] = (Rect){
        .x = old_rect.x,
        .y = (int)intersection_bottom,
        .w = old_rect.w,
        .h = (int)(old_bottom - intersection_bottom),
    };
  }

  if (intersection.x > old_rect.x) {
    out[count++] = (Rect){
        .x = old_rect.x,
        .y = intersection.y,
        .w = intersection.x - old_rect.x,
        .h = intersection.h,
    };
  }

  if (intersection_right < old_right) {
    out[count++] = (Rect){
        .x = (int)intersection_right,
        .y = intersection.y,
        .w = (int)(old_right - intersection_right),
        .h = intersection.h,
    };
  }

  return count;
}