[call for testing v2] clients: add cliptest program
Birin Sanchez
birintxo at gmail.com
Tue Sep 11 02:14:09 PDT 2012
Hi Pekka,
I gave a try to v2 of cliptest and found something that might be
interesting. See attached screenshot.
This is how to get those extra 4 vertex:
* Move the clipping area to cover the surface with exactly the same
size, you'll see 4 vertex as expected
* Press 'n' or 'm' to get the surface to spin at least 4 times
* From the 4th spin onwards you'll see the extra 4 vertex. If you
make the surface to spin in the other direction the extra vertex will
disappear.
I guess this is due to float rounding errors.
Apart from this issue I couldn't find any other problems.
Cheers,
Birin
On 07/09/12 16:08, Pekka Paalanen wrote:
> Cliptest is for controlled testing of the calculate_edges() function in
> compositor.c. The function is copied verbatim into cliptest.c.
>
> v2:
> - show vertex coordinates
> - rewrite intersection computing; improved precision
> - remove duplicate vertices
> - fix non-transformed adjacent but not overlapping cases
>
> v1: original call for testing
>
> Signed-off-by: Pekka Paalanen <ppaalanen at gmail.com>
> ---
>
> Hi all,
>
> a new version for testing. This can also be found in the git branch
> http://cgit.collabora.com/git/user/pq/wayland-demos.git/log/?h=cliptest2
> where you can easily see the changes to v1.
>
> Thanks,
> pq
>
>
> clients/Makefile.am | 5 +
> clients/cliptest.c | 889 +++++++++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 894 insertions(+), 0 deletions(-)
> create mode 100644 clients/cliptest.c
>
> diff --git a/clients/Makefile.am b/clients/Makefile.am
> index 1b7fa10..a777772 100644
> --- a/clients/Makefile.am
> +++ b/clients/Makefile.am
> @@ -48,6 +48,7 @@ terminal = weston-terminal
> clients_programs = \
> flower \
> image \
> + cliptest \
> dnd \
> smoke \
> resizor \
> @@ -88,6 +89,10 @@ weston_terminal_LDADD = $(toolkit_libs) -lutil
> image_SOURCES = image.c
> image_LDADD = $(toolkit_libs)
>
> +cliptest_SOURCES = cliptest.c
> +cliptest_CPPFLAGS = $(AM_CPPFLAGS) $(PIXMAN_CFLAGS)
> +cliptest_LDADD = $(toolkit_libs) $(PIXMAN_LIBS)
> +
> dnd_SOURCES = dnd.c
> dnd_LDADD = $(toolkit_libs)
>
> diff --git a/clients/cliptest.c b/clients/cliptest.c
> new file mode 100644
> index 0000000..41cedae
> --- /dev/null
> +++ b/clients/cliptest.c
> @@ -0,0 +1,889 @@
> +/*
> + * Copyright © 2012 Collabora, Ltd.
> + * Copyright © 2012 Rob Clark
> + *
> + * Permission to use, copy, modify, distribute, and sell this software and its
> + * documentation for any purpose is hereby granted without fee, provided that
> + * the above copyright notice appear in all copies and that both that copyright
> + * notice and this permission notice appear in supporting documentation, and
> + * that the name of the copyright holders not be used in advertising or
> + * publicity pertaining to distribution of the software without specific,
> + * written prior permission. The copyright holders make no representations
> + * about the suitability of this software for any purpose. It is provided "as
> + * is" without express or implied warranty.
> + *
> + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
> + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
> + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
> + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
> + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
> + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
> + * OF THIS SOFTWARE.
> + */
> +
> +/* cliptest: for debugging calculate_edges() function, which is copied
> + * from compositor.c.
> + * controls:
> + * clip box position: mouse left drag, keys: w a s d
> + * clip box size: mouse right drag, keys: i j k l
> + * surface orientation: mouse wheel, keys: n m
> + * surface transform disable key: r
> + */
> +
> +#include <stdint.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <fcntl.h>
> +#include <libgen.h>
> +#include <unistd.h>
> +#include <math.h>
> +#include <time.h>
> +#include <pixman.h>
> +#include <cairo.h>
> +#include <float.h>
> +#include <assert.h>
> +
> +#include <linux/input.h>
> +#include <wayland-client.h>
> +
> +#include "window.h"
> +
> +typedef float GLfloat;
> +
> +struct geometry {
> + pixman_box32_t clip;
> +
> + pixman_box32_t surf;
> + float s; /* sin phi */
> + float c; /* cos phi */
> + float phi;
> +};
> +
> +struct weston_surface {
> + struct {
> + int enabled;
> + } transform;
> +
> + struct geometry *geometry;
> +};
> +
> +static void
> +weston_surface_to_global_float(struct weston_surface *surface,
> + GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
> +{
> + struct geometry *g = surface->geometry;
> +
> + /* pure rotation around origin by sine and cosine */
> + *x = g->c * sx + g->s * sy;
> + *y = -g->s * sx + g->c * sy;
> +}
> +
> +/* ---------------------- copied begins -----------------------*/
> +
> +struct polygon8 {
> + GLfloat x[8];
> + GLfloat y[8];
> + int n;
> +};
> +
> +struct clip_context {
> + struct {
> + GLfloat x;
> + GLfloat y;
> + } prev;
> +
> + struct {
> + GLfloat x1, y1;
> + GLfloat x2, y2;
> + } clip;
> +
> + struct {
> + GLfloat *x;
> + GLfloat *y;
> + } vertices;
> +};
> +
> +static GLfloat
> +float_difference(GLfloat a, GLfloat b)
> +{
> + /* http://www.altdevblogaday.com/2012/02/22/comparing-floating-point-numbers-2012-edition/ */
> + static const GLfloat max_diff = 4.0f * FLT_MIN;
> + static const GLfloat max_rel_diff = 4.0e-5;
> + GLfloat diff = a - b;
> + GLfloat adiff = fabsf(diff);
> +
> + if (adiff <= max_diff)
> + return 0.0f;
> +
> + a = fabsf(a);
> + b = fabsf(b);
> + if (adiff <= (a > b ? a : b) * max_rel_diff)
> + return 0.0f;
> +
> + return diff;
> +}
> +
> +/* A line segment (p1x, p1y)-(p2x, p2y) intersects the line x = x_arg.
> + * Compute the y coordinate of the intersection.
> + */
> +static GLfloat
> +clip_intersect_y(GLfloat p1x, GLfloat p1y, GLfloat p2x, GLfloat p2y,
> + GLfloat x_arg)
> +{
> + GLfloat a;
> + GLfloat diff = float_difference(p1x, p2x);
> +
> + if (diff == 0.0f)
> + return p2y;
> +
> + a = (x_arg - p2x) / diff;
> + return p2y + (p1y - p2y) * a;
> +}
> +
> +/* A line segment (p1x, p1y)-(p2x, p2y) intersects the line y = y_arg.
> + * Compute the x coordinate of the intersection.
> + */
> +static GLfloat
> +clip_intersect_x(GLfloat p1x, GLfloat p1y, GLfloat p2x, GLfloat p2y,
> + GLfloat y_arg)
> +{
> + GLfloat a;
> + GLfloat diff = float_difference(p1y, p2y);
> +
> + if (diff == 0.0f)
> + return p2x;
> +
> + a = (y_arg - p2y) / diff;
> + return p2x + (p1x - p2x) * a;
> +}
> +
> +enum path_transition {
> + PATH_TRANSITION_OUT_TO_OUT = 0,
> + PATH_TRANSITION_OUT_TO_IN = 1,
> + PATH_TRANSITION_IN_TO_OUT = 2,
> + PATH_TRANSITION_IN_TO_IN = 3,
> +};
> +
> +static void
> +clip_append_vertex(struct clip_context *ctx, GLfloat x, GLfloat y)
> +{
> + *ctx->vertices.x++ = x;
> + *ctx->vertices.y++ = y;
> +}
> +
> +static enum path_transition
> +path_transition_left_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
> +{
> + return ((ctx->prev.x >= ctx->clip.x1) << 1) | (x >= ctx->clip.x1);
> +}
> +
> +static enum path_transition
> +path_transition_right_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
> +{
> + return ((ctx->prev.x < ctx->clip.x2) << 1) | (x < ctx->clip.x2);
> +}
> +
> +static enum path_transition
> +path_transition_top_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
> +{
> + return ((ctx->prev.y >= ctx->clip.y1) << 1) | (y >= ctx->clip.y1);
> +}
> +
> +static enum path_transition
> +path_transition_bottom_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
> +{
> + return ((ctx->prev.y < ctx->clip.y2) << 1) | (y < ctx->clip.y2);
> +}
> +
> +static void
> +clip_polygon_leftright(struct clip_context *ctx,
> + enum path_transition transition,
> + GLfloat x, GLfloat y, GLfloat clip_x)
> +{
> + GLfloat yi;
> +
> + switch (transition) {
> + case PATH_TRANSITION_IN_TO_IN:
> + clip_append_vertex(ctx, x, y);
> + break;
> + case PATH_TRANSITION_IN_TO_OUT:
> + yi = clip_intersect_y(ctx->prev.x, ctx->prev.y, x, y, clip_x);
> + clip_append_vertex(ctx, clip_x, yi);
> + break;
> + case PATH_TRANSITION_OUT_TO_IN:
> + yi = clip_intersect_y(ctx->prev.x, ctx->prev.y, x, y, clip_x);
> + clip_append_vertex(ctx, clip_x, yi);
> + clip_append_vertex(ctx, x, y);
> + break;
> + case PATH_TRANSITION_OUT_TO_OUT:
> + /* nothing */
> + break;
> + default:
> + assert(0 && "bad enum path_transition");
> + }
> +
> + ctx->prev.x = x;
> + ctx->prev.y = y;
> +}
> +
> +static void
> +clip_polygon_topbottom(struct clip_context *ctx,
> + enum path_transition transition,
> + GLfloat x, GLfloat y, GLfloat clip_y)
> +{
> + GLfloat xi;
> +
> + switch (transition) {
> + case PATH_TRANSITION_IN_TO_IN:
> + clip_append_vertex(ctx, x, y);
> + break;
> + case PATH_TRANSITION_IN_TO_OUT:
> + xi = clip_intersect_x(ctx->prev.x, ctx->prev.y, x, y, clip_y);
> + clip_append_vertex(ctx, xi, clip_y);
> + break;
> + case PATH_TRANSITION_OUT_TO_IN:
> + xi = clip_intersect_x(ctx->prev.x, ctx->prev.y, x, y, clip_y);
> + clip_append_vertex(ctx, xi, clip_y);
> + clip_append_vertex(ctx, x, y);
> + break;
> + case PATH_TRANSITION_OUT_TO_OUT:
> + /* nothing */
> + break;
> + default:
> + assert(0 && "bad enum path_transition");
> + }
> +
> + ctx->prev.x = x;
> + ctx->prev.y = y;
> +}
> +
> +static void
> +clip_context_prepare(struct clip_context *ctx, const struct polygon8 *src,
> + GLfloat *dst_x, GLfloat *dst_y)
> +{
> + ctx->prev.x = src->x[src->n - 1];
> + ctx->prev.y = src->y[src->n - 1];
> + ctx->vertices.x = dst_x;
> + ctx->vertices.y = dst_y;
> +}
> +
> +static int
> +clip_polygon_left(struct clip_context *ctx, const struct polygon8 *src,
> + GLfloat *dst_x, GLfloat *dst_y)
> +{
> + enum path_transition trans;
> + int i;
> +
> + clip_context_prepare(ctx, src, dst_x, dst_y);
> + for (i = 0; i < src->n; i++) {
> + trans = path_transition_left_edge(ctx, src->x[i], src->y[i]);
> + clip_polygon_leftright(ctx, trans, src->x[i], src->y[i],
> + ctx->clip.x1);
> + }
> + return ctx->vertices.x - dst_x;
> +}
> +
> +static int
> +clip_polygon_right(struct clip_context *ctx, const struct polygon8 *src,
> + GLfloat *dst_x, GLfloat *dst_y)
> +{
> + enum path_transition trans;
> + int i;
> +
> + clip_context_prepare(ctx, src, dst_x, dst_y);
> + for (i = 0; i < src->n; i++) {
> + trans = path_transition_right_edge(ctx, src->x[i], src->y[i]);
> + clip_polygon_leftright(ctx, trans, src->x[i], src->y[i],
> + ctx->clip.x2);
> + }
> + return ctx->vertices.x - dst_x;
> +}
> +
> +static int
> +clip_polygon_top(struct clip_context *ctx, const struct polygon8 *src,
> + GLfloat *dst_x, GLfloat *dst_y)
> +{
> + enum path_transition trans;
> + int i;
> +
> + clip_context_prepare(ctx, src, dst_x, dst_y);
> + for (i = 0; i < src->n; i++) {
> + trans = path_transition_top_edge(ctx, src->x[i], src->y[i]);
> + clip_polygon_topbottom(ctx, trans, src->x[i], src->y[i],
> + ctx->clip.y1);
> + }
> + return ctx->vertices.x - dst_x;
> +}
> +
> +static int
> +clip_polygon_bottom(struct clip_context *ctx, const struct polygon8 *src,
> + GLfloat *dst_x, GLfloat *dst_y)
> +{
> + enum path_transition trans;
> + int i;
> +
> + clip_context_prepare(ctx, src, dst_x, dst_y);
> + for (i = 0; i < src->n; i++) {
> + trans = path_transition_bottom_edge(ctx, src->x[i], src->y[i]);
> + clip_polygon_topbottom(ctx, trans, src->x[i], src->y[i],
> + ctx->clip.y2);
> + }
> + return ctx->vertices.x - dst_x;
> +}
> +
> +#define max(a, b) (((a) > (b)) ? (a) : (b))
> +#define min(a, b) (((a) > (b)) ? (b) : (a))
> +#define clip(x, a, b) min(max(x, a), b)
> +
> +static int
> +calculate_edges(struct weston_surface *es, pixman_box32_t *rect,
> + pixman_box32_t *surf_rect, GLfloat *ex, GLfloat *ey)
> +{
> + struct polygon8 polygon;
> + struct clip_context ctx;
> + int i, n = 0;
> + GLfloat min_x, max_x, min_y, max_y;
> + struct polygon8 surf = {
> + { surf_rect->x1, surf_rect->x2, surf_rect->x2, surf_rect->x1 },
> + { surf_rect->y1, surf_rect->y1, surf_rect->y2, surf_rect->y2 },
> + 4
> + };
> +
> + ctx.clip.x1 = rect->x1;
> + ctx.clip.y1 = rect->y1;
> + ctx.clip.x2 = rect->x2;
> + ctx.clip.y2 = rect->y2;
> +
> + /* transform surface to screen space: */
> + for (i = 0; i < surf.n; i++)
> + weston_surface_to_global_float(es, surf.x[i], surf.y[i],
> + &surf.x[i], &surf.y[i]);
> +
> + /* find bounding box: */
> + min_x = max_x = surf.x[0];
> + min_y = max_y = surf.y[0];
> +
> + for (i = 1; i < surf.n; i++) {
> + min_x = min(min_x, surf.x[i]);
> + max_x = max(max_x, surf.x[i]);
> + min_y = min(min_y, surf.y[i]);
> + max_y = max(max_y, surf.y[i]);
> + }
> +
> + /* First, simple bounding box check to discard early transformed
> + * surface rects that do not intersect with the clip region:
> + */
> + if ((min_x >= ctx.clip.x2) || (max_x <= ctx.clip.x1) ||
> + (min_y >= ctx.clip.y2) || (max_y <= ctx.clip.y1))
> + return 0;
> +
> + /* Simple case, bounding box edges are parallel to surface edges,
> + * there will be only four edges. We just need to clip the surface
> + * vertices to the clip rect bounds:
> + */
> + if (!es->transform.enabled) {
> + for (i = 0; i < surf.n; i++) {
> + ex[n] = clip(surf.x[i], ctx.clip.x1, ctx.clip.x2);
> + ey[n] = clip(surf.y[i], ctx.clip.y1, ctx.clip.y2);
> + n++;
> + }
> + return surf.n;
> + }
> +
> + /* Transformed case: use a general polygon clipping algorithm to
> + * clip the surface rectangle with each side of 'rect'.
> + * The algorithm is Sutherland-Hodgman, as explained in
> + * http://www.codeguru.com/cpp/misc/misc/graphics/article.php/c8965/Polygon-Clipping.htm
> + * but without looking at any of that code.
> + */
> + polygon.n = clip_polygon_left(&ctx, &surf, polygon.x, polygon.y);
> + surf.n = clip_polygon_right(&ctx, &polygon, surf.x, surf.y);
> + polygon.n = clip_polygon_top(&ctx, &surf, polygon.x, polygon.y);
> + surf.n = clip_polygon_bottom(&ctx, &polygon, surf.x, surf.y);
> +
> + /* Get rid of duplicate vertices */
> + ex[0] = surf.x[0];
> + ey[0] = surf.y[0];
> + n = 1;
> + for (i = 1; i < surf.n; i++) {
> + if (float_difference(ex[n - 1], surf.x[i]) == 0.0f &&
> + float_difference(ey[n - 1], surf.y[i]) == 0.0f)
> + continue;
> + ex[n] = surf.x[i];
> + ey[n] = surf.y[i];
> + n++;
> + }
> + if (float_difference(ex[n - 1], surf.x[0]) == 0.0f &&
> + float_difference(ey[n - 1], surf.y[0]) == 0.0f)
> + n--;
> +
> + if (n < 3)
> + return 0;
> +
> + return n;
> +}
> +
> +
> +/* ---------------------- copied ends -----------------------*/
> +
> +static void
> +geometry_set_phi(struct geometry *g, float phi)
> +{
> + g->phi = phi;
> + g->s = sin(phi);
> + g->c = cos(phi);
> +}
> +
> +static void
> +geometry_init(struct geometry *g)
> +{
> + g->clip.x1 = -50;
> + g->clip.y1 = -50;
> + g->clip.x2 = -10;
> + g->clip.y2 = -10;
> +
> + g->surf.x1 = -20;
> + g->surf.y1 = -20;
> + g->surf.x2 = 20;
> + g->surf.y2 = 20;
> +
> + geometry_set_phi(g, 0.0);
> +}
> +
> +struct ui_state {
> + uint32_t button;
> + int down;
> +
> + int down_pos[2];
> + struct geometry geometry;
> +};
> +
> +struct cliptest {
> + struct window *window;
> + struct widget *widget;
> + struct display *display;
> + int fullscreen;
> +
> + struct ui_state ui;
> +
> + struct geometry geometry;
> + struct weston_surface surface;
> +};
> +
> +static void
> +draw_polygon_closed(cairo_t *cr, GLfloat *x, GLfloat *y, int n)
> +{
> + int i;
> +
> + cairo_move_to(cr, x[0], y[0]);
> + for (i = 1; i < n; i++)
> + cairo_line_to(cr, x[i], y[i]);
> + cairo_line_to(cr, x[0], y[0]);
> +}
> +
> +static void
> +draw_polygon_labels(cairo_t *cr, GLfloat *x, GLfloat *y, int n)
> +{
> + char str[16];
> + int i;
> +
> + for (i = 0; i < n; i++) {
> + snprintf(str, 16, "%d", i);
> + cairo_move_to(cr, x[i], y[i]);
> + cairo_show_text(cr, str);
> + }
> +}
> +
> +static void
> +draw_coordinates(cairo_t *cr, double ox, double oy, GLfloat *x, GLfloat *y, int n)
> +{
> + char str[64];
> + int i;
> + cairo_font_extents_t ext;
> +
> + cairo_font_extents(cr, &ext);
> + for (i = 0; i < n; i++) {
> + snprintf(str, 64, "%d: %14.9f, %14.9f", i, x[i], y[i]);
> + cairo_move_to(cr, ox, oy + ext.height * (i + 1));
> + cairo_show_text(cr, str);
> + }
> +}
> +
> +static void
> +draw_box(cairo_t *cr, pixman_box32_t *box, struct weston_surface *surface)
> +{
> + GLfloat x[4], y[4];
> +
> + if (surface) {
> + weston_surface_to_global_float(surface, box->x1, box->y1, &x[0], &y[0]);
> + weston_surface_to_global_float(surface, box->x2, box->y1, &x[1], &y[1]);
> + weston_surface_to_global_float(surface, box->x2, box->y2, &x[2], &y[2]);
> + weston_surface_to_global_float(surface, box->x1, box->y2, &x[3], &y[3]);
> + } else {
> + x[0] = box->x1; y[0] = box->y1;
> + x[1] = box->x2; y[1] = box->y1;
> + x[2] = box->x2; y[2] = box->y2;
> + x[3] = box->x1; y[3] = box->y2;
> + }
> +
> + draw_polygon_closed(cr, x, y, 4);
> +}
> +
> +static void
> +draw_geometry(cairo_t *cr, struct weston_surface *surface,
> + GLfloat *ex, GLfloat *ey, int n)
> +{
> + struct geometry *g = surface->geometry;
> + GLfloat cx, cy;
> +
> + draw_box(cr, &g->surf, surface);
> + cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 0.4);
> + cairo_fill(cr);
> + weston_surface_to_global_float(surface, g->surf.x1 - 4, g->surf.y1 - 4, &cx, &cy);
> + cairo_arc(cr, cx, cy, 1.5, 0.0, 2.0 * M_PI);
> + if (surface->transform.enabled == 0)
> + cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 0.8);
> + cairo_fill(cr);
> +
> + draw_box(cr, &g->clip, NULL);
> + cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 0.4);
> + cairo_fill(cr);
> +
> + draw_polygon_closed(cr, ex, ey, n);
> + cairo_set_source_rgb(cr, 0.0, 1.0, 0.0);
> + cairo_stroke(cr);
> +
> + cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 0.5);
> + draw_polygon_labels(cr, ex, ey, n);
> +}
> +
> +static void
> +redraw_handler(struct widget *widget, void *data)
> +{
> + struct cliptest *cliptest = data;
> + struct geometry *g = cliptest->surface.geometry;
> + struct rectangle allocation;
> + cairo_t *cr;
> + cairo_surface_t *surface;
> + GLfloat ex[8];
> + GLfloat ey[8];
> + int n;
> +
> + n = calculate_edges(&cliptest->surface, &g->clip, &g->surf, ex, ey);
> +
> + widget_get_allocation(cliptest->widget, &allocation);
> +
> + surface = window_get_surface(cliptest->window);
> + cr = cairo_create(surface);
> + widget_get_allocation(cliptest->widget, &allocation);
> + cairo_rectangle(cr, allocation.x, allocation.y,
> + allocation.width, allocation.height);
> + cairo_clip(cr);
> +
> + cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
> + cairo_set_source_rgba(cr, 0, 0, 0, 1);
> + cairo_paint(cr);
> +
> + cairo_translate(cr, allocation.x, allocation.y);
> + cairo_set_line_width(cr, 1.0);
> + cairo_move_to(cr, allocation.width / 2.0, 0.0);
> + cairo_line_to(cr, allocation.width / 2.0, allocation.height);
> + cairo_move_to(cr, 0.0, allocation.height / 2.0);
> + cairo_line_to(cr, allocation.width, allocation.height / 2.0);
> + cairo_set_source_rgba(cr, 0.5, 0.5, 0.5, 1.0);
> + cairo_stroke(cr);
> +
> + cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
> + cairo_push_group(cr);
> + cairo_translate(cr, allocation.width / 2.0,
> + allocation.height / 2.0);
> + cairo_scale(cr, 4.0, 4.0);
> + cairo_set_line_width(cr, 0.5);
> + cairo_set_line_join(cr, CAIRO_LINE_JOIN_BEVEL);
> + cairo_select_font_face(cr, "Sans", CAIRO_FONT_SLANT_NORMAL,
> + CAIRO_FONT_WEIGHT_BOLD);
> + cairo_set_font_size(cr, 5.0);
> + draw_geometry(cr, &cliptest->surface, ex, ey, n);
> + cairo_pop_group_to_source(cr);
> + cairo_paint(cr);
> +
> + cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 1.0);
> + cairo_select_font_face(cr, "monospace", CAIRO_FONT_SLANT_NORMAL,
> + CAIRO_FONT_WEIGHT_NORMAL);
> + cairo_set_font_size(cr, 12.0);
> + draw_coordinates(cr, 10.0, 10.0, ex, ey, n);
> +
> + cairo_destroy(cr);
> +
> + cairo_surface_destroy(surface);
> +}
> +
> +static int
> +motion_handler(struct widget *widget, struct input *input,
> + uint32_t time, float x, float y, void *data)
> +{
> + struct cliptest *cliptest = data;
> + struct ui_state *ui = &cliptest->ui;
> + struct geometry *ref = &ui->geometry;
> + struct geometry *geom = &cliptest->geometry;
> + float dx, dy;
> +
> + if (!ui->down)
> + return CURSOR_LEFT_PTR;
> +
> + dx = (x - ui->down_pos[0]) * 0.25;
> + dy = (y - ui->down_pos[1]) * 0.25;
> +
> + switch (ui->button) {
> + case BTN_LEFT:
> + geom->clip.x1 = ref->clip.x1 + dx;
> + geom->clip.y1 = ref->clip.y1 + dy;
> + /* fall through */
> + case BTN_RIGHT:
> + geom->clip.x2 = ref->clip.x2 + dx;
> + geom->clip.y2 = ref->clip.y2 + dy;
> + break;
> + default:
> + return CURSOR_LEFT_PTR;
> + }
> +
> + widget_schedule_redraw(cliptest->widget);
> + return CURSOR_BLANK;
> +}
> +
> +static void
> +button_handler(struct widget *widget, struct input *input,
> + uint32_t time, uint32_t button,
> + enum wl_pointer_button_state state, void *data)
> +{
> + struct cliptest *cliptest = data;
> + struct ui_state *ui = &cliptest->ui;
> +
> + ui->button = button;
> +
> + if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
> + ui->down = 1;
> + input_get_position(input, &ui->down_pos[0], &ui->down_pos[1]);
> + } else {
> + ui->down = 0;
> + ui->geometry = cliptest->geometry;
> + }
> +}
> +
> +static void
> +axis_handler(struct widget *widget, struct input *input, uint32_t time,
> + uint32_t axis, wl_fixed_t value, void *data)
> +{
> + struct cliptest *cliptest = data;
> + struct geometry *geom = &cliptest->geometry;
> +
> + if (axis != WL_POINTER_AXIS_VERTICAL_SCROLL)
> + return;
> +
> + geometry_set_phi(geom, geom->phi +
> + (M_PI / 12.0) * wl_fixed_to_double(value));
> + cliptest->surface.transform.enabled = 1;
> +
> + widget_schedule_redraw(cliptest->widget);
> +}
> +
> +static void
> +key_handler(struct window *window, struct input *input, uint32_t time,
> + uint32_t key, uint32_t sym,
> + enum wl_keyboard_key_state state, void *data)
> +{
> + struct cliptest *cliptest = data;
> + struct geometry *g = &cliptest->geometry;
> +
> + if (state == WL_KEYBOARD_KEY_STATE_RELEASED)
> + return;
> +
> + switch (sym) {
> + case XKB_KEY_Escape:
> + display_exit(cliptest->display);
> + return;
> + case XKB_KEY_w:
> + g->clip.y1 -= 1;
> + g->clip.y2 -= 1;
> + break;
> + case XKB_KEY_a:
> + g->clip.x1 -= 1;
> + g->clip.x2 -= 1;
> + break;
> + case XKB_KEY_s:
> + g->clip.y1 += 1;
> + g->clip.y2 += 1;
> + break;
> + case XKB_KEY_d:
> + g->clip.x1 += 1;
> + g->clip.x2 += 1;
> + break;
> + case XKB_KEY_i:
> + g->clip.y2 -= 1;
> + break;
> + case XKB_KEY_j:
> + g->clip.x2 -= 1;
> + break;
> + case XKB_KEY_k:
> + g->clip.y2 += 1;
> + break;
> + case XKB_KEY_l:
> + g->clip.x2 += 1;
> + break;
> + case XKB_KEY_n:
> + geometry_set_phi(g, g->phi + (M_PI / 24.0));
> + cliptest->surface.transform.enabled = 1;
> + break;
> + case XKB_KEY_m:
> + geometry_set_phi(g, g->phi - (M_PI / 24.0));
> + cliptest->surface.transform.enabled = 1;
> + break;
> + case XKB_KEY_r:
> + geometry_set_phi(g, 0.0);
> + cliptest->surface.transform.enabled = 0;
> + break;
> + default:
> + return;
> + }
> +
> + widget_schedule_redraw(cliptest->widget);
> +}
> +
> +static void
> +keyboard_focus_handler(struct window *window,
> + struct input *device, void *data)
> +{
> + struct cliptest *cliptest = data;
> +
> + window_schedule_redraw(cliptest->window);
> +}
> +
> +static void
> +fullscreen_handler(struct window *window, void *data)
> +{
> + struct cliptest *cliptest = data;
> +
> + cliptest->fullscreen ^= 1;
> + window_set_fullscreen(window, cliptest->fullscreen);
> +}
> +
> +static struct cliptest *
> +cliptest_create(struct display *display)
> +{
> + struct cliptest *cliptest;
> +
> + cliptest = malloc(sizeof *cliptest);
> + if (cliptest == NULL)
> + return cliptest;
> + memset(cliptest, 0, sizeof *cliptest);
> +
> + cliptest->surface.geometry = &cliptest->geometry;
> + cliptest->surface.transform.enabled = 0;
> + geometry_init(&cliptest->geometry);
> + geometry_init(&cliptest->ui.geometry);
> +
> + cliptest->window = window_create(display);
> + cliptest->widget = frame_create(cliptest->window, cliptest);
> + window_set_title(cliptest->window, "cliptest");
> + cliptest->display = display;
> +
> + window_set_user_data(cliptest->window, cliptest);
> + widget_set_redraw_handler(cliptest->widget, redraw_handler);
> + widget_set_button_handler(cliptest->widget, button_handler);
> + widget_set_motion_handler(cliptest->widget, motion_handler);
> + widget_set_axis_handler(cliptest->widget, axis_handler);
> +
> + window_set_keyboard_focus_handler(cliptest->window,
> + keyboard_focus_handler);
> + window_set_key_handler(cliptest->window, key_handler);
> + window_set_fullscreen_handler(cliptest->window, fullscreen_handler);
> +
> + /* set minimum size */
> + widget_schedule_resize(cliptest->widget, 200, 100);
> +
> + /* set current size */
> + widget_schedule_resize(cliptest->widget, 500, 400);
> +
> + return cliptest;
> +}
> +
> +static struct timespec begin_time;
> +
> +static void
> +reset_timer(void)
> +{
> + clock_gettime(CLOCK_MONOTONIC, &begin_time);
> +}
> +
> +static double
> +read_timer(void)
> +{
> + struct timespec t;
> +
> + clock_gettime(CLOCK_MONOTONIC, &t);
> + return (double)(t.tv_sec - begin_time.tv_sec) +
> + 1e-9 * (t.tv_nsec - begin_time.tv_nsec);
> +}
> +
> +static int
> +benchmark(void)
> +{
> + struct weston_surface surface;
> + struct geometry geom;
> + GLfloat ex[8], ey[8];
> + int i;
> + double t;
> + const int N = 1000000;
> +
> + geom.clip.x1 = -19;
> + geom.clip.y1 = -19;
> + geom.clip.x2 = 19;
> + geom.clip.y2 = 19;
> +
> + geom.surf.x1 = -20;
> + geom.surf.y1 = -20;
> + geom.surf.x2 = 20;
> + geom.surf.y2 = 20;
> +
> + geometry_set_phi(&geom, 0.0);
> +
> + surface.transform.enabled = 1;
> + surface.geometry = &geom;
> +
> + reset_timer();
> + for (i = 0; i < N; i++) {
> + geometry_set_phi(&geom, (float)i / 360.0f);
> + calculate_edges(&surface, &geom.clip, &geom.surf, ex, ey);
> + }
> + t = read_timer();
> +
> + printf("%d calls took %g s, average %g us/call\n", N, t, t / N * 1e6);
> +
> + return 0;
> +}
> +
> +int
> +main(int argc, char *argv[])
> +{
> + struct display *d;
> + struct cliptest *cliptest;
> +
> + if (argc > 1)
> + return benchmark();
> +
> + d = display_create(argc, argv);
> + if (d == NULL) {
> + fprintf(stderr, "failed to create display: %m\n");
> + return -1;
> + }
> +
> + cliptest = cliptest_create(d);
> + display_run(d);
> +
> + widget_destroy(cliptest->widget);
> + window_destroy(cliptest->window);
> + free(cliptest);
> +
> + return 0;
> +}
-------------- next part --------------
A non-text attachment was scrubbed...
Name: wayland-screenshot2.png
Type: image/png
Size: 191787 bytes
Desc: not available
URL: <http://lists.freedesktop.org/archives/wayland-devel/attachments/20120911/a1882ad0/attachment-0001.png>
More information about the wayland-devel
mailing list