X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=hacks%2Fglx%2Fgleidescope.c;h=9a49b20af138759a19c87a1e1291c43813174d5b;hb=aa75c7476aeaa84cf3abc192b376a8b03c325213;hp=7470d3f3888d1584c92645212bcc2fe61fefc1b4;hpb=96a411663168b0ba5432b407a83be55f3df0c802;p=xscreensaver diff --git a/hacks/glx/gleidescope.c b/hacks/glx/gleidescope.c index 7470d3f3..9a49b20a 100644 --- a/hacks/glx/gleidescope.c +++ b/hacks/glx/gleidescope.c @@ -1,11 +1,14 @@ /* -*- Mode: C; tab-width: 4 -*- */ +/* vim: set ai ts=4 sw=4: */ -#if !defined( lint ) && !defined( SABER ) -static const char sccsid[] = "@(#)gleidescope.c 1.0 03/06/27 xlockmore"; +#if 0 +/*static const char sccsid[] = "@(#)gleidescope.c 1.0 03/06/27 xlockmore";*/ #endif -/* enable -grab switch */ -/*#define GRAB*/ +/* enable -grab switch for animations */ +#undef GRAB + +#undef DISPLAY_TEXTURE /*- * Permission to use, copy, modify, and distribute this software and its @@ -40,13 +43,26 @@ static const char sccsid[] = "@(#)gleidescope.c 1.0 03/06/27 xlockmore"; * no preference is given. * Made grid slightly bigger so you can't see * the edge when zooming and moving. + * 20061226 1.4 acd Now uses GL Display Lists. + * 20070318 1.5 acd Generates textures. + * Fixed texture size problem (and introduced another). + * 20070412 1.6 acd Textures now have independant sizes. + * 20070413 1.7 acd Added Lissajous movement pattern. + * 20070414 1.8 acd Added corners movement pattern. + * 20080319 1.9 acd Changes to arguments for saner gleidescope.xml. + * + * TODO + * generate textures myself - render random shapes to 256x256 texture. (done) + * lower res for checks and random - use 256 and 4x4 or 8x8 pixels. (disabled for now) + * gnome-saver doesn't let you specify source directory so add that to this. + * image loading routine is too slow - rotation grinds to a halt - stop using it. (better in version 5) + * image loading also looks bad for non-square images - edges are black. (fixed) + * possible to see edge of the world on widescreen terminals - use larger grid and hidden hex removal? + * fading textures may have different max_tx - use two sets. (done) + * choice of movement patterns. (3 implemented, chooseable at compile time) + * look into rangle and tangle. */ -#include -#include "colors.h" - -#include "xpm-ximage.h" - /* **---------------------------------------------------------------------------- ** Defines @@ -54,23 +70,14 @@ static const char sccsid[] = "@(#)gleidescope.c 1.0 03/06/27 xlockmore"; */ #ifdef STANDALONE -# define PROGCLASS "gleidescope" -# define HACK_INIT init_gleidescope -# define HACK_DRAW draw_gleidescope -# define HACK_RESHAPE reshape_gleidescope -# define HACK_HANDLE_EVENT gleidescope_handle_event -# define EVENT_MASK PointerMotionMask -# define gleidescope_opts xlockmore_opts # define DEFAULTS \ "*delay: 20000 \n" \ "*showFPS: False \n" \ - "*move: False \n" \ - "*rotate: False \n" \ - "*zoom: False \n" \ - "*image: DEFAULT \n" \ - "*size: -1 \n" \ - "*duration: 30 \n" \ + "*size: 0 \n" \ + "*useSHM: True \n" \ + "*suppressRotationAnimation: True\n" \ +# define refresh_gleidescope 0 # include "xlockmore.h" /* from the xscreensaver distribution */ #else /* !STANDALONE */ # include "xlock.h" /* from the xlockmore distribution */ @@ -78,9 +85,17 @@ static const char sccsid[] = "@(#)gleidescope.c 1.0 03/06/27 xlockmore"; #ifdef USE_GL -#include +#include "colors.h" +#include "xpm-ximage.h" +#include "grab-ximage.h" + +#ifdef GRAB +void grab_frame(Display *display, Window window); +#endif /* acd TODO should all these be in gleidestruct? */ +/* they can't be, because of the idiotic way the xlockmore "argtype vars" + interface works. -jwz */ #ifdef GRAB static Bool grab; /* grab images */ #endif @@ -88,54 +103,60 @@ static Bool move; /* moving camera */ static Bool nomove; /* no moving camera */ static Bool rotate; /* rotate in place */ static Bool norotate; /* no rotate in place */ -static int size = -1; /* size */ static Bool zoom; /* zooming camera */ static Bool nozoom; /* no zooming camera */ static char *image; /* name of texture to load */ static int duration; /* length of time to display grabbed image */ -#define MAX_TANGLE_VEL 2.0 +#define MAX_CAM_SPEED 1.0 +#define MAX_ANGLE_VEL 1.0 +#define INITIAL_ANGLE_VEL 0.2 +#define INITIAL_ANGLE_ACC 0.001 +#define TWISTING_PROBABILITY 1000 /* 1 in ... of change of acceleration */ -static float tangle = 0; /* texture angle */ -static float tangle_vel = 0.0; /* texture velocity */ -static float tangle_acc = 0.0; /* texture acceleration */ +#define RADIANS (M_PI / 180) +#define ANGLE_120 (M_PI * 2 / 3) +#define ANGLE_240 (M_PI * 4 / 3) -#define MAX_RANGLE_VEL 1.5 +#define DEF_GRAB "False" +#define DEF_MOVE "False" +#define DEF_NOMOVE "False" +#define DEF_ROTATE "False" +#define DEF_NOROTATE "False" +#define DEF_ZOOM "False" +#define DEF_NOZOOM "False" +#define DEF_IMAGE "DEFAULT" +#define DEF_DURATION "30" -static float rangle = 0; /* rotate angle */ -static float rangle_vel = 0.0; /* rotate velocity */ -static float rangle_acc = 0.0; /* rotate acceleration */ static XrmOptionDescRec opts[] = { #ifdef GRAB - {"-grab", (char *) ".gleidescope.grab", XrmoptionNoArg, "true"}, + {"-grab", ".gleidescope.grab", XrmoptionNoArg, "true"}, #endif - {"-move", (char *) ".gleidescope.move", XrmoptionNoArg, "true"}, - {"-no-move", (char *) ".gleidescope.nomove", XrmoptionNoArg, "true"}, - {"-rotate", (char *) ".gleidescope.rotate", XrmoptionNoArg, "true"}, - {"-no-rotate", (char *) ".gleidescope.norotate", XrmoptionNoArg, "true"}, - /*{"-size", (char *) ".gleidescope.size", XrmoptionNoArg, "-1"},*/ - {"-zoom", (char *) ".gleidescope.zoom", XrmoptionNoArg, "true"}, - {"-no-zoom", (char *) ".gleidescope.nozoom", XrmoptionNoArg, "true"}, - {"-image", (char *) ".gleidescope.image", XrmoptionSepArg, "DEFAULT"}, - {"-duration", (char *) ".gleidescope.duration", XrmoptionSepArg, "30"}, + {"-move", ".gleidescope.move", XrmoptionNoArg, "true"}, + {"-no-move", ".gleidescope.nomove", XrmoptionNoArg, "true"}, + {"-rotate", ".gleidescope.rotate", XrmoptionNoArg, "true"}, + {"-no-rotate", ".gleidescope.norotate", XrmoptionNoArg, "true"}, + {"-zoom", ".gleidescope.zoom", XrmoptionNoArg, "true"}, + {"-no-zoom", ".gleidescope.nozoom", XrmoptionNoArg, "true"}, + {"-image", ".gleidescope.image", XrmoptionSepArg, "DEFAULT"}, + {"-duration", ".gleidescope.duration", XrmoptionSepArg, "30"}, }; static argtype vars[] = { #ifdef GRAB - {(caddr_t *) &grab, "grab", "Grab", "False", t_Bool}, + {&grab, "grab", "Grab", DEF_GRAB, t_Bool}, #endif - {(caddr_t *) &move, "move", "Move", "False", t_Bool}, - {(caddr_t *) &nomove, "nomove", "noMove", "False", t_Bool}, - {(caddr_t *) &rotate, "rotate", "Rotate", "False", t_Bool}, - {(caddr_t *) &norotate, "norotate", "noRotate", "False", t_Bool}, - /*{(caddr_t *) &size, "size", "Size", "-1", t_Int},*/ - {(caddr_t *) &zoom, "zoom", "Zoom", "False", t_Bool}, - {(caddr_t *) &nozoom, "nozoom", "noZoom", "False", t_Bool}, - {(caddr_t *) &image, "image", "Image", "DEFAULT", t_String}, - {(caddr_t *) &duration, "duration", "Duration", "30", t_Int}, + {&move, "move", "Move", DEF_MOVE, t_Bool}, + {&nomove, "nomove", "noMove", DEF_NOMOVE, t_Bool}, + {&rotate, "rotate", "Rotate", DEF_ROTATE, t_Bool}, + {&norotate, "norotate", "noRotate", DEF_NOROTATE, t_Bool}, + {&zoom, "zoom", "Zoom", DEF_ZOOM, t_Bool}, + {&nozoom, "nozoom", "noZoom", DEF_NOZOOM, t_Bool}, + {&image, "image", "Image", DEF_IMAGE, t_String}, + {&duration, "duration", "Duration", DEF_DURATION, t_Int}, }; static OptionStruct desc[] = { @@ -146,14 +167,13 @@ static OptionStruct desc[] = { {"-no-move", "camera won't move"}, {"-rotate", "camera will rotate"}, {"-no-rotate", "camera won't rotate"}, - /*{"-size", "size of the hexagons (1-10)"},*/ {"-zoom", "camera will zoom"}, {"-no-zoom", "camera won't zoom"}, {"-image", "xpm / xbm image file to use for texture"}, {"-duration", "length of time texture will be used"}, }; -ModeSpecOpt gleidescope_opts = { +ENTRYPOINT ModeSpecOpt gleidescope_opts = { sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc @@ -183,6 +203,25 @@ typedef struct { GLfloat z; } vectorf; +typedef struct { + GLfloat x; + GLfloat y; +} vector2f; + +typedef struct { + GLuint id; /* opengl texture id */ + GLfloat width, height; /* texture width and height */ + GLfloat min_tx, min_ty; /* minimum texture sizes */ + GLfloat max_tx, max_ty; /* maximum texture sizes */ + time_t start_time; + Bool button_down_p; + Bool mipmap_p; + Bool waiting_for_image_p; + /* r_phase is for triangle rotation speed */ + GLfloat x_period, y_period, r_period; + GLfloat x_phase, y_phase, r_phase; +} texture; + #define MAX_FADE 500 /* number of fade cycles */ typedef struct { @@ -191,14 +230,36 @@ typedef struct { float tic; GLXContext *glx_context; Window window; - GLfloat max_tx, max_ty; /* maximum texture sizes */ - GLuint textures[2]; /* texture handles */ - GLuint visible; /* texture handle for new texture */ + texture textures[2]; /* texture handles */ + GLuint visible; /* index for current texture */ GLint fade; time_t start_time; Bool button_down_p; + + int size; + int list; + + float tangle; /* texture angle (degrees) */ + float tangle_vel; /* texture velocity */ + float tangle_acc; /* texture acceleration */ + + float rangle; /* rotate angle */ + float rangle_vel; /* rotate velocity */ + float rangle_acc; /* rotate acceleration */ + + /* mouse */ + int xstart; + int ystart; + double xmouse; + double ymouse; + + Bool mipmap_p; + Bool waiting_for_image_p; + } gleidestruct; +#define frandrange(x, y) (x + frand(y - x)) + #define XOFFSET (0.8660254f) /* sin 60' */ #define YOFFSET (1.5000000f) /* cos 60' + 1 */ @@ -214,9 +275,9 @@ generate_grid(int size) int i, x, y; - size--; + gp->size--; - i = size; + i = gp->size; for (y = -size ; y <= size ; y++) { for (x = -i ; x <= i ; x += 2) { printf("{XOFFSET * %d, YOFFSET * %d, 0},\n", x, y); @@ -232,7 +293,8 @@ generate_grid(int size) } #endif -hex_t hex[] = { +/* acd - this is terrible - 120+ hexes */ +static const hex_t hex[] = { /* edges of size 7 */ /* number of hexagons required to cover screen depends on camera distance */ /* at a distance of 10 this is just about enough. */ @@ -385,10 +447,11 @@ hex_t hex[] = { static gleidestruct *gleidescope = NULL; +#if 0 /* *load defaults in config structure */ -void setdefaultconfig(void) +static void setdefaultconfig(void) { #ifdef GRAB grab = False; @@ -398,13 +461,9 @@ void setdefaultconfig(void) zoom = False; image = NULL; } +#endif -static int xstart; -static int ystart; -static double xmouse = 0.0; -static double ymouse = 0.0; - -Bool +ENTRYPOINT Bool gleidescope_handle_event(ModeInfo *mi, XEvent *event) { gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; @@ -413,15 +472,14 @@ gleidescope_handle_event(ModeInfo *mi, XEvent *event) printf("event:%d\n", event->xany.type); printf("button:%d\n", event->xbutton.button); */ - switch(event->xany.type) - { - case ButtonPress: - - if (event->xbutton.button == Button1 || event->xbutton.button == Button3) + if (event->xany.type == ButtonPress) + { + if (event->xbutton.button == Button1 || + event->xbutton.button == Button3) { /* store initial values of mouse */ - xstart = event->xbutton.x; - ystart = event->xbutton.y; + gp->xstart = event->xbutton.x; + gp->ystart = event->xbutton.y; /* button is down */ gp->button_down_p = True; @@ -439,101 +497,386 @@ gleidescope_handle_event(ModeInfo *mi, XEvent *event) return True; } #endif - break; - - case ButtonRelease: - - if (event->xbutton.button == Button1 || event->xbutton.button == Button3) + } else if (event->xany.type == ButtonRelease) + { + if (event->xbutton.button == Button1 || + event->xbutton.button == Button3) { /* button is up */ gp->button_down_p = False; return True; } - break; - - case MotionNotify: - + } else if (event->xany.type == MotionNotify) + { if (gp->button_down_p) { /* update mouse position */ - xmouse += (double)(event->xmotion.x - xstart) / MI_WIDTH(mi); - ymouse += (double)(event->xmotion.y - ystart) / MI_HEIGHT(mi); - xstart = event->xmotion.x; - ystart = event->xmotion.y; + gp->xmouse += (double)(event->xmotion.x - gp->xstart) / MI_WIDTH(mi); + gp->ymouse += (double)(event->xmotion.y - gp->ystart) / MI_HEIGHT(mi); + gp->xstart = event->xmotion.x; + gp->ystart = event->xmotion.y; return True; } - break; - } + } + else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event)) + { + gp->start_time = -1; + gp->fade = 0; + return True; + } return False; } -#include "grab-ximage.h" static void -getSnapshot(ModeInfo *mi, GLuint name) +image_loaded_cb (const char *filename, XRectangle *geometry, + int image_width, int image_height, + int texture_width, int texture_height, + void *closure) +{ + texture *tp = (texture *) closure; + +#if 0 + gp->max_tx = (GLfloat) image_width / texture_width; + gp->max_ty = (GLfloat) image_height / texture_height; +#endif + + /* new - taken from flipscreen */ + tp->width = texture_width; + tp->height = texture_height; + tp->min_tx = (GLfloat) geometry->x / tp->width; + tp->min_ty = (GLfloat) geometry->y / tp->height; + tp->max_tx = (GLfloat) (geometry->x + geometry->width) / tp->width; + tp->max_ty = (GLfloat) (geometry->y + geometry->height) / tp->height; + +#ifdef DEBUG + printf("Image w,h: (%d, %d)\n", image_width, image_height); + printf("Texture w,h: (%d, %d)\n", texture_width, texture_height); + printf("Geom x,y: (%d, %d)\n", geometry->x, geometry->y); + printf("Geom w,h: (%d, %d)\n", geometry->width, geometry->height); + printf("Max Tx,Ty: (%f, %f)\n", tp->max_tx, tp->max_ty); +#endif + + glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + (tp->mipmap_p ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR)); + + tp->waiting_for_image_p = False; + tp->start_time = time ((time_t *) 0); +} + +static void +getSnapshot(ModeInfo *mi, texture *texture) { - XImage *ximage; - int status; - int tw, th; gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; +#ifdef DEBUG + printf("getSnapshot"); +#endif + if (MI_IS_WIREFRAME(mi)) return; - ximage = screen_to_ximage(mi->xgwa.screen, mi->window, 0); + gp->mipmap_p = True; + load_texture_async (mi->xgwa.screen, mi->window, + *gp->glx_context, 0, 0, gp->mipmap_p, + texture->id, image_loaded_cb, texture); + texture->start_time = time((time_t *)0); +} + +#define TEXTURE_SIZE 256 + +static void +plot(unsigned char *buffer, int x, int y, int r, int g, int b, int a) { + int c; + if (x < 0 || x >= TEXTURE_SIZE || y < 0 || y >= TEXTURE_SIZE) { + return; + } + c = ((x * TEXTURE_SIZE) + y) * 4; + /*printf("(%d,%d)[%d]\n", x, y, c);*/ + buffer[c + 0] = r; + buffer[c + 1] = g; + buffer[c + 2] = b; + buffer[c + 3] = a; +} + +#if 0 +static void +plot2(unsigned char *buffer, int x, int y, int r, int g, int b, int a) { + int c; + if (x < 0 || x >= TEXTURE_SIZE || y < 0 || y >= TEXTURE_SIZE) { + return; + } + c = ((x * TEXTURE_SIZE) + y) * 4; + /*printf("(%d,%d)[%d]\n", x, y, c);*/ + buffer[c + 0] = r; + buffer[c + 1] = g; + buffer[c + 2] = b; + buffer[c + 3] = a; + + if (y + 1 < TEXTURE_SIZE) { + buffer[c + 4] = r; + buffer[c + 5] = g; + buffer[c + 6] = b; + buffer[c + 7] = a; + } + + if (x + 1 < TEXTURE_SIZE) { + c += (TEXTURE_SIZE * 4); + buffer[c + 0] = r; + buffer[c + 1] = g; + buffer[c + 2] = b; + buffer[c + 3] = a; + if (y + 1 < TEXTURE_SIZE) { + buffer[c + 4] = r; + buffer[c + 5] = g; + buffer[c + 6] = b; + buffer[c + 7] = a; + } + } +} +#endif + +/* draw geometric shapes to texture */ +/* modifies passed in buffer */ +static void +draw_shapes (unsigned char *buffer) { + int a = 0xff; + int x, y, w, h; + int i, j; + int s; + float left, right; + + for (i = 0 ; i < TEXTURE_SIZE * TEXTURE_SIZE * 4 ; i += 4) { + buffer[i + 0] = 0x00; + buffer[i + 1] = 0x00; + buffer[i + 2] = 0x00; + buffer[i + 3] = 0xff; + } - tw = mi->xgwa.width; - th = mi->xgwa.height; + for (s = 0 ; s < 25 ; s++) { + int shape = random() % 3; + + /* 8 bits */ + int r = (random() & 0xff); + int g = (random() & 0xff); + int b = (random() & 0xff); + + switch (shape) { + case 0: + /* rectangle */ + x = (random() % TEXTURE_SIZE) - (TEXTURE_SIZE / 4); /* top left */ + y = (random() % TEXTURE_SIZE) - (TEXTURE_SIZE / 4); + w = 10 + random() % (TEXTURE_SIZE / 4); /* size */ + h = 10 + random() % (TEXTURE_SIZE / 4); +#ifdef DEBUG + printf("Rectangle: (%d, %d)(%d, %d)\n", x, y, w, h); +#endif + if (x < 0) { + x = 0; + } + if (y < 0) { + y = 0; + } + for (i = x ; i < x + w && i < TEXTURE_SIZE; i++) { + for (j = y ; j < y + h && j < TEXTURE_SIZE; j++) { + plot(buffer, i, j, r, g, b, a); + } + } + break; + + case 1: + /* circle */ + x = random() % TEXTURE_SIZE; /* centre */ + y = random() % TEXTURE_SIZE; + h = 10 + random() % (TEXTURE_SIZE / 8); /* radius */ +#ifdef DEBUG + printf("Circle: %d, %d, %d\n", x, y, h); +#endif + for (i = 0 ; i < h ; i++) { + int xdist = i * i; + for (j = 0 ; j < h ; j++) { + int ydist = j * j; + /* + printf("xdist: %d\n", xdist); + printf("ydist: %d\n", ydist); + printf("radius: %d\n", h * h); + */ + if ((xdist + ydist) < (h * h)) { + plot(buffer, x + i, y + j, r, b, g, a); + /* check we haven't already done these */ + if (j != 0) { + plot(buffer, x + i, y - j, r, b, g, a); + } + if (i != 0) { + plot(buffer, x - i, y + j, r, b, g, a); + if (j != 0) { + plot(buffer, x - i, y - j, r, b, g, a); + } + } + } + } + } + break; + + case 2: + /* triangle */ + x = random() % TEXTURE_SIZE; /* top */ + y = random() % TEXTURE_SIZE; + h = 10 + random() % (TEXTURE_SIZE / 4); /* height */ +#ifdef DEBUG + printf("Triangle: %d, %d, %d\n", x, y, h); +#endif + left = x; + right = x; + for (i = 0 ; i < h ; i++) { + for (j = left ; j < right ; j++) { + plot(buffer, j, y + i, r, g, b, a); + } + left -= .5; + right += .5; + } + break; + } + } +} - gp->max_tx = (GLfloat) tw / (GLfloat) ximage->width; - gp->max_ty = (GLfloat) th / (GLfloat) ximage->height; +static void +setup_random_texture (ModeInfo *mi, texture *texture) +{ + int width = 0, height = 0; + char buf[1024]; + unsigned char *my_data = NULL; +#if 0 + int i, j, c; + int style; + int r0, g0, b0, a0, r1, g1, b1, a1; +#endif - glBindTexture (GL_TEXTURE_2D, name); +#ifdef DEBUG + printf("RandomTexture\n"); +#endif - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, - GL_LINEAR_MIPMAP_LINEAR); + /* use this texture */ + glBindTexture(GL_TEXTURE_2D, texture->id); clear_gl_error(); - status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, - ximage->width, ximage->height, - GL_RGBA, GL_UNSIGNED_BYTE, ximage->data); - if (!status && glGetError()) - /* Some implementations of gluBuild2DMipmaps(), but set a GL error anyway. - ** We could just call check_gl_error(), but that would exit. */ - status = -1; + /* + * code for various generated patterns - noise, stripes, checks etc. + * random geometric shapes looked the best. + */ - if (status) - { - const GLubyte *s = gluErrorString (status); - if (s) - { - fprintf (stderr, "%s: error mipmapping %dx%d texture: %s\n", - progname, ximage->width, ximage->height, s); - } - else - { - fprintf (stderr, "%s: error mipmapping %dx%d texture: (unknown)\n", - progname, ximage->width, ximage->height); - } - clear_gl_error(); +#if 0 + style = random() & 0x3; + r0 = random() & 0xff; + g0 = random() & 0xff; + b0 = random() & 0xff; + a0 = 0xff; + r1 = random() & 0xff; + g1 = random() & 0xff; + b1 = random() & 0xff; + a1 = 0xff; + + switch (style) { + case 0: /* random */ + printf("Random0\n"); + height = width = TEXTURE_SIZE; + my_data = (void *)malloc(width * height * 4); + for (i = 0 ; i < width ; i += 2) { + for (j = 0 ; j < height ; j += 2) { + r0 = random() & 0xff; + g0 = random() & 0xff; + b0 = random() & 0xff; + a0 = 0xff; + plot2(my_data, i, j, r0, g0, b0, a0); + } + } + break; + + case 1: /* shapes */ +#endif +#ifdef DEBUG + printf("Shapes\n"); +#endif + height = width = TEXTURE_SIZE; + my_data = (void *)malloc(width * height * 4); + draw_shapes(my_data); +#if 0 + break; + + case 2: /* check */ + printf("Check\n"); + height = width = TEXTURE_SIZE; + my_data = (void *)malloc(width * height * 4); + for (i = 0 ; i < height ; i += 2) { + for (j = 0 ; j < width ; j += 2) { + if (((i + j) & 0x3) == 0) { + plot2(my_data, i, j, r0, g0, b0, a0); + } else { + plot2(my_data, i, j, r1, g1, b1, a1); + } + } + } + break; + + case 3: /* random stripes */ + printf("Stripes 2\n"); + height = width = TEXTURE_SIZE; + my_data = (void *)malloc(width * height * 4); + for (i = 0 ; i < height ; i += 2) { + r0 = random() & 0xff; + g0 = random() & 0xff; + b0 = random() & 0xff; + a0 = 0xff; + for (j = 0 ; j < width ; j += 2) { + plot2(my_data, i, j, r0, g0, b0, a0); + } + } + break; + } +#endif + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, + width, height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, my_data); + sprintf (buf, "random texture: (%dx%d)", + width, height); + check_gl_error(buf); + + /* setup parameters for texturing */ + glPixelStorei(GL_UNPACK_ALIGNMENT, 4); + glPixelStorei(GL_UNPACK_ROW_LENGTH, width); + + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + if (random() & 0x1) { + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + } else { + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } - check_gl_error("mipmapping"); /* should get a return code instead of a - GL error, but just in case... */ - free(ximage->data); - ximage->data = 0; - XDestroyImage (ximage); + if (my_data != NULL) { + free(my_data); + my_data = NULL; + } - /* remember time of last image change */ - gp->start_time = time ((time_t *) 0); + /* use full texture */ + /* acd - was 1.0 */ + texture->min_tx = 0.0; + texture->max_tx = 2.0; + texture->min_ty = 0.0; + texture->max_ty = 2.0; + texture->start_time = time((time_t *)0); } static void -setup_file_texture (ModeInfo *mi, char *filename, GLuint name) +setup_file_texture (ModeInfo *mi, char *filename, texture *texture) { Display *dpy = mi->dpy; Visual *visual = mi->xgwa.visual; @@ -542,8 +885,12 @@ setup_file_texture (ModeInfo *mi, char *filename, GLuint name) Colormap cmap = mi->xgwa.colormap; XImage *image = xpm_file_to_ximage (dpy, visual, cmap, filename); +#ifdef DEBUG + printf("FileTexture\n"); +#endif + /* use this texture */ - glBindTexture(GL_TEXTURE_2D, name); + glBindTexture(GL_TEXTURE_2D, texture->id); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, @@ -562,32 +909,62 @@ setup_file_texture (ModeInfo *mi, char *filename, GLuint name) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + + /* use full texture */ + texture->min_tx = 0.0; + texture->max_tx = 1.0; + texture->min_ty = 0.0; + texture->max_ty = 1.0; + texture->start_time = time((time_t *)0); } static void -setup_texture(ModeInfo * mi, GLuint id) +setup_texture(ModeInfo * mi, texture *texture) { gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; if (!image || !*image || !strcmp(image, "DEFAULT")) { - /* no image specified - grab screen */ - getSnapshot(mi, id); - /* max_tx and max_ty set in getSnapshot() */ + /* no image specified - use system settings */ +#ifdef DEBUG + printf("SetupTexture: get_snapshot\n"); +#endif + getSnapshot(mi, texture); } else { - /* use supplied image file */ - setup_file_texture(mi, image, id); - - /* set tx params to use whole image */ - gp->max_tx = 1.0f; - gp->max_ty = 1.0f; + if (strcmp(image, "GENERATE") == 0) { +#ifdef DEBUG + printf("SetupTexture: random_texture\n"); +#endif + setup_random_texture(mi, texture); + } else { + /* use supplied image file */ +#ifdef DEBUG + printf("SetupTexture: file_texture\n"); +#endif + setup_file_texture(mi, image, texture); + } } + /* copy start time from texture */ + gp->start_time = texture->start_time; check_gl_error("texture initialization"); - /* Need to flip the texture top for bottom for some reason. */ - glMatrixMode (GL_TEXTURE); - glScalef (1, -1, 1); - glMatrixMode (GL_MODELVIEW); + /* acd + * resultant loaded image is upside down BUT + * it's a kaledescope and half of the hexagon is backwards anyway... + */ + + /* TODO: values for lissajous movement */ + texture->x_period = frandrange(-2.0, 2.0); + texture->y_period = frandrange(-2.0, 2.0); + texture->r_period = frandrange(-2.0, 2.0); + texture->x_phase = frand(M_PI * 2); + texture->y_phase = frand(M_PI * 2); + texture->r_phase = frand(M_PI * 2); +#ifdef DEBUG + printf("XPeriod %f XPhase %f\n", texture->x_period, texture->x_phase); + printf("YPeriod %f YPhase %f\n", texture->y_period, texture->y_phase); + printf("RPeriod %f RPhase %f\n", texture->r_period, texture->r_phase); +#endif } #define VERTEX0 glVertex3f( 0.0000f, 0.000f, 0.0f); @@ -598,99 +975,226 @@ setup_texture(ModeInfo * mi, GLuint id) #define VERTEX5 glVertex3f(-XOFFSET, -0.500f, 0.0f); #define VERTEX6 glVertex3f(-XOFFSET, 0.500f, 0.0f); +/* +** Three different functions for calculating texture coordinates +** which modify how the texture triangle moves over the source image. +** Choose one. +*/ + +#if 0 +/* the classic equilateral triangle rotating around centre */ +static void +calculate_texture_coords(ModeInfo *mi, texture *texture, vector2f t[3]) { + + gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; + GLfloat centre_x = 0.5; + GLfloat centre_y = 0.5; + GLfloat radius_x = (texture->max_tx - texture->min_tx) / 2; + GLfloat radius_y = (texture->max_ty - texture->min_ty) / 2; + GLfloat tangle2; + t[0].x = centre_x; + t[0].y = centre_y; + + /* t[1] */ + t[1].x = centre_x + .95 * radius_x * cos((gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS)); + t[1].y = centre_y + .95 * radius_y * sin((gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS)); + + /* t[2] is always 60' further around than t2 */ + tangle2 = (gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS) + (M_PI * 2 / 6); + t[2].x = centre_x + .95 * radius_x * cos(tangle2); + t[2].y = centre_y + .95 * radius_y * sin(tangle2); +#if 0 + printf("texcoords:[%f,%f]->[%f,%f](%f,%f)\n", t[0].x, t[0].y, t[1].x, t[1].y, texture->max_tx, texture->max_ty); +#endif +} +#endif + +#if 1 +/* new lissajous movement pattern */ static void -draw_hexagons(ModeInfo *mi, int translucency, GLuint texture) +calculate_texture_coords(ModeInfo *mi, texture *texture, vector2f t[3]) { + + /* equilateral triangle rotating around centre */ + gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; + GLfloat width = texture->max_tx - texture->min_tx; + GLfloat height = texture->max_ty - texture->min_ty; + /* centre */ + GLfloat centre_x = texture->min_tx + (width * .5); + GLfloat centre_y = texture->min_ty + (height * .5); + /* m radius and t radius should be = .5 */ + /* triangle radius is 30% available space */ + GLfloat t_radius_x = width * .3; + GLfloat t_radius_y = height * .3; + /* movement radius is 30% available space */ + GLfloat m_radius_x = width * .2; + GLfloat m_radius_y = height * .2; + GLfloat angle2; + + /* centre of triangle */ + GLfloat angle = (gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS); /* to radians */ + GLfloat t_centre_x = centre_x + m_radius_x * cos(texture->x_period * angle + texture->x_phase); + GLfloat t_centre_y = centre_y + m_radius_y * sin(texture->y_period * angle + texture->y_phase); + +#if 0 + printf("WH: %f, %f - tWH: %f, %f\n", width, height, texture->width, texture->height); + printf("size: (%f, %f)\n", width, height); + printf("centre: (%f, %f)\n", centre_x, centre_y); +#endif + + angle2 = texture->r_period * angle + texture->r_phase; + t[0].x = t_centre_x + t_radius_x * cos(angle2); + t[0].y = t_centre_y + t_radius_y * sin(angle2); + t[1].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_120); + t[1].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_120); + t[2].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_240); + t[2].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_240); + +#if 0 + printf("texcoords:[%f,%f]->[%f,%f](%f,%f)\n", t[0].x, t[0].y, t[1].x, t[1].y, texture->max_tx, texture->max_ty); +#endif +} +#endif + +#if 0 +/* corners into corners - meant to maximise coverage */ +static void +calculate_texture_coords(ModeInfo *mi, texture *texture, vector2f t[3]) { + + /* equilateral triangle rotating around centre */ + gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; + GLfloat width = texture->max_tx - texture->min_tx; + GLfloat height = texture->max_ty - texture->min_ty; + /* centre */ + GLfloat centre_x = texture->min_tx + (width * .5); + GLfloat centre_y = texture->min_ty + (height * .5); + /* m radius and t radius should be = .5 */ + /* triangle radius calculated using maths 8) */ +#define TRADIUS (M_SQRT2 - 1.0) +#define MRADIUS (1.0 - (M_SQRT2 / 2.0)) + GLfloat t_radius_x = width * TRADIUS * .95; + GLfloat t_radius_y = height * TRADIUS * .95; + /* movement radius also calculated using maths */ + GLfloat m_radius_x = width * MRADIUS * .95; + GLfloat m_radius_y = height * MRADIUS * .95; + GLfloat angle, angle2; + GLfloat t_centre_x, t_centre_y; + + /* centre of triangle */ + angle = gp->tangle * RADIANS; /* to radians */ + t_centre_x = centre_x + m_radius_x * cos(angle); + t_centre_y = centre_y + m_radius_y * sin(angle); +#if 0 + printf("angle: %f, %f\n", angle, gp->tangle); + printf("tcentre: %f,%f\n", t_centre_x, t_centre_y); + printf("tradius: %f,%f\n", t_radius_x, t_radius_y); + + printf("size: (%f, %f)\n", width, height); + printf("centre: (%f, %f)\n", centre_x, centre_y); + printf("centre: (%f, %f)\n", centre_x, centre_y); + printf("TRADIUS: %f\n", TRADIUS); + printf("MRADIUS: %f\n", MRADIUS); +#endif + + /* angle2 is tied to tangle */ + angle2 = (180.0 - ((30.0 / 90.0) * gp->tangle)) * RADIANS; +#if 0 + printf("Angle1: %f\tAngle2: %f\n", angle / RADIANS, angle2 / RADIANS); +#endif + t[0].x = t_centre_x + t_radius_x * cos(angle2); + t[0].y = t_centre_y + t_radius_y * sin(angle2); + t[1].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_120); + t[1].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_120); + t[2].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_240); + t[2].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_240); + +#if 0 + printf("texcoords:[%f,%f][%f,%f][%f,%f]\n", t[0].x, t[0].y, t[1].x, t[1].y, t[2].x, t[2].y); +#endif +} +#endif + +static int +draw_hexagons(ModeInfo *mi, int translucency, texture *texture) { + int polys = 0; int i; - GLfloat col[4]; - GLfloat t1x, t1y, t2x, t2y, t3x, t3y; + vector2f t[3]; gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; - GLfloat tangle2; - col[0] = 1.0; - col[1] = 1.0; - col[2] = 1.0; - col[3] = (float)translucency / MAX_FADE; - - /* calculate vertices of equilateral triangle within image. */ - /* t1 is always in centre */ - t1x = gp->max_tx / 2; - t1y = gp->max_ty / 2; - /* t2 rotates */ - t2x = (gp->max_tx / 2) * (1 + cos((ymouse * 2 * M_PI) + (tangle * M_PI / 180))); - t2y = (gp->max_ty / 2) * (1 + sin((ymouse * 2 * M_PI) + (tangle * M_PI / 180))); - /* t3 is always 60' further around than t2 */ - tangle2 = (ymouse * 2 * M_PI) + (tangle * M_PI / 180) + (M_PI * 2 / 6); - t3x = (gp->max_tx / 2) * (1 + (cos(tangle2))); - t3y = (gp->max_ty / 2) * (1 + (sin(tangle2))); - /* NB image is flipped vertically hence: */ - t1y = 1 - t1y; - t2y = 1 - t2y; - t3y = 1 - t3y; - /*printf("texcoords:[%f,%f]->[%f,%f](%f,%f)\n", t1x, t1y, t2x, t2y, gp->max_tx, gp->max_ty);*/ + calculate_texture_coords(mi, texture, t); glColor4f(1.0, 1.0, 1.0, (float)translucency / MAX_FADE); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDepthMask(GL_FALSE); - glBindTexture(GL_TEXTURE_2D, gp->textures[texture]); + glBindTexture(GL_TEXTURE_2D, texture->id); + + if (gp->list == -1) { + gp->list = glGenLists(1); + } + /* compile new list */ + glNewList(gp->list, GL_COMPILE); + glBegin(GL_TRIANGLES); + + /* + ** six triangles to each hexagon + */ + + glTexCoord2f(t[0].x, t[0].y); + VERTEX0; + glTexCoord2f(t[1].x, t[1].y); + VERTEX1; + glTexCoord2f(t[2].x, t[2].y); + VERTEX6; + + glTexCoord2f(t[0].x, t[0].y); + VERTEX0; + glTexCoord2f(t[2].x, t[2].y); + VERTEX6; + glTexCoord2f(t[1].x, t[1].y); + VERTEX5; + + glTexCoord2f(t[0].x, t[0].y); + VERTEX0; + glTexCoord2f(t[1].x, t[1].y); + VERTEX5; + glTexCoord2f(t[2].x, t[2].y); + VERTEX4; + + glTexCoord2f(t[0].x, t[0].y); + VERTEX0; + glTexCoord2f(t[2].x, t[2].y); + VERTEX4; + glTexCoord2f(t[1].x, t[1].y); + VERTEX3; + + glTexCoord2f(t[0].x, t[0].y); + VERTEX0; + glTexCoord2f(t[1].x, t[1].y); + VERTEX3; + glTexCoord2f(t[2].x, t[2].y); + VERTEX2; + + glTexCoord2f(t[0].x, t[0].y); + VERTEX0; + glTexCoord2f(t[2].x, t[2].y); + VERTEX2; + glTexCoord2f(t[1].x, t[1].y); + VERTEX1; + + glEnd(); + glEndList(); + + /* call the list n times */ for (i = 0 ; i < sizeof(hex) / sizeof(hex[0]) ; i++) { glPushMatrix(); glTranslatef(hex[i].x, hex[i].y, 0.0); - - glBegin(GL_TRIANGLES); - - /* - ** six triangles to each hexagon - */ - - glTexCoord2f(t1x, t1y); - VERTEX0; - glTexCoord2f(t2x, t2y); - VERTEX1; - glTexCoord2f(t3x, t3y); - VERTEX6; - - glTexCoord2f(t1x, t1y); - VERTEX0; - glTexCoord2f(t3x, t3y); - VERTEX6; - glTexCoord2f(t2x, t2y); - VERTEX5; - - glTexCoord2f(t1x, t1y); - VERTEX0; - glTexCoord2f(t2x, t2y); - VERTEX5; - glTexCoord2f(t3x, t3y); - VERTEX4; - - glTexCoord2f(t1x, t1y); - VERTEX0; - glTexCoord2f(t3x, t3y); - VERTEX4; - glTexCoord2f(t2x, t2y); - VERTEX3; - - glTexCoord2f(t1x, t1y); - VERTEX0; - glTexCoord2f(t2x, t2y); - VERTEX3; - glTexCoord2f(t3x, t3y); - VERTEX2; - - glTexCoord2f(t1x, t1y); - VERTEX0; - glTexCoord2f(t3x, t3y); - VERTEX2; - glTexCoord2f(t2x, t2y); - VERTEX1; - - glEnd(); + glCallList(gp->list); + polys += 6; glPopMatrix(); } @@ -709,13 +1213,15 @@ draw_hexagons(ModeInfo *mi, int translucency, GLuint texture) glVertex3f(1.0, 1.0, -0.1); glTexCoord2f(0.0, 1.0); glVertex3f(0.0, 1.0, -0.1); + polys++; glEnd(); /* acd debug - display texture triangle */ - glColor4f(1.0, 1.0, 1.0, 1.0); + glColor4f(1.0, 0.5, 1.0, 1.0); glBegin(GL_LINE_LOOP); - glVertex3f(t1x, t1y, -0.11); - glVertex3f(t2x, t2y, -0.11); - glVertex3f(t3x, t3y, -0.11); + glVertex3f(t[0].x, t[0].y, -0.11); + glVertex3f(t[1].x, t[1].y, -0.11); + glVertex3f(t[2].x, t[2].y, -0.11); + polys++; glEnd(); glPopMatrix(); #endif @@ -723,6 +1229,7 @@ draw_hexagons(ModeInfo *mi, int translucency, GLuint texture) glDisable(GL_TEXTURE_2D); glDepthMask(GL_TRUE); glDisable(GL_BLEND); + return polys; } /* @@ -734,9 +1241,9 @@ draw(ModeInfo * mi) GLfloat x_angle, y_angle, z_angle; gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; vectorf v1; - GLfloat pos[4]; - glClearColor(0.5, 0.5, 0.5, 1.0); + mi->polygon_count = 0; + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); @@ -747,27 +1254,27 @@ draw(ModeInfo * mi) z_angle = gp->cam_z_phase + gp->tic * gp->cam_z_speed; if (move) { - v1.x = 2 * sin(x_angle); - v1.y = 2 * sin(y_angle); + v1.x = 1 * sin(x_angle); + v1.y = 1 * sin(y_angle); } else { v1.x = 0; v1.y = 0; } /* size is changed in pinit() to be distance from plane */ - size = MI_SIZE(mi); - if (size > 10) { - size = 10; + gp->size = MI_SIZE(mi); + if (gp->size > 10) { + gp->size = 10; } - if (size < -1) { - size = -1; + if (gp->size <= 0) { + gp->size = 0; } - if (size != -1) { + if (gp->size > 0) { /* user defined size */ - v1.z = size; + v1.z = gp->size; } else if (zoom) { /* max distance given by adding the constant and the multiplier */ - v1.z = 5.0 + 4.0 * sin(z_angle); + v1.z = 5.0 + 3.0 * sin(z_angle); } else { /* default */ v1.z = 7.0; @@ -779,20 +1286,26 @@ draw(ModeInfo * mi) float new_rangle_vel = 0.0; /* update camera rotation angle and velocity */ - rangle += rangle_vel; - new_rangle_vel = rangle_vel + rangle_acc; - if (new_rangle_vel > -MAX_RANGLE_VEL && new_rangle_vel < MAX_RANGLE_VEL) + gp->rangle += gp->rangle_vel; + new_rangle_vel = gp->rangle_vel + gp->rangle_acc; + if (new_rangle_vel > -MAX_ANGLE_VEL && new_rangle_vel < MAX_ANGLE_VEL) { /* new velocity is within limits */ - rangle_vel = new_rangle_vel; + gp->rangle_vel = new_rangle_vel; } - /* randomly change twisting speed */ - if ((random() % 1000) < 1) - { - rangle_acc = frand(0.002) - 0.001; + /* randomly change twisting speed - 3ff = 1024 */ + if ((random() % TWISTING_PROBABILITY) < 1.0) { + gp->rangle_acc = INITIAL_ANGLE_ACC * frand(1.0); + if (gp->rangle_vel > 0.0) { + gp->rangle_acc = -gp->rangle_acc; + } } } +#if 0 + printf("Rangle: %f : %f : %f\n", gp->rangle, gp->rangle_vel, gp->rangle_acc); + printf("Tangle: %f : %f : %f\n", gp->tangle, gp->tangle_vel, gp->tangle_acc); +#endif #ifdef WOBBLE /* this makes the image wobble - requires -move and a larger grid */ @@ -804,27 +1317,34 @@ draw(ModeInfo * mi) gluLookAt( v1.x, v1.y, v1.z, v1.x, v1.y, 0.0, - sin((xmouse * M_PI * 2) + rangle * M_PI / 180), - cos((xmouse * M_PI * 2) + rangle * M_PI / 180), + sin((gp->xmouse * M_PI * 2) + gp->rangle * RADIANS), + cos((gp->xmouse * M_PI * 2) + gp->rangle * RADIANS), 0.0); #endif - /* light position same as camera */ - pos[0] = v1.x; - pos[1] = v1.y; - pos[2] = v1.z; - pos[3] = 0; +# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */ + { + GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi); + int o = (int) current_device_rotation(); + if (o != 0 && o != 180 && o != -180) + glScalef (1/h, 1/h, 1/h); + } +# endif if (gp->fade == 0) { /* not fading */ - draw_hexagons(mi, MAX_FADE, gp->visible); + mi->polygon_count += + draw_hexagons(mi, MAX_FADE, &gp->textures[gp->visible]); } else { - /* fading - show both textures with alpha */ - draw_hexagons(mi, MAX_FADE - gp->fade, gp->visible); - draw_hexagons(mi, gp->fade, 1 - gp->visible); + /* fading - show both textures with alpha + NB first is always max alpha */ + mi->polygon_count += + draw_hexagons(mi, MAX_FADE, &gp->textures[1 - gp->visible]); + mi->polygon_count += + draw_hexagons(mi, MAX_FADE - gp->fade, &gp->textures[gp->visible]); /* fade some more */ gp->fade++; @@ -844,20 +1364,22 @@ draw(ModeInfo * mi) { float new_tangle_vel = 0.0; - tangle += tangle_vel; + gp->tangle += gp->tangle_vel; /* work out new texture angle velocity */ - new_tangle_vel = tangle_vel + tangle_acc; - if (new_tangle_vel > -MAX_TANGLE_VEL && new_tangle_vel < MAX_TANGLE_VEL) + new_tangle_vel = gp->tangle_vel + gp->tangle_acc; + if (new_tangle_vel > -MAX_ANGLE_VEL && new_tangle_vel < MAX_ANGLE_VEL) { /* new velocity is inside limits */ - tangle_vel = new_tangle_vel; + gp->tangle_vel = new_tangle_vel; } - /* randomly change texture angle acceleration */ - if ((random() % 1000) < 1) - { - tangle_acc = frand(0.002) - 0.001; + /* randomly change twisting speed - 3ff = 1024 */ + if ((random() % TWISTING_PROBABILITY) < 1.0) { + gp->tangle_acc = INITIAL_ANGLE_ACC * frand(1.0); + if (gp->tangle_vel > 0.0) { + gp->tangle_acc = -gp->tangle_acc; + } } } @@ -867,7 +1389,7 @@ draw(ModeInfo * mi) /* * new window size or exposure */ -void reshape_gleidescope(ModeInfo *mi, int width, int height) +ENTRYPOINT void reshape_gleidescope(ModeInfo *mi, int width, int height) { GLfloat h = (GLfloat) height / (GLfloat) width; @@ -876,7 +1398,6 @@ void reshape_gleidescope(ModeInfo *mi, int width, int height) glLoadIdentity(); gluPerspective(50.0, 1/h, 0.1, 2000.0); glMatrixMode (GL_MODELVIEW); - glLineWidth(1); glPointSize(1); } @@ -890,8 +1411,10 @@ pinit(ModeInfo * mi) gp->start_time = (time_t)0; /* set the texture size to default */ + /* gp->max_tx = 1.0; gp->max_ty = 1.0; + */ /* no fading */ gp->fade = 0; @@ -903,11 +1426,11 @@ pinit(ModeInfo * mi) glDisable(GL_LIGHTING); /* space for textures */ - glGenTextures(1, &gp->textures[0]); - glGenTextures(1, &gp->textures[1]); + glGenTextures(1, &gp->textures[0].id); + glGenTextures(1, &gp->textures[1].id); gp->visible = 0; - setup_texture(mi, gp->textures[gp->visible]); + setup_texture(mi, &gp->textures[gp->visible]); /* ** want to choose a value for arg randomly if neither -arg nor -no-arg @@ -951,40 +1474,42 @@ pinit(ModeInfo * mi) } /* define cam variables */ - gp->cam_x_speed = frand(3.0) - 1.5; + gp->cam_x_speed = MAX_CAM_SPEED * frandrange(-.5, 0.5); gp->cam_x_phase = random() % 360; - gp->cam_y_speed = frand(3.0) - 1.5; + gp->cam_y_speed = MAX_CAM_SPEED * frandrange(-.5, 0.5); gp->cam_y_phase = random() % 360; - gp->cam_z_speed = frand(3.0) - 1.5; + gp->cam_z_speed = MAX_CAM_SPEED * frandrange(-.5, 0.5); gp->cam_z_phase = random() % 360; /* initial angular speeds */ - rangle_vel = frand(0.2) - 0.1; - tangle_vel = frand(0.2) - 0.1; - rangle_acc = frand(0.002) - 0.001; - tangle_acc = frand(0.002) - 0.001; + gp->rangle_vel = INITIAL_ANGLE_VEL * frandrange(-.5, 0.5); + gp->tangle_vel = INITIAL_ANGLE_VEL * frandrange(-.5, 0.5); + gp->rangle_acc = INITIAL_ANGLE_ACC * frandrange(-.5, 0.5); + gp->tangle_acc = INITIAL_ANGLE_ACC * frandrange(-.5, 0.5); /* jwz */ +#if 0 { GLfloat speed = 15; - rangle_vel *= speed; - tangle_vel *= speed; - rangle_acc *= speed; - tangle_acc *= speed; + gp->rangle_vel *= speed; + gp->tangle_vel *= speed; + gp->rangle_acc *= speed; + gp->tangle_acc *= speed; } +#endif /* distance is 11 - size */ - if (size != -1) { + if (gp->size != -1) { if (zoom) { fprintf(stderr, "-size given. ignoring -zoom.\n"); zoom = False; } - if (size < 1) { - size = 1; - } else if (size >= 10) { - size = 10; + if (gp->size < 1) { + gp->size = 1; + } else if (gp->size >= 10) { + gp->size = 10; } - size = 11 - size; + gp->size = 11 - gp->size; } #ifdef DEBUG @@ -992,13 +1517,12 @@ printf("phases [%d, %d, %d]\n", gp->cam_x_phase, gp->cam_y_phase, gp->cam_z_phas #endif } -void +ENTRYPOINT void init_gleidescope(ModeInfo * mi) { gleidestruct *gp; int screen = MI_SCREEN(mi); - if (gleidescope == NULL) { gleidescope = (gleidestruct *) calloc(MI_NUM_SCREENS(mi), sizeof (gleidestruct)); if (gleidescope == NULL) { @@ -1007,10 +1531,13 @@ init_gleidescope(ModeInfo * mi) } gp = &gleidescope[screen]; gp->window = MI_WINDOW(mi); + gp->size = -1; + gp->list = -1; if ((gp->glx_context = init_GL(mi)) != NULL) { reshape_gleidescope(mi, MI_WIDTH(mi), MI_HEIGHT(mi)); + clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ glDrawBuffer(GL_BACK); @@ -1022,7 +1549,7 @@ init_gleidescope(ModeInfo * mi) } } -void +ENTRYPOINT void draw_gleidescope(ModeInfo * mi) { gleidestruct *gp = &gleidescope[MI_SCREEN(mi)]; @@ -1033,6 +1560,9 @@ draw_gleidescope(ModeInfo * mi) if (!gp->glx_context) return; + /* Just keep running before the texture has come in. */ + /* if (gp->waiting_for_image_p) return; */ + glDrawBuffer(GL_BACK); glXMakeCurrent(display, window, *(gp->glx_context)); @@ -1047,21 +1577,26 @@ draw_gleidescope(ModeInfo * mi) #ifdef GRAB if (grab) { - grab_frame(mi); + grab_frame(display, window); } #endif /* need to change texture? */ if ((gp->start_time != 0) && (duration != -1) && gp->fade == 0) { if (gp->start_time + duration <= time((time_t *)0)) { +#ifdef DEBUG + printf("Start Time: %lu - Current Time: %lu\n", (unsigned long)gp->start_time, (unsigned long)time((time_t *)0)); + printf("Changing Texture\n"); +#endif /* get new snapshot (into back buffer) and start fade count */ - getSnapshot(mi, gp->textures[1 - gp->visible]); + setup_texture(mi, &gp->textures[1 - gp->visible]); + /* restart fading */ gp->fade = 1; } } } -void +ENTRYPOINT void release_gleidescope(ModeInfo * mi) { if (gleidescope != NULL) { @@ -1085,4 +1620,6 @@ release_gleidescope(ModeInfo * mi) FreeAllGL(mi); } +XSCREENSAVER_MODULE ("Gleidescope", gleidescope) + #endif