mirror of
https://gitlab.freedesktop.org/wlroots/wlroots.git
synced 2024-10-29 23:20:57 +00:00
257 lines
7.7 KiB
C
257 lines
7.7 KiB
C
#include <assert.h>
|
|
#include <math.h>
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <wlr/util/region.h>
|
|
|
|
void wlr_region_scale(pixman_region32_t *dst, const pixman_region32_t *src,
|
|
float scale) {
|
|
wlr_region_scale_xy(dst, src, scale, scale);
|
|
}
|
|
|
|
void wlr_region_scale_xy(pixman_region32_t *dst, const pixman_region32_t *src,
|
|
float scale_x, float scale_y) {
|
|
if (scale_x == 1.0 && scale_y == 1.0) {
|
|
pixman_region32_copy(dst, src);
|
|
return;
|
|
}
|
|
|
|
int nrects;
|
|
const pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
|
|
|
|
pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
|
|
if (dst_rects == NULL) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < nrects; ++i) {
|
|
dst_rects[i].x1 = floor(src_rects[i].x1 * scale_x);
|
|
dst_rects[i].x2 = ceil(src_rects[i].x2 * scale_x);
|
|
dst_rects[i].y1 = floor(src_rects[i].y1 * scale_y);
|
|
dst_rects[i].y2 = ceil(src_rects[i].y2 * scale_y);
|
|
}
|
|
|
|
pixman_region32_fini(dst);
|
|
pixman_region32_init_rects(dst, dst_rects, nrects);
|
|
free(dst_rects);
|
|
}
|
|
|
|
void wlr_region_transform(pixman_region32_t *dst, const pixman_region32_t *src,
|
|
enum wl_output_transform transform, int width, int height) {
|
|
if (transform == WL_OUTPUT_TRANSFORM_NORMAL) {
|
|
pixman_region32_copy(dst, src);
|
|
return;
|
|
}
|
|
|
|
int nrects;
|
|
const pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
|
|
|
|
pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
|
|
if (dst_rects == NULL) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < nrects; ++i) {
|
|
switch (transform) {
|
|
case WL_OUTPUT_TRANSFORM_NORMAL:
|
|
dst_rects[i].x1 = src_rects[i].x1;
|
|
dst_rects[i].y1 = src_rects[i].y1;
|
|
dst_rects[i].x2 = src_rects[i].x2;
|
|
dst_rects[i].y2 = src_rects[i].y2;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_90:
|
|
dst_rects[i].x1 = height - src_rects[i].y2;
|
|
dst_rects[i].y1 = src_rects[i].x1;
|
|
dst_rects[i].x2 = height - src_rects[i].y1;
|
|
dst_rects[i].y2 = src_rects[i].x2;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_180:
|
|
dst_rects[i].x1 = width - src_rects[i].x2;
|
|
dst_rects[i].y1 = height - src_rects[i].y2;
|
|
dst_rects[i].x2 = width - src_rects[i].x1;
|
|
dst_rects[i].y2 = height - src_rects[i].y1;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_270:
|
|
dst_rects[i].x1 = src_rects[i].y1;
|
|
dst_rects[i].y1 = width - src_rects[i].x2;
|
|
dst_rects[i].x2 = src_rects[i].y2;
|
|
dst_rects[i].y2 = width - src_rects[i].x1;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED:
|
|
dst_rects[i].x1 = width - src_rects[i].x2;
|
|
dst_rects[i].y1 = src_rects[i].y1;
|
|
dst_rects[i].x2 = width - src_rects[i].x1;
|
|
dst_rects[i].y2 = src_rects[i].y2;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
|
|
dst_rects[i].x1 = src_rects[i].y1;
|
|
dst_rects[i].y1 = src_rects[i].x1;
|
|
dst_rects[i].x2 = src_rects[i].y2;
|
|
dst_rects[i].y2 = src_rects[i].x2;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
|
|
dst_rects[i].x1 = src_rects[i].x1;
|
|
dst_rects[i].y1 = height - src_rects[i].y2;
|
|
dst_rects[i].x2 = src_rects[i].x2;
|
|
dst_rects[i].y2 = height - src_rects[i].y1;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
|
|
dst_rects[i].x1 = height - src_rects[i].y2;
|
|
dst_rects[i].y1 = width - src_rects[i].x2;
|
|
dst_rects[i].x2 = height - src_rects[i].y1;
|
|
dst_rects[i].y2 = width - src_rects[i].x1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pixman_region32_fini(dst);
|
|
pixman_region32_init_rects(dst, dst_rects, nrects);
|
|
free(dst_rects);
|
|
}
|
|
|
|
void wlr_region_expand(pixman_region32_t *dst, const pixman_region32_t *src,
|
|
int distance) {
|
|
assert(distance >= 0);
|
|
|
|
if (distance == 0) {
|
|
pixman_region32_copy(dst, src);
|
|
return;
|
|
}
|
|
|
|
int nrects;
|
|
const pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
|
|
|
|
pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
|
|
if (dst_rects == NULL) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < nrects; ++i) {
|
|
dst_rects[i].x1 = src_rects[i].x1 - distance;
|
|
dst_rects[i].x2 = src_rects[i].x2 + distance;
|
|
dst_rects[i].y1 = src_rects[i].y1 - distance;
|
|
dst_rects[i].y2 = src_rects[i].y2 + distance;
|
|
}
|
|
|
|
pixman_region32_fini(dst);
|
|
pixman_region32_init_rects(dst, dst_rects, nrects);
|
|
free(dst_rects);
|
|
}
|
|
|
|
void wlr_region_rotated_bounds(pixman_region32_t *dst, const pixman_region32_t *src,
|
|
float rotation, int ox, int oy) {
|
|
if (rotation == 0) {
|
|
pixman_region32_copy(dst, src);
|
|
return;
|
|
}
|
|
|
|
int nrects;
|
|
const pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
|
|
|
|
pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
|
|
if (dst_rects == NULL) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < nrects; ++i) {
|
|
double x1 = src_rects[i].x1 - ox;
|
|
double y1 = src_rects[i].y1 - oy;
|
|
double x2 = src_rects[i].x2 - ox;
|
|
double y2 = src_rects[i].y2 - oy;
|
|
|
|
double rx1 = x1 * cos(rotation) - y1 * sin(rotation);
|
|
double ry1 = x1 * sin(rotation) + y1 * cos(rotation);
|
|
|
|
double rx2 = x2 * cos(rotation) - y1 * sin(rotation);
|
|
double ry2 = x2 * sin(rotation) + y1 * cos(rotation);
|
|
|
|
double rx3 = x2 * cos(rotation) - y2 * sin(rotation);
|
|
double ry3 = x2 * sin(rotation) + y2 * cos(rotation);
|
|
|
|
double rx4 = x1 * cos(rotation) - y2 * sin(rotation);
|
|
double ry4 = x1 * sin(rotation) + y2 * cos(rotation);
|
|
|
|
x1 = fmin(fmin(rx1, rx2), fmin(rx3, rx4));
|
|
y1 = fmin(fmin(ry1, ry2), fmin(ry3, ry4));
|
|
x2 = fmax(fmax(rx1, rx2), fmax(rx3, rx4));
|
|
y2 = fmax(fmax(ry1, ry2), fmax(ry3, ry4));
|
|
|
|
dst_rects[i].x1 = floor(ox + x1);
|
|
dst_rects[i].x2 = ceil(ox + x2);
|
|
dst_rects[i].y1 = floor(oy + y1);
|
|
dst_rects[i].y2 = ceil(oy + y2);
|
|
}
|
|
|
|
pixman_region32_fini(dst);
|
|
pixman_region32_init_rects(dst, dst_rects, nrects);
|
|
free(dst_rects);
|
|
}
|
|
|
|
static void region_confine(const pixman_region32_t *region, double x1, double y1, double x2,
|
|
double y2, double *x2_out, double *y2_out, pixman_box32_t box) {
|
|
double x_clamped = fmax(fmin(x2, box.x2 - 1), box.x1);
|
|
double y_clamped = fmax(fmin(y2, box.y2 - 1), box.y1);
|
|
|
|
// If the target coordinates are above box.{x,y}2 - 1, but less than
|
|
// box.{x,y}2, then they are still within the box.
|
|
if (floor(x_clamped) == floor(x2) && floor(y_clamped) == floor(y2)) {
|
|
*x2_out = x2;
|
|
*y2_out = y2;
|
|
return;
|
|
}
|
|
|
|
double dx = x2 - x1;
|
|
double dy = y2 - y1;
|
|
|
|
// We use fabs to avoid negative zeroes and thus avoid a bug
|
|
// with negative infinity.
|
|
double delta = fmin(fabs(x_clamped - x1) / fabs(dx), fabs(y_clamped - y1) / fabs(dy));
|
|
|
|
// We clamp it again due to precision errors.
|
|
double x = fmax(fmin(delta * dx + x1, box.x2 - 1), box.x1);
|
|
double y = fmax(fmin(delta * dy + y1, box.y2 - 1), box.y1);
|
|
|
|
// Go one unit past the boundary to find an adjacent box.
|
|
int x_ext = floor(x) + (dx == 0 ? 0 : dx > 0 ? 1 : -1);
|
|
int y_ext = floor(y) + (dy == 0 ? 0 : dy > 0 ? 1 : -1);
|
|
|
|
if (pixman_region32_contains_point(region, x_ext, y_ext, &box)) {
|
|
return region_confine(region, x, y, x2, y2, x2_out, y2_out, box);
|
|
} else if (dx == 0 || dy == 0) {
|
|
*x2_out = x;
|
|
*y2_out = y;
|
|
} else {
|
|
bool bordering_x = x == box.x1 || x == box.x2 - 1;
|
|
bool bordering_y = y == box.y1 || y == box.y2 - 1;
|
|
|
|
if (bordering_x == bordering_y) {
|
|
double x2_potential, y2_potential;
|
|
double tmp1, tmp2;
|
|
region_confine(region, x, y, x, y2, &tmp1, &y2_potential, box);
|
|
region_confine(region, x, y, x2, y, &x2_potential, &tmp2, box);
|
|
if (fabs(x2_potential - x) > fabs(y2_potential - y)) {
|
|
*x2_out = x2_potential;
|
|
*y2_out = y;
|
|
} else {
|
|
*x2_out = x;
|
|
*y2_out = y2_potential;
|
|
}
|
|
} else if (bordering_x) {
|
|
return region_confine(region, x, y, x, y2, x2_out, y2_out, box);
|
|
} else if (bordering_y) {
|
|
return region_confine(region, x, y, x2, y, x2_out, y2_out, box);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool wlr_region_confine(const pixman_region32_t *region, double x1, double y1, double x2,
|
|
double y2, double *x2_out, double *y2_out) {
|
|
pixman_box32_t box;
|
|
if (pixman_region32_contains_point(region, floor(x1), floor(y1), &box)) {
|
|
region_confine(region, x1, y1, x2, y2, x2_out, y2_out, box);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|