| |
| /* |
| * Test011 |
| * |
| * Copyright 2007 Sony Corporation |
| * Copyright (C) 2007 Sony Computer Entertainment Inc. |
| * |
| * This file is subject to the terms and conditions of the GNU General Public |
| * License. See the file COPYING in the main directory of this archive for |
| * more details. |
| */ |
| |
| #include <assert.h> |
| #include <unistd.h> |
| |
| #include "types.h" |
| #include "fb.h" |
| #include "drawops.h" |
| #include "visual.h" |
| #include "test.h" |
| #include "util.h" |
| |
| #define BLOCKSIZE 29 |
| |
| #define SLEEP_MS 5 |
| |
| struct linegen { |
| u32 x1, y1, x2, y2; |
| int dx, dy; |
| int sx, sy; |
| int e; |
| int first; |
| }; |
| |
| static void linegen_init(struct linegen *gen, u32 x1, u32 y1, u32 x2, u32 y2) |
| { |
| gen->x1 = x1; |
| gen->y1 = y1; |
| gen->x2 = x2; |
| gen->y2 = y2; |
| gen->dx = x2-x1; |
| gen->dy = y2-y1; |
| |
| if (gen->dy < 0) { |
| gen->dy = -gen->dy; |
| gen->sy = -1; |
| } else { |
| gen->sy = 1; |
| } |
| if (gen->dx < 0) { |
| gen->dx = -gen->dx; |
| gen->sx = -1; |
| } else { |
| gen->sx = 1; |
| } |
| gen->e = gen->dx > gen->dy ? -gen->dx/2 : -gen->dy/2; |
| gen->first = 1; |
| } |
| |
| static int linegen_next(struct linegen *gen, u32 *x, u32 *y) |
| { |
| if (gen->first) |
| gen->first = 0; |
| else if (gen->dx > gen->dy) { |
| if (gen->x1 == gen->x2) |
| return 0; |
| |
| gen->e += gen->dy; |
| if (gen->e >= 0) { |
| gen->y1 += gen->sy; |
| gen->e -= gen->dx; |
| } |
| gen->x1 += gen->sx; |
| } else { |
| if (gen->y1 == gen->y2) |
| return 0; |
| |
| gen->e += gen->dx; |
| if (gen->e >= 0) { |
| gen->x1 += gen->sx; |
| gen->e -= gen->dy; |
| } |
| gen->y1 += gen->sy; |
| } |
| *x = gen->x1; |
| *y = gen->y1; |
| return 1; |
| } |
| |
| static void move(u32 cx, u32 cy, u32 x1, u32 y1, u32 x2, u32 y2) |
| { |
| struct linegen gen; |
| u32 x, y; |
| static int cnt = 0; |
| |
| linegen_init(&gen, x1, y1, x2, y2); |
| while (linegen_next(&gen, &x, &y)) { |
| fill_circle(cx+x, cy+y, 2, cnt & 4 ? black_pixel : white_pixel); |
| fb_pan(x, y); |
| wait_ms(SLEEP_MS); |
| cnt++; |
| } |
| } |
| |
| static enum test_res test011_func(void) |
| { |
| u32 x, y, cx, cy, dx, dy; |
| int even; |
| |
| fill_rect(0, 0, fb_var.xres_virtual, fb_var.yres_virtual, black_pixel); |
| for (y = 0; y < fb_var.yres_virtual; y += BLOCKSIZE) { |
| even = (y / BLOCKSIZE) % 2; |
| draw_hline(0, y, fb_var.xres_virtual, white_pixel); |
| for (x = 0; x < fb_var.xres_virtual; x += BLOCKSIZE) { |
| if (even && x+4 < fb_var.xres_virtual && |
| y+4 <= fb_var.yres_virtual) |
| fill_rect(x+4, y+4, |
| min(BLOCKSIZE-8, fb_var.xres_virtual-x-4), |
| min(BLOCKSIZE-8, fb_var.yres_virtual-y-4), |
| white_pixel); |
| even ^= 1; |
| } |
| } |
| for (x = 0; x < fb_var.xres_virtual; x += BLOCKSIZE) |
| draw_vline(x, 0, fb_var.yres_virtual, white_pixel); |
| |
| cx = fb_var.xres/2; |
| cy = fb_var.yres/2; |
| |
| dx = fb_fix.xpanstep ? fb_var.xres_virtual-fb_var.xres : 0; |
| dy = fb_fix.ypanstep ? fb_var.yres_virtual-fb_var.yres : 0; |
| |
| /* move right */ |
| move(cx, cy, 0, 0, dx, 0); |
| |
| /* move down */ |
| move(cx, cy, dx, 0, dx, dy); |
| |
| /* move left */ |
| move(cx, cy, dx, dy, 0, dy); |
| |
| if (dx >= 2 && dy >= 2) { |
| /* move up and right */ |
| move(cx, cy, 0, dy, dx/2, 0); |
| |
| /* move right and down */ |
| move(cx, cy, dx/2, 0, dx, dy/2); |
| |
| /* move left and down */ |
| move(cx, cy, dx, dy/2, dx/2, dy); |
| |
| /* move up and left */ |
| move(cx, cy, dx/2, dy, 0, 0); |
| } else { |
| /* move up */ |
| move(cx, cy, 0, dy, 0, 0); |
| } |
| |
| wait_for_key(10); |
| return TEST_OK; |
| } |
| |
| const struct test test011 = { |
| .name = "test011", |
| .desc = "Panning test", |
| .visual = VISUAL_MONO, |
| .reqs = REQF_panning, |
| .func = test011_func, |
| }; |
| |