# To unbundle, run this file
echo mkfile
sed 's/^X//' >mkfile <<'!'
X</$objtype/mkfile
TARG=rotzoomer
OFILES=\
X getscr.$O\
X rotzoomer.$O
HFILES=getscr.h
BIN=$home/bin/$objtype
X</sys/src/cmd/mkone
X# LDFLAGS=-p
!
echo getscr.c
sed 's/^X//' >getscr.c <<'!'
X#include <u.h>
X#include <libc.h>
X#include <draw.h>
X#include "getscr.h"
X/*
X * allocates temporary storage for and reads
X * /dev/screen... modified from of lens.c
X */
uchar *
getscr(void)
X{
X char buf[5*12];
X ulong chan;
X uchar *screenbuf;
X int d, screenfd;
X screenfd = open("/dev/screen", OREAD);
X if(screenfd < 0)
X sysfatal("can't open /dev/screen: %r");
X if(read(screenfd, buf, sizeof buf) != sizeof buf)
X sysfatal("can't read /dev/screen: %r");
X chan = strtochan(buf);
X d = chantodepth(chan);
X if(d < 8)
X sysfatal("can't handle screen format %11.11s", buf);
X bypp = d/8;
X screenr.min.x = atoi(buf+1*12);
X screenr.min.y = atoi(buf+2*12);
X screenr.max.x = atoi(buf+3*12);
X screenr.max.y = atoi(buf+4*12);
X screenbuf = malloc(bypp*Dx(screenr)*Dy(screenr));
X if(screenbuf == nil)
X sysfatal("screen buffer malloc failed: %r");
X if(readn(screenfd, screenbuf, bypp*Dx(screenr)*Dy(screenr)) != bypp*Dx(screenr)*Dy(screenr))
X sysfatal("can't read screen: %r");
X return screenbuf;
X}
X/*
X * squeeze the screenshot to fit in the current window
X */
Image *
squeeze(uchar *buf)
X{
X int x, y, dxim, dyim, yydxsc;
X float dx, dy;
X Image *im;
X uchar *out, *src, *dst;
X if(buf == nil)
X return nil;
X im = allocimage(display, screen->r, screen->chan, 0, DBlack);
X if(im == nil)
X sysfatal("can't allocate temp image");
X dxim = Dx(im->r);
X dyim = Dy(im->r);
X dx = (float)Dx(screenr)/dxim;
X dy = (float)Dy(screenr)/dyim;
X out = (uchar *)malloc(bypp*dxim*dyim);
X if(out == nil)
X sysfatal("can't allocate temp memory");
X dst = out;
X for (y=0; y < dyim; y++) {
X yydxsc = ((int)(dy*y))*Dx(screenr);
X src = &buf[bypp*yydxsc];
X for (x=0; x < dxim; x++) {
X memmove(dst, src, bypp);
X dst += bypp;
X /*
X * ensure that src remains on a pixel boundary.
X * it's important that dx*x be computed in floating point
X * and rounded down, then multiplied by bypp.
X */
X src = &buf[bypp*(yydxsc + (int)(dx*x))];
X }
X }
X if(loadimage(im, im->r, out, bypp*dxim*dyim) != bypp*dxim*dyim)
X sysfatal("loadimage");
X free(out);
X return im;
X}
!
echo getscr.h
sed 's/^X//' >getscr.h <<'!'
uchar* getscr(void);
Image* squeeze(uchar *);
Rectangle screenr;
int bypp;
!
echo rotzoomer.c
sed 's/^X//' >rotzoomer.c <<'!'
X/*
X * rotzoomer - creates a collage of rotated and scaled portions of the screen
X * Copyright (C) 2001 Claudio Matsuoka <claudio@helllabs.org>
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation. No representations are made about the suitability of this
X * software for any purpose. It is provided "as is" without express or
X * implied warranty.
X */
X/*
X * ported to Plan 9 by mirtchov@cpsc.ucalgary.ca, 01/03
X */
X/* plan9-related stuff */
X#include <u.h>
X#include <libc.h>
X#include <draw.h>
X#include <event.h>
X/* screenshot-related stuff */
X#include "getscr.h"
static uchar *scrbuf;
static Image *scrimg;
static Image *bufimg;
X/* other defines */
X#define NULL nil
X#define XPoint Point
X#define NRAND nrand
X#define LRAND lrand
X#define random lrand
X#define MAXRAND ((2<<31)-1)
X#define MAX(a, b) (((a) > (b))?(a):(b))
X#define MIN(a, b) (((a) < (b))?(a):(b))
X#define RAND_MAX MAXRAND
X#define ABS abs
Image *colors[256];
X#define M_PI PI
X#define Bool int
X#define False 0
X#define True 1
X#define CYCLES 50000
char *buttons[] = {
X "sweep on/off",
X "exit",
X 0
X};
Menu menu = {
X buttons
X};
Mouse m;
X/* end of plan9-related defines */
typedef struct {
X int w, h; /* rectangle width and height */
X int inc1, inc2; /* rotation and zoom angle increments */
X int dx, dy; /* translation increments */
X int a1, a2; /* rotation and zoom angular variables */
X int ox, oy; /* origin in the background copy */
X int xx, yy; /* left-upper corner position (* 256) */
X int x, y; /* left-upper corner position */
X int ww, hh; /* valid area to place left-upper corner */
X int n; /* # of iteractions */
X int count; /* current iteraction */
X} Zoom;
static int width, height;
static Zoom **zoom_box = nil;
static int num_zoom = 2;
static int move = 0;
static int sweep = 0;
static int delay = 10;
static int anim = 1;
typedef struct {
X Rectangle r;
X} Screendim;
static Screendim scrdim;
static void
rotzoom(Zoom *za)
X{
X int x, y, c, s, zoom, z;
X int x2 = za->x + za->w - 1, y2 = za->y + za->h - 1;
X int ox = 0, oy = 0, ys, yc;
X Rectangle r;
X z = 8100 * sin(M_PI * za->a2 / 8192);
X zoom = 8192 + z;
X c = zoom * cos(M_PI * za->a1 / 8192);
X s = zoom * sin(M_PI * za->a1 / 8192);
X ys = za->y * s;
X yc = za->y * c;
X for (y = za->y; y <= y2; y++) {
X int oxbig = za->x*c + ys;
X int oybig = -za->x*s + yc;
X ys += s;
X yc += c;
X for (x = za->x; x <= x2; x++) {
X ox = oxbig >> 13;
X if (ox < 0)
X do {
X ox += width;
X } while (ox < 0);
X else
X while (ox >= width)
X ox -= width;
X oxbig += c;
X oy = oybig >> 13;
X if (oy < 0)
X do {
X oy += height;
X } while (oy < 0);
X else
X while (oy >= height)
X oy -= height;
X oybig -= s;
X // XPutPixel(buffer_map, x, y, XGetPixel(scrbuf, ox, oy));
X r.max.x = (r.min.x = scrdim.r.min.x + x) + 2;
X r.max.y = (r.min.y = scrdim.r.min.y + y) + 2;
X /* we call draw way too much */
X draw(screen, r, scrimg, nil,
X (Point){scrdim.r.min.x + ox, scrdim.r.min.y + oy});
X }
X }
X za->a1 += za->inc1; /* Rotation angle */
X za->a1 &= 0x3fff;;
X za->a2 += za->inc2; /* Zoom */
X za->a2 &= 0x3fff;
X za->ox = ox; /* Save state for next iteration */
X za->oy = oy;
X za->count++;
X}
static void
reset_zoom(Zoom *za)
X{
X if (sweep) {
X int speed = random()%100 + 100;
X switch ((ulong)random()%4) {
X case 0:
X za->w = width;
X za->h = 10;
X za->x = za->y = za->dx = 0;
X za->dy = speed;
X za->n = height - 10;
X break;
X case 1:
X za->w = 10;
X za->h = height;
X za->x = width - 10;
X za->y = 0;
X za->dx = -speed;
X za->dy = 0;
X za->n = width - 10;
X break;
X case 2:
X za->w = width;
X za->h = 10;
X za->x = 0;
X za->y = height - 10;
X za->dx = 0;
X za->dy = -speed;
X za->n = height - 10;
X break;
X case 3:
X za->w = 10;
X za->h = height;
X za->x = 0;
X za->y = 0;
X za->dx = speed;
X za->dy = 0;
X za->n = width - 10;
X break;
X }
X za->n = (za->n * 256) / speed;
X za->ww = width - za->w;
X za->hh = height - za->h;
X /* We want smaller angle increments in sweep mode (looks better) */
X za->a1 = za->a2 = 0;
X za->inc1 = (2*(random() & 1) - 1) * (1 + random()%7);
X za->inc2 = (2*(random() & 1) - 1) * (1 + random()%7);
X } else {
X za->w = 50 + random()%300;
X za->h = 50 + random()%300;
X if (za->w > width / 3)
X za->w = width / 3;
X if (za->h > height / 3)
X za->h = height / 3;
X za->ww = width - za->w;
X za->hh = height - za->h;
X za->x = random() % za->ww;
X za->y = random() % za->hh;
X za->dx = (2*(random() & 1) - 1) * (100 + random()%300);
X za->dy = (2*(random() & 1) - 1) * (100 + random()%300);
X if (anim) {
X za->n = 50 + random()%1000;
X za->a1 = za->a2 = 0;
X } else {
X za->n = 5 + random()%10;
X za->a1 = random();
X za->a2 = random();
X }
X za->inc1 = (2*(random() & 1) - 1) * (random() % 30);
X za->inc2 = (2*(random() & 1) - 1) * (random() % 30);
X }
X za->xx = za->x * 256;
X za->yy = za->y * 256;
X za->count = 0;
X}
static Zoom *
create_zoom(void)
X{
X Zoom *za = malloc(sizeof(Zoom));
X reset_zoom(za);
X return za;
X}
static void
update_position(Zoom *za)
X{
X za->xx += za->dx;
X za->yy += za->dy;
X za->x = za->xx >> 8;
X za->y = za->yy >> 8;
X if (za->x < 0) {
X za->x = 0;
X za->dx = 100 + random() % 100;
X }
X if (za->y < 0) {
X za->y = 0;
X za->dy = 100 + random() % 100;
X }
X if (za->x > za->ww) {
X za->x = za->ww;
X za->dx = -(100 + random() % 100);
X }
X if (za->y > za->hh) {
X za->y = za->hh;
X za->dy = -(100 + random() % 100);
X }
X}
static void
hack_main(void)
X{
X int i;
X for (i = 0; i < num_zoom; i++) {
X if (move || sweep)
X update_position (zoom_box[i]);
X if (zoom_box[i]->n > 0) {
X if (anim || zoom_box[i]->count == 0)
X rotzoom(zoom_box[i]);
X else
X sleep(1);
X zoom_box[i]->n--;
X } else
X reset_zoom(zoom_box[i]);
X }
X flushimage(display, 1);
X if(ecanmouse()) {
X m = emouse();
X if(m.buttons&4)
X switch(emenuhit(3, &m, &menu)) {
X case 0:
X sweep = !sweep;
X for(i = 0; i < num_zoom; i++)
X reset_zoom(zoom_box[i]);
X break;
X case 1:
X exits(0);
X default:
X sysfatal("no such button in menu choice!");
X }
X }
X}
void
eresized(int new)
X{
X int i;
X if(new && getwindow(display, Refnone) < 0)
X sysfatal("can't reattach to window: %r");
X scrdim.r = screen->r;
X width = Dx(scrdim.r);
X height = Dy(scrdim.r);
X if (width & 1)
X width--;
X if (height & 1)
X height--;
X if(scrimg != nil)
X freeimage(scrimg);
X scrimg = squeeze(scrbuf);
X if(scrimg == nil)
X sysfatal("unable to fit screenshot to window: %r");
X if(zoom_box == nil) {
X zoom_box = calloc(num_zoom, sizeof(Zoom *));
X for(i = 0; i < num_zoom; i++)
X zoom_box[i] = create_zoom();
X } else
X for (i = 0; i < num_zoom; i++)
X reset_zoom(zoom_box[i]);
X draw(screen, scrdim.r, display->black, nil, ZP);
X}
void
screenhack(void)
X{
X /* In sweep or static mode, we want only one box */
X if (sweep || !anim)
X num_zoom = 1;
X /* Can't have static sweep mode */
X if (!anim)
X sweep = 0;
X /* Main drawing loop */
X for (; ; ) {
X hack_main();
X sleep(delay);
X }
X}
void
main(int argc, char **argv)
X{
X USED(argc, argv);
X srand(time(0));
X num_zoom = 2;
X move = delay = 0;
X sweep = anim = 1;
X scrbuf = getscr();
X if(scrbuf == nil)
X sysfatal("could not obtain screenshot: %r");
X if(initdraw(nil, nil, "rotzoomer") < 0)
X sysfatal("initdraw failed: %r");
X einit(Emouse);
X eresized(0);
X screenhack();
X}
!
|
