/* Whirlygig -- an experiment in X programming * * 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. No representations are made about the suitability of this * software for any purpose. It is provided "as is" without express or * implied warranty. * * When I was in trigonometry class as a kid, I remember being fascinated * by the beauty of the shapes one receives when playing with sine waves * Here is a little experiment to show that beauty is simple */ #include #include #include "screenhack.h" #ifdef HAVE_DOUBLE_BUFFER_EXTENSION # include "xdbe.h" #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */ #define NCOLORS 100 #define FULL_CYCLE 429496729 #define START_ARC 0 #define END_ARC 23040 struct info { /* Bool writable; / * Is the screen writable */ double xspeed; /* A factor to modify the horizontal movement */ double yspeed; /* A factor to modify vertical movement */ double xamplitude; double yamplitude; int whirlies; /* How many whirlies per line do you want? */ int nlines; /* How many lines of whirlies do you want? */ int half_width; /* 1/2 the width of the screen */ int half_height; int speed; int trail; int color_modifier; double xoffset; double yoffset; double offset_period; int wrap; }; enum object_mode { spin_mode, funky_mode, circle_mode, linear_mode, test_mode, fun_mode, innie_mode, lissajous_mode } mode; static void explain(int, int, struct info *, Display *, Window, GC); static void draw_explain_string(int, int, Display *, Window, GC); static void spin(unsigned long int, struct info *, int *, int); static void funky(unsigned long int, struct info *, int *, int); static void circle(unsigned long int, struct info *, int *, int); static void fun(unsigned long int, struct info *, int *, int); static void linear(unsigned long int, struct info *, int *, int); static void lissajous(unsigned long int, struct info *, int *, int); static void test(unsigned long int, struct info *, int *, int); static void innie(unsigned long int, struct info *, int *, int, double); XColor colors[NCOLORS]; int ncolors = NCOLORS; char *progclass = "Whirlygig"; char *defaults [] = { ".background: black", ".foreground: white", "*xspeed: 1.0", "*yspeed: 1.0", "*xamplitude: 1.0", "*yamplitude: 1.0", "*whirlies: -1", "*nlines: -1", "*xmode: change", "*ymode: change", "*speed: 1", "*trail: 0", "*color_modifier: -1", "*start_time: -1", "*explain: False", "*xoffset: 1.0", "*yoffset: 1.0", "*offset_period: 1", "*wrap: 0", "*doubleBuffer: True", #ifdef HAVE_DOUBLE_BUFFER_EXTENSION "*useDBE: True", "*useDBEClear: True", #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */ 0 }; XrmOptionDescRec options [] = { { "-xspeed", ".xspeed", XrmoptionSepArg, 0 }, /* xspeed is a modifier of the argument to cos -- changing it thus changes the frequency of cos */ { "-yspeed", ".yspeed", XrmoptionSepArg, 0 }, /* Similiarly, yspeed changes the frequency of sin */ { "-xamplitude", ".xamplitude", XrmoptionSepArg, 0 }, /* A factor by which to increase/decrease the amplitude of the sin */ { "-yamplitude", ".yamplitude", XrmoptionSepArg, 0 }, /* A factor by which to increase/decrease the amplitude of the cos */ { "-whirlies", ".whirlies",XrmoptionSepArg, 0 }, /* whirlies defines the number of circles to draw per line */ { "-nlines", ".nlines",XrmoptionSepArg, 0 }, /* nlines is the number of lines of whirlies to draw */ { "-xmode", ".xmode", XrmoptionSepArg, 0 }, /* There are a few different modes that I have written -- each mode is in theory a different experiment with the possible modifiers to sin/cos */ { "-ymode", ".ymode", XrmoptionSepArg, 0 }, { "-speed", ".speed", XrmoptionSepArg, 0 }, /* This will modify how often it should draw, changing it will probably suck */ { "-trail", ".trail", XrmoptionSepArg, 0 }, /* Control whether or not you want the old circles to be erased */ { "-color_modifier", ".color_modifier", XrmoptionSepArg, 0 }, /* How many colors away from the current should the next whirly be? */ { "-start_time", ".start_time", XrmoptionSepArg, 0 }, /* Specify exactly at what time to start graphing... */ { "-xoffset", ".xoffset", XrmoptionSepArg, 0 }, /* Tell the whirlies to be offset by this factor of a sin */ { "-yoffset", ".yoffset", XrmoptionSepArg, 0 }, /* Tell the whirlies to be offset by this factor of a cos */ { "-offset_period", ".offset_period", XrmoptionSepArg, 0 }, /* Change the period of an offset cycle */ { "-explain", ".explain", XrmoptionNoArg, "True" }, /* Specify whether or not to print an explanation of the function used. */ { "-wrap", ".wrap", XrmoptionSepArg, 0 }, /* Specify if you want whirlies which are out of the boundary of the screen to be wrapped around to the other side */ { "-db", ".doubleBuffer", XrmoptionNoArg, "True" }, { "-no-db", ".doubleBuffer", XrmoptionNoArg, "False" }, { 0, 0, 0, 0 } }; static const char spin_explanation[] = "Spin mode is a simple sin/cos with every argument modified"; static const char funky_explanation[] = "Funky mode is me goofing off."; static const char circle_explanation[] = "Circle mode graphs the x and y positions as you trace the edge of a circle over time."; static const char linear_explanation[] = "Linear mode draws a straight line"; static const char test_explanation[] = "Test mode is a mode that I play around with ideas in."; static const char fun_explanation[] = "Fun mode is the coolest."; static const char innie_explanation[] = "Innie mode does something or other. Looks cool, though."; static const char lissajous_explanation[] = "Lissajous mode draws a slightly modified lissajous curve"; static void explain(int xmode, int ymode, struct info *info, Display *display, Window window, GC fgc) { XClearWindow(display, window); draw_explain_string(xmode, info->half_height-100, display, window, fgc); /* draw_explain_string(ymode, info->half_height-50, display, window, fgc);*/ XSync(display, False); sleep(3); XClearWindow(display, window); } static void draw_explain_string(int mode, int offset, Display *display, Window window, GC fgc) { switch(mode) { case spin_mode: XDrawString(display, window, fgc, 50, offset, spin_explanation, strlen(spin_explanation)); break; case funky_mode: XDrawString(display, window, fgc, 50, offset, funky_explanation, strlen(funky_explanation)); break; case circle_mode: XDrawString(display, window, fgc, 50, offset, circle_explanation, strlen(circle_explanation)); break; case linear_mode: XDrawString(display, window, fgc, 50, offset, linear_explanation, strlen(linear_explanation)); break; case test_mode: XDrawString(display, window, fgc, 50, offset, test_explanation, strlen(test_explanation)); break; case fun_mode: XDrawString(display, window, fgc, 50, offset, fun_explanation, strlen(fun_explanation)); break; case innie_mode: XDrawString(display, window, fgc, 50, offset, innie_explanation, strlen(innie_explanation)); break; case lissajous_mode: XDrawString(display, window, fgc, 50, offset, lissajous_explanation, strlen(linear_explanation)); } } static void funky(unsigned long int the_time, struct info *info, int pos[], int index) { double new_time = ((the_time % 360 ) / 180.0) * M_PI; if (index == 0) { double time_modifier = cos(new_time / 180.0); double the_cos = cos((new_time * (double)info->xspeed) + (time_modifier * 80.0)); double dist_mod_x = cos(new_time) * (info->half_width - 50); pos[index]= info->xamplitude * (the_cos * dist_mod_x) + info->half_width; } else { double new_time = ((the_time % 360 ) / 180.0) * M_PI; double time_modifier = sin(new_time / 180.0); double the_sin = sin((new_time * (double)info->yspeed) + (time_modifier * 80.0)); double dist_mod_y = sin(new_time) * (info->half_height - 50); pos[index] = info->yamplitude * (the_sin * dist_mod_y) + info->half_height; } } static void innie(unsigned long int the_time, struct info *info, int pos[], int index, double modifier) { double frequency = 2000000.0 + (modifier * cos(((double)the_time / 100.0))); double arg = (double)the_time / frequency; double amplitude = 200.0 * cos(arg); double fun = 150.0 * cos((double)the_time / 2000.0); int vert_mod, horiz_mod; if (index == 0) { horiz_mod = (int)(fun * cos((double)the_time / 100.0)) + info->half_width; pos[index] = (amplitude * cos((double)the_time / 100.0 * info->xspeed)) + horiz_mod; } else { vert_mod = (int)(fun * sin((double)the_time / 100.0)) + info->half_height; pos[index] = (amplitude * sin((double)the_time / 100.0 * info->yspeed)) + vert_mod; } } static void lissajous(unsigned long int the_time, struct info *info, int pos[], int index) { /* This is a pretty standard lissajous curve x = a sin(nt + c) y = b sin(t) The n and c modifiers are cyclic as well, however... */ int result; double time = (double)the_time / 100.0; double fun = 15.0 * cos((double)the_time / 800.0); double weird = cos((time / 1100000.0) / 1000.0); if (index == 0) { result = info->xamplitude * 200.0 * sin((weird * time) + fun) + info->half_width; } else { result = info->yamplitude * 200.0 * sin(time) + info->half_height; } pos[index] = result; } static void circle(unsigned long int the_time, struct info *info, int pos[], int index) { int result; if (index == 0) { result = info->xamplitude * (cos((double)the_time / 100.0 * info->xspeed) * (info->half_width / 2)) + info->half_width; } else { result = info->yamplitude * (sin((double)the_time / 100.0 * info->yspeed) * (info->half_height / 2)) + info->half_height; } pos[index] = result; } #if 0 static void mod(unsigned long int the_time, struct info *info, int pos[], int index) { int amplitude; int max = info->half_width; if ((the_time % (max * 2)) < max) amplitude = max - ((the_time % (max * 2)) - max); else amplitude = the_time % (max * 2); amplitude = amplitude - max; } #endif static void spin(unsigned long int the_time, struct info *info, int pos[], int index) { double funky = (((the_time % 360) * 1.0) / 180.0) * M_PI; if (index ==0) { double the_cos = cos((double)the_time / (180.0 * info->xspeed)); double dist_mod_x = cos((double)funky) * (info->half_width - 50); pos[index] = info->xamplitude * (the_cos * dist_mod_x) + info->half_width; } else { double the_sin = sin((double)the_time / (180.0 * info->yspeed)); double dist_mod_y = sin((double)funky) * (info->half_height - 50); pos[index] = info->yamplitude * (the_sin * dist_mod_y) + info->half_height; } } static void fun(unsigned long int the_time, struct info *info, int pos[], int index) { int amplitude; int max = info->half_width; if ((the_time % (max * 2)) < max) amplitude = max - ((the_time % (max * 2)) - max); else amplitude = the_time % (max * 2); amplitude = amplitude - max; if (index ==0) { pos[index] = (amplitude * cos((double)the_time / 100.0 * info->xspeed)) + info->half_width; } else { pos[index] = (amplitude * sin((double)the_time / 100.0 * info->yspeed)) + info->half_height; } } static void linear(unsigned long int the_time, struct info *info, int pos[], int index) { if (index == 0) /* Calculate for the x axis */ pos[index] = ((the_time / 2) % (info->half_width * 2)); else pos[index] = ((the_time / 2) % (info->half_height * 2)); } static void test(unsigned long int the_time, struct info *info, int pos[], int index) { if (index == 0) { pos[index] = info->xamplitude * (cos((double)the_time / 100.0 * info->xspeed) * (info->half_width / 2)) + info->half_width; } else { pos[index] = info->yamplitude * (sin((double)the_time / 100.0 * info->yspeed) * (info->half_height / 2)) + info->half_height; } } static int preen(int current, int max) { if (current > max) current=current-max; if (current < 0) current=current+max; return(current); } static void smoothen(int x, int lastx, int y, int lasty, int size, int last_color, XColor *colors, Display *display, Window window, GC bgc, int screen, struct info *info) { double xdistance = abs((double)x-(double)lastx); double ydistance = abs((double)y-(double)lasty); double distance = sqrt(((xdistance * xdistance) + (ydistance * ydistance)) ); double slope = (((double)y-(double)lasty) / ((double)x-(double)lastx)); printf("Starting smoothen with values: %f, %f, %f, %f\n", xdistance, ydistance, distance, slope); if (distance > 2.0) { int newx = (int)((xdistance / distance) * slope); int newy = (int)((ydistance / distance) * slope); if (! info->trail) { XSetForeground(display, bgc, BlackPixel(display, screen)); XFillArc(display, window, bgc, lastx, lasty, size, size, START_ARC, END_ARC); } XSetForeground(display, bgc, colors[last_color].pixel); XFillArc(display, window, bgc, newx, newy, size, size, START_ARC, END_ARC); XSync(display, False); smoothen(newx, x, newy, y, size, last_color, colors, display, window, bgc, screen, info); } } void screenhack (Display *display, Window window) { /* The following are all X related toys */ XGCValues gcv; /* The structure to hold the GC data */ XWindowAttributes xgwa; /* A structure to hold window data */ Pixmap b=0, ba=0; /* double-buffer to reduce flicker */ #ifdef HAVE_DOUBLE_BUFFER_EXTENSION XdbeBackBuffer backb = 0; #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */ GC fgc, bgc; int screen; Bool dbuf = get_boolean_resource ("doubleBuffer", "Boolean"); Bool dbeclear_p = get_boolean_resource ("useDBEClear", "Boolean"); unsigned long int current_time = 0; /* The global int telling the current time */ unsigned long int start_time = current_time; struct info *info = (struct info *)malloc(sizeof(struct info)); /* Dont forget to call free() later */ char *xmode_str, *ymode_str; /* holds the current mode for x and y computation */ /* pos is the current position x,y -- last_x contains one cell of every x coordinate for every position of every whirly in every line up to 100 whirlies in 100 lines -- lasy_y and last_size hold the same information for y and size respectively */ int pos[2], last_x[100][100], last_y[100][100], last_size[100][100]; int current_color; int wrap; int xmode, ymode; double modifier; /* for innie */ /* Set up the X toys that I will be using later */ screen = DefaultScreen(display); XGetWindowAttributes (display, window, &xgwa); if (dbuf) { #ifdef HAVE_DOUBLE_BUFFER_EXTENSION if (dbeclear_p) b = xdbe_get_backbuffer (display, window, XdbeBackground); else b = xdbe_get_backbuffer (display, window, XdbeUndefined); backb = b; #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */ if (!b) { ba = XCreatePixmap (display, window, xgwa.width, xgwa.height,xgwa.depth); b = ba; } } else { b = window; } gcv.foreground = get_pixel_resource("foreground", "Foreground", display, xgwa.colormap); fgc = XCreateGC (display, b, GCForeground, &gcv); gcv.foreground = get_pixel_resource("background", "Background", display, xgwa.colormap); bgc = XCreateGC (display, b, GCForeground, &gcv); { Bool writable_p = False; make_uniform_colormap (display, xgwa.visual, xgwa.colormap, colors, &ncolors, True, &writable_p, True); } if (ba) XFillRectangle (display, ba, bgc, 0, 0, xgwa.width, xgwa.height); /* info is a structure holding all the random pieces of information I may want to pass to my baby functions -- much of it I may never use, but it is nice to have around just in case I want it to make a funky function funkier */ /* info->writable = get_boolean_resource ("cycle", "Boolean"); */ info->xspeed = get_float_resource("xspeed" , "Float"); info->yspeed = get_float_resource("yspeed" , "Float"); info->xamplitude = get_float_resource("xamplitude", "Float"); info->yamplitude = get_float_resource("yamplitude", "Float"); info->offset_period = get_float_resource("offset_period", "Float"); info->whirlies = get_integer_resource("whirlies", "Integer"); info->nlines = get_integer_resource("nlines", "Integer"); info->half_width = xgwa.width / 2; info->half_height = xgwa.height / 2; info->speed = get_integer_resource("speed" , "Integer"); info->trail = get_integer_resource("trail", "Integer"); info->color_modifier = get_integer_resource("color_modifier", "Integer"); info->xoffset = get_float_resource("xoffset", "Float"); info->yoffset = get_float_resource("yoffset", "Float"); xmode_str = get_string_resource("xmode", "Mode"); ymode_str = get_string_resource("ymode", "Mode"); wrap = get_integer_resource("wrap", "Integer"); modifier = 3000.0 + frand(1500.0); if (! xmode_str) xmode = spin_mode; else if (! strcmp (xmode_str, "spin")) xmode = spin_mode; else if (! strcmp (xmode_str, "funky")) xmode = funky_mode; else if (! strcmp (xmode_str, "circle")) xmode = circle_mode; else if (! strcmp (xmode_str, "linear")) xmode = linear_mode; else if (! strcmp (xmode_str, "test")) xmode = test_mode; else if (! strcmp (xmode_str, "fun")) xmode = fun_mode; else if (! strcmp (xmode_str, "innie")) xmode = innie_mode; else if (! strcmp (xmode_str, "lissajous")) xmode = lissajous_mode; else { xmode = spin_mode; } if (! ymode_str) ymode = spin_mode; else if (! strcmp (ymode_str, "spin")) ymode = spin_mode; else if (! strcmp (ymode_str, "funky")) ymode = funky_mode; else if (! strcmp (ymode_str, "circle")) ymode = circle_mode; else if (! strcmp (ymode_str, "linear")) ymode = linear_mode; else if (! strcmp (ymode_str, "test")) ymode = test_mode; else if (! strcmp (ymode_str, "fun")) ymode = fun_mode; else if (! strcmp (ymode_str, "innie")) ymode = innie_mode; else if (! strcmp (ymode_str, "lissajous")) ymode = lissajous_mode; else { ymode = spin_mode; } if (get_integer_resource("start_time", "Integer") == -1) current_time = (unsigned long int)(random()); else current_time = get_integer_resource("start_time", "Integer"); if (info->whirlies == -1) info->whirlies = 1 + (random() % 15); if (info->nlines == -1) info->nlines = 1 + (random() % 5); if (info->color_modifier == -1) info->color_modifier = 1 + (random() % 25); if (get_boolean_resource("explain", "Integer")) explain(xmode, ymode, info, display, window, fgc); current_color = 1 + (random() % NCOLORS); /* Now that info is full, lets play! */ while (1) { int wcount; /* wcount is a counter incremented for every whirly take note of internal_time before you mess with it */ int change_time = 4000; if (! strcmp (xmode_str, "change") && ! strcmp (ymode_str, "change")) { if ((current_time - start_time) > change_time) { start_time = current_time; xmode = 1 + (random() % 4); ymode = 1 + (random() % 4); } } else if (! strcmp (xmode_str, "change")) { if ((current_time - start_time) > change_time) { start_time = current_time; xmode = 1 + (random() % 4); } } else if (! strcmp (ymode_str, "change")) { if ((current_time - start_time) > change_time) { start_time = current_time; ymode = 1 + (random() % 3); printf("Changing ymode to %d\n", ymode); } } if (++current_color >= NCOLORS) current_color = 0; for (wcount = 0; wcount < info->whirlies; wcount++) { int lcount; /* lcount is a counter for every line -- take note of the offsets changing */ int internal_time = current_time; int color_offset = (current_color + (info->color_modifier * wcount)) % NCOLORS; if (current_time == 0) internal_time = 0; else /* I want the distance between whirlies to increase more each whirly */ internal_time = current_time + (10 * wcount) + (wcount * wcount); switch (xmode) { /* All these functions expect an int time, the struct info, a pointer to an array of positions, and the index that the the function will fill of the array */ case spin_mode: spin(internal_time, info, pos, 0); break; case funky_mode: funky(internal_time, info, pos, 0); break; case circle_mode: circle(internal_time, info, pos, 0); break; case linear_mode: linear(internal_time, info, pos, 0); break; case fun_mode: fun(internal_time, info, pos, 0); break; case test_mode: test(internal_time, info, pos, 0); break; case innie_mode: innie(internal_time, info, pos, 0, modifier); break; case lissajous_mode: lissajous(internal_time, info, pos, 0); break; default: spin(internal_time, info, pos, 0); break; } /* End of the switch for the x position*/ switch (ymode) { case spin_mode: spin(internal_time, info, pos, 1); break; case funky_mode: funky(internal_time, info, pos, 1); break; case circle_mode: circle(internal_time, info, pos, 1); break; case linear_mode: linear(internal_time, info, pos, 1); break; case fun_mode: fun(internal_time, info, pos, 1); break; case test_mode: test(internal_time, info, pos, 1); break; case innie_mode: innie(internal_time, info, pos, 1, modifier); break; case lissajous_mode: lissajous(internal_time, info, pos, 1); break; default: spin(internal_time, info, pos, 1); break; } /* End of the switch for the y position*/ for (lcount = 0; lcount < info->nlines; lcount++) { double arg = (double)((internal_time * info->offset_period) / 90.0); double line_offset = 20.0 * (double)lcount * sin(arg); int size; size = (int)(15.0 + 5.0 * sin((double)internal_time / 180.0)); /* First delete the old circle... */ if (!info->trail && ( !dbeclear_p #ifdef HAVE_DOUBLE_BUFFER_EXTENSION || !backb #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */ )) { XSetForeground(display, bgc, BlackPixel(display, screen)); XFillArc(display, b, bgc, last_x[wcount][lcount], last_y[wcount][lcount], last_size[wcount][lcount], last_size[wcount][lcount], START_ARC, END_ARC); } /* Now, lets draw in the new circle */ { /* Starting new scope for local x_pos and y_pos */ int xpos, ypos; if (wrap) { xpos = preen((int)(info->xoffset*line_offset)+pos[0], info->half_width * 2); ypos = preen((int)(info->yoffset*line_offset)+pos[1], info->half_height * 2); } else { xpos = (int)(info->xoffset*line_offset)+pos[0]; ypos = (int)(info->yoffset*line_offset)+pos[1]; } if (start_time == current_time) { /* smoothen should move from one mode to another prettily... */ /* Note: smoothen has not been modified to take the double buffering code into account, and needs to be hacked on before uncommenting. */ /* smoothen(xpos, last_x[wcount][lcount], ypos, last_y[wcount][lcount], size, color_offset, colors, display, window, bgc, screen, info); */ } last_x[wcount][lcount] = xpos; last_y[wcount][lcount] = ypos; last_size[wcount][lcount] = size; XSetForeground(display, bgc, colors[color_offset].pixel); XFillArc(display, b, bgc, xpos, ypos, size, size, START_ARC, END_ARC); } /* End of my temporary scope for xpos and ypos */ } /* End of the for each line in nlines */ } /* End of the for each whirly in whirlies */ #ifdef HAVE_DOUBLE_BUFFER_EXTENSION if (backb) { XdbeSwapInfo info[1]; info[0].swap_window = window; info[0].swap_action = (dbeclear_p ? XdbeBackground : XdbeUndefined); XdbeSwapBuffers (display, info, 1); } else #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */ if (dbuf) { XCopyArea (display, b, window, bgc, 0, 0, xgwa.width, xgwa.height, 0, 0); } XSync(display, False); if (current_time == FULL_CYCLE) current_time = 1; else current_time = current_time + info->speed; screenhack_handle_events(display); /* if (!info->writable) */ usleep(10000); } /* End the while loop! */ free(info); }