1 /* mirrorblob Copyright (c) 2003 Jon Dowdall <jon.dowdall@bigpond.com> */
3 * Permission to use, copy, modify, and distribute this software and its
4 * documentation for any purpose and without fee is hereby granted,
5 * provided that the above copyright notice appear in all copies and that
6 * both that copyright notice and this permission notice appear in
7 * supporting documentation.
9 * This file is provided AS IS with no warranties of any kind. The author
10 * shall have no liability with respect to the infringement of copyrights,
11 * trade secrets or any patents by this file or any part thereof. In no
12 * event will the author be liable for any lost revenue or profits or
13 * other special, indirect and consequential damages.
16 * 23-Sep-2003: jon.dowdall@bigpond.com Created module "blob"
17 * 19-Oct-2003: jon.dowdall@bigpond.com Added texturing
18 * 21-Oct-2003: Renamed to mirrorblob
19 * 10-Feb-2004: jon.dowdall@bigpond.com Added motion blur
20 * 28-Jan-2006: jon.dowdall@bigpond.com Big clean up and bug fixes
21 * 13-Apr-2009: jon.dowdall@gmail.com Fixed Mac version
23 * The mirrorblob screensaver draws a pulsing blob on the screen. Options
24 * include adding a background (via screen_to_texture), texturing the blob,
25 * making the blob semi-transparent and varying the resolution of the blob
28 * The blob was inspired by a lavalamp is in no way a simulation. The code is
29 * just an attempt to generate some eye-candy.
31 * Much of xmirrorblob code framework is taken from the pulsar module by David
32 * Konerding and the glslideshow by Mike Oliphant and Jamie Zawinski.
39 #define DEFAULTS "*delay: " DEF_DELAY "\n" \
40 "*showFPS: " DEF_FPS "\n" \
42 "*desktopGrabber: xscreensaver-getimage -no-desktop %s\n" \
43 "*grabDesktopImages: True \n" \
44 "*chooseRandomImages: True \n" \
45 "*suppressRotationAnimation: True\n" \
47 # define refresh_mirrorblob 0
48 # define release_mirrorblob 0
49 # include "xlockmore.h"
50 #else /* !STANDALONE */
51 # include "xlock.h" /* from the xlockmore distribution */
52 #endif /* !STANDALONE */
54 #ifdef USE_GL /* whole file */
57 #define DEF_DELAY "10000"
58 #define DEF_FPS "False"
59 #define DEF_WIRE "False"
60 #define DEF_BLEND "1.0"
61 #define DEF_FOG "False"
62 #define DEF_ANTIALIAS "False"
63 #define DEF_WALLS "False"
64 #define DEF_COLOUR "False"
65 #define DEF_ASYNC "True"
66 #define DEF_TEXTURE "True"
67 #define DEF_OFFSET_TEXTURE "False"
68 #define DEF_PAINT_BACKGROUND "True"
69 #define DEF_RESOLUTION "30"
70 #define DEF_BUMPS "10"
71 #define DEF_MOTION_BLUR "0.0"
72 #define DEF_INCREMENTAL "0"
73 #define DEF_HOLD_TIME "30.0"
74 #define DEF_FADE_TIME "5.0"
75 #define DEF_ZOOM "1.0"
79 # include <X11/Xmu/Drawing.h>
81 # include <Xmu/Drawing.h>
85 #include "gltrackball.h"
86 #include "grab-ximage.h"
89 #define countof(x) (sizeof((x)) / sizeof((*x)))
91 #define PI 3.1415926535897
93 /* Options from command line */
95 static Bool wireframe;
97 static Bool do_antialias;
99 static Bool do_texture;
100 static Bool do_paint_background;
101 static Bool do_colour;
102 static Bool offset_texture;
103 static int resolution;
105 static float motion_blur;
106 static float fade_time;
107 static float hold_time;
110 /* Internal parameters based on supplied options */
112 static Bool load_textures;
114 static XrmOptionDescRec opts[] = {
115 {"-wire", ".blob.wire", XrmoptionNoArg, "true" },
116 {"+wire", ".blob.wire", XrmoptionNoArg, "false" },
117 {"-blend", ".blob.blend", XrmoptionSepArg, 0 },
118 {"-fog", ".blob.fog", XrmoptionNoArg, "true" },
119 {"+fog", ".blob.fog", XrmoptionNoArg, "false" },
120 {"-antialias", ".blob.antialias", XrmoptionNoArg, "true" },
121 {"+antialias", ".blob.antialias", XrmoptionNoArg, "false" },
122 {"-walls", ".blob.walls", XrmoptionNoArg, "true" },
123 {"+walls", ".blob.walls", XrmoptionNoArg, "false" },
124 {"-texture", ".blob.texture", XrmoptionNoArg, "true" },
125 {"+texture", ".blob.texture", XrmoptionNoArg, "false" },
126 {"-colour", ".blob.colour", XrmoptionNoArg, "true" },
127 {"+colour", ".blob.colour", XrmoptionNoArg, "false" },
128 {"-offset-texture", ".blob.offsetTexture", XrmoptionNoArg, "true" },
129 {"+offset-texture", ".blob.offsetTexture", XrmoptionNoArg, "false" },
130 {"-paint-background", ".blob.paintBackground", XrmoptionNoArg, "true" },
131 {"+paint-background", ".blob.paintBackground", XrmoptionNoArg, "false" },
132 {"-resolution", ".blob.resolution", XrmoptionSepArg, NULL },
133 {"-bumps", ".blob.bumps", XrmoptionSepArg, NULL },
134 {"-motion-blur", ".blob.motionBlur", XrmoptionSepArg, 0 },
135 {"-fade-time", ".blob.fadeTime", XrmoptionSepArg, 0 },
136 {"-hold-time", ".blob.holdTime", XrmoptionSepArg, 0 },
137 {"-zoom", ".blob.zoom", XrmoptionSepArg, 0 },
140 static argtype vars[] = {
141 {&wireframe, "wire", "Wire", DEF_WIRE, t_Bool},
142 {&blend, "blend", "Blend", DEF_BLEND, t_Float},
143 {&do_fog, "fog", "Fog", DEF_FOG, t_Bool},
144 {&do_antialias, "antialias", "Antialias", DEF_ANTIALIAS, t_Bool},
145 {&do_walls, "walls", "Walls", DEF_WALLS, t_Bool},
146 {&do_texture, "texture", "Texture", DEF_TEXTURE, t_Bool},
147 {&do_colour, "colour", "Colour", DEF_COLOUR, t_Bool},
148 {&offset_texture, "offsetTexture","OffsetTexture", DEF_OFFSET_TEXTURE, t_Bool},
149 {&do_paint_background,"paintBackground","PaintBackground", DEF_PAINT_BACKGROUND, t_Bool},
150 {&resolution, "resolution", "Resolution", DEF_RESOLUTION, t_Int},
151 {&bumps, "bumps", "Bump", DEF_BUMPS, t_Int},
152 {&motion_blur, "motionBlur", "MotionBlur", DEF_MOTION_BLUR, t_Float},
153 {&fade_time, "fadeTime", "FadeTime", DEF_FADE_TIME, t_Float},
154 {&hold_time, "holdTime", "HoldTime", DEF_HOLD_TIME, t_Float},
155 {&zoom, "zoom", "Zoom", DEF_ZOOM, t_Float},
159 static OptionStruct desc[] =
161 {"-/+ wire", "whether to do use wireframe instead of filled (faster)"},
162 {"-/+ blend", "whether to do enable blending (slower)"},
163 {"-/+ fog", "whether to do enable fog (slower)"},
164 {"-/+ antialias", "whether to do enable antialiased lines (slower)"},
165 {"-/+ walls", "whether to add walls to the blob space (slower)"},
166 {"-/+ texture", "whether to add a texture to the blob (slower)"},
167 {"-/+ colour", "whether to colour the blob"},
168 {"-/+ offset_texture", "whether to offset texture co-ordinates"},
169 {"-/+ paint_background", "whether to display a background texture (slower)"},
170 {"-resolution", "Resolution of blob tesselation"},
171 {"-bumps", "Number of bumps used to disturb blob"},
172 {"-motion_blur", "Fade blob images (higher number = faster fade)"},
173 {"-fade_time", "Number of frames to transistion to next image"},
174 {"-hold_time", "Number of frames before next image"},
177 ENTRYPOINT ModeSpecOpt mirrorblob_opts = {countof(opts), opts, countof(vars), vars, desc};
180 ModStruct mirrorblob_description =
181 {"mirrorblob", "init_mirrorblob", "draw_mirrorblob", NULL,
182 "draw_mirrorblob", "init_mirrorblob", "handle_event", &mirrorblob_opts,
183 1000, 1, 2, 1, 4, 1.0, "",
184 "OpenGL mirrorblob", 0, NULL};
187 /*****************************************************************************
188 * Types used in blob code
189 *****************************************************************************/
211 GLubyte red, green, blue, alpha;
216 Vector3D initial_position;
223 int node1, node2, node3;
225 double length1, length2, length3;
228 /* Structure to hold data about bumps used to distortion sphere */
231 double cx, cy, cpower, csize;
232 double ax, ay, power, size;
233 double mx, my, mpower, msize;
234 double vx, vy, vpower, vsize;
238 /* Vertices of a tetrahedron */
239 #define sqrt_3 0.5773502692
242 #define PPP { sqrt_3, sqrt_3, sqrt_3 } /* +X, +Y, +Z */
243 #define MMP { -sqrt_3, -sqrt_3, sqrt_3 } /* -X, -Y, +Z */
244 #define MPM { -sqrt_3, sqrt_3, -sqrt_3 } /* -X, +Y, -Z */
245 #define PMM { sqrt_3, -sqrt_3, -sqrt_3 } /* +X, -Y, -Z */
247 /* Structure describing a tetrahedron */
248 static Vector3D tetrahedron[4][3] = {
255 /*****************************************************************************
257 *****************************************************************************/
259 static const Vector3D zero_vector = { 0.0, 0.0, 0.0 };
261 /* Use 2 textures to allow a gradual fade between images */
262 #define NUM_TEXTURES 2
263 #define BUMP_ARRAY_SIZE 1024
273 /* structure for holding the mirrorblob data */
275 int screen_width, screen_height;
276 GLXContext *glx_context;
280 /* Parameters controlling the position of the blob as a whole */
281 Vector3D blob_center;
282 Vector3D blob_anchor;
283 Vector3D blob_velocity;
286 /* Count of the total number of nodes and faces used to tesselate the blob */
296 Vector2D *tex_coords;
298 /* Pointer to the bump function results */
299 double *bump_shape, *wall_shape;
301 Bump_Data *bump_data;
303 /* Use 2 textures to allow a gradual fade between images */
306 /* Ratio of used texture size to total texture size */
307 GLfloat tex_width[NUM_TEXTURES], tex_height[NUM_TEXTURES];
308 GLuint textures[NUM_TEXTURES];
311 double state_start_time;
316 Bool waiting_for_image_p;
319 trackball_state *trackball;
324 static mirrorblobstruct *Mirrorblob = NULL;
326 /******************************************************************************
328 * Returns the current time in seconds as a double. Shamelessly borrowed from
336 # ifdef GETTIMEOFDAY_TWO_ARGS
338 gettimeofday(&now, &tzp);
343 return (now.tv_sec + ((double) now.tv_usec * 0.000001));
346 /******************************************************************************
348 * Change to the projection matrix and set our viewing volume.
352 reset_projection(int width, int height)
354 glMatrixMode (GL_PROJECTION);
356 gluPerspective (60.0, 1.0, 1.0, 1024.0 );
357 glMatrixMode (GL_MODELVIEW);
361 /******************************************************************************
363 * Calculate the dot product of two vectors u and v
364 * Dot product u.v = |u||v|cos(theta)
365 * Where theta = angle between u and v
368 dot (const Vector3D u, const Vector3D v)
370 return (u.x * v.x) + (u.y * v.y) + (u.z * v.z);
373 /******************************************************************************
375 * Calculate the cross product of two vectors.
376 * Gives a vector perpendicular to u and v with magnitude |u||v|sin(theta)
377 * Where theta = angle between u and v
379 static inline Vector3D
380 cross (const Vector3D u, const Vector3D v)
384 result.x = (u.y * v.z - u.z * v.y);
385 result.y = (u.z * v.x - u.x * v.z);
386 result.z = (u.x * v.y - u.y * v.x);
391 /******************************************************************************
393 * Add vector v to vector u
396 add (Vector3D *u, const Vector3D v)
403 /******************************************************************************
405 * Subtract vector v from vector u
407 static inline Vector3D
408 subtract (const Vector3D u, const Vector3D v)
412 result.x = u.x - v.x;
413 result.y = u.y - v.y;
414 result.z = u.z - v.z;
419 /******************************************************************************
421 * multiply vector v by scalar s
423 static inline Vector3D
424 scale (const Vector3D v, const double s)
434 /******************************************************************************
438 static inline Vector3D
439 normalise (const Vector3D v)
444 magnitude = sqrt (dot(v, v));
446 if (magnitude > 1e-300)
448 result = scale (v, 1.0 / magnitude);
453 result = zero_vector;
458 /******************************************************************************
460 * Calculate the transform matrix for the given quaternion
463 quaternion_transform (Quaternion q, GLfloat * transform)
471 transform[0] = (w * w) + (x * x) - (y * y) - (z * z);
472 transform[1] = (2.0 * x * y) + (2.0 * w * z);
473 transform[2] = (2.0 * x * z) - (2.0 * w * y);
476 transform[4] = (2.0 * x * y) - (2.0 * w * z);
477 transform[5] = (w * w) - (x * x) + (y * y) - (z * z);
478 transform[6] = (2.0 * y * z) + (2.0 * w * x);
481 transform[8] = (2.0 * x * z) + (2.0 * w * y);
482 transform[9] = (2.0 * y * z) - (2.0 * w * x);
483 transform[10] = (w * w) - (x * x) - (y * y) + (z * z);
489 transform[15] = (w * w) + (x * x) + (y * y) + (z * z);
492 /******************************************************************************
494 * Apply a matrix transform to the given vector
496 static inline Vector3D
497 vector_transform (Vector3D u, GLfloat * t)
501 result.x = (u.x * t[0] + u.y * t[4] + u.z * t[8] + 1.0 * t[12]);
502 result.y = (u.x * t[1] + u.y * t[5] + u.z * t[9] + 1.0 * t[13]);
503 result.z = (u.x * t[2] + u.y * t[6] + u.z * t[10] + 1.0 * t[14]);
508 /******************************************************************************
510 * Return a node that is on an arc between node1 and node2, where distance
511 * is the proportion of the distance from node1 to the total arc.
514 partial (Vector3D node1, Vector3D node2, double distance)
517 Vector3D rotation_axis;
518 GLfloat transformation[16];
522 rotation_axis = normalise (cross (node1, node2));
523 angle = acos (dot (node1, node2)) * distance;
525 rotation.x = rotation_axis.x * sin (angle / 2.0);
526 rotation.y = rotation_axis.y * sin (angle / 2.0);
527 rotation.z = rotation_axis.z * sin (angle / 2.0);
528 rotation.w = cos (angle / 2.0);
530 quaternion_transform (rotation, transformation);
532 result = vector_transform (node1, transformation);
537 /****************************************************************************
539 * Callback indicating a texture has loaded
542 image_loaded_cb (const char *filename, XRectangle *geometry,
543 int image_width, int image_height,
544 int texture_width, int texture_height,
547 mirrorblobstruct *mp = (mirrorblobstruct *) closure;
549 int texture_index = -1;
552 glGetIntegerv (GL_TEXTURE_BINDING_2D, &texid);
553 if (texid < 0) abort();
555 for (i = 0; i < NUM_TEXTURES; i++) {
556 if (mp->textures[i] == texid) {
561 if (texture_index < 0) abort();
563 mp->tex_width [texture_index] = (GLfloat) image_width / texture_width;
564 mp->tex_height[texture_index] = -(GLfloat) image_height / texture_height;
566 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
567 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
568 (mp->mipmap_p ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR));
569 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
570 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
571 glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
573 mp->waiting_for_image_p = False;
574 mp->first_image_p = True;
577 /* Load a new file into a texture
580 grab_texture(ModeInfo *mi, int texture_index)
582 mirrorblobstruct *mp = &Mirrorblob[MI_SCREEN(mi)];
585 int w = (MI_WIDTH(mi) / 2) - 1;
586 int h = (MI_HEIGHT(mi) / 2) - 1;
590 mp->waiting_for_image_p = True;
592 load_texture_async (mi->xgwa.screen, mi->window,
593 *mp->glx_context, w, h, mp->mipmap_p,
594 mp->textures[texture_index],
595 image_loaded_cb, mp);
599 /******************************************************************************
601 * Generate internal parameters based on supplied options the parameters to
602 * ensure they are consistant.
607 # ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */
611 /* In wire frame mode do not draw a texture */
618 /* Need to load textures if either the blob or the backgound has an image */
619 if (do_texture || do_paint_background)
621 load_textures = True;
625 load_textures = False;
628 /* If theres no texture don't calculate co-ordinates. */
631 offset_texture = False;
637 /******************************************************************************
639 * Initialise the openGL state data.
642 initialize_gl(ModeInfo *mi, GLsizei width, GLsizei height)
644 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
646 /* Lighting values */
647 GLfloat ambientLight[] = { 0.2f, 0.2f, 0.2f, 1.0f };
649 GLfloat lightPos0[] = {500.0f, 100.0f, 200.0f, 1.0f };
650 GLfloat whiteLight0[] = { 0.0f, 0.0f, 0.0f, 1.0f };
651 GLfloat sourceLight0[] = { 0.6f, 0.6f, 0.6f, 1.0f };
652 GLfloat specularLight0[] = { 0.8f, 0.8f, 0.9f, 1.0f };
654 GLfloat lightPos1[] = {-50.0f, -100.0f, 2500.0f, 1.0f };
655 GLfloat whiteLight1[] = { 0.0f, 0.0f, 0.0f, 1.0f };
656 GLfloat sourceLight1[] = { 0.6f, 0.6f, 0.6f, 1.0f };
657 GLfloat specularLight1[] = { 0.7f, 0.7f, 0.7f, 1.0f };
659 GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
661 GLfloat fogColor[4] = { 0.4, 0.4, 0.5, 0.1 };
663 /* Set the internal parameters based on the configuration settings */
666 /* Set the viewport to the width and heigh of the window */
667 glViewport (0, 0, width, height );
672 glEnable(GL_LINE_SMOOTH);
673 glEnable(GL_POLYGON_SMOOTH);
676 /* The blend function is used for trasitioning between two images even when
677 * blend is not selected.
679 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
684 glFogfv(GL_FOG_COLOR, fogColor);
685 glFogf(GL_FOG_DENSITY, 0.50);
686 glFogf(GL_FOG_START, 15.0);
687 glFogf(GL_FOG_END, 30.0);
690 /* Set the shading model to smooth (Gouraud shading). */
691 glShadeModel (GL_SMOOTH);
693 glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambientLight);
694 glLightfv (GL_LIGHT0, GL_AMBIENT, whiteLight0);
695 glLightfv (GL_LIGHT0, GL_DIFFUSE, sourceLight0);
696 glLightfv (GL_LIGHT0, GL_SPECULAR, specularLight0);
697 glLightfv (GL_LIGHT0, GL_POSITION, lightPos0);
698 glEnable (GL_LIGHT0);
699 glLightfv (GL_LIGHT1, GL_AMBIENT, whiteLight1);
700 glLightfv (GL_LIGHT1, GL_DIFFUSE, sourceLight1);
701 glLightfv (GL_LIGHT1, GL_SPECULAR, specularLight1);
702 glLightfv (GL_LIGHT1, GL_POSITION, lightPos1);
703 glEnable (GL_LIGHT1);
704 glEnable (GL_LIGHTING);
706 /* Enable color tracking */
707 glEnable (GL_COLOR_MATERIAL);
709 /* Set Material properties to follow glColor values */
710 glColorMaterial (GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
712 /* Set all materials to have specular reflectivity */
713 glMaterialfv (GL_FRONT, GL_SPECULAR, specref);
714 glMateriali (GL_FRONT, GL_SHININESS, 32);
716 /* Let GL implementation scale normal vectors. */
717 glEnable (GL_NORMALIZE);
722 glLightModeli (GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
723 glEnable (GL_TEXTURE_2D);
725 gp->current_texture = 0;
726 glGenTextures(NUM_TEXTURES, gp->textures);
727 grab_texture(mi, gp->current_texture);
729 glMatrixMode (GL_TEXTURE);
730 glRotated (180.0, 1.0, 0.0, 0.0);
731 glMatrixMode (GL_MODELVIEW);
734 /* Clear the buffer since this is not done during a draw with motion blur */
735 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
738 /******************************************************************************
740 * Initialise the openGL state data.
743 set_blob_gl_state(GLfloat alpha)
747 glEnable(GL_LINE_SMOOTH);
748 glEnable(GL_POLYGON_SMOOTH);
753 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
757 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
760 /* The blend function is used for trasitioning between two images even when
761 * blend is not selected.
763 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
768 glCullFace (GL_BACK);
769 glEnable (GL_CULL_FACE);
770 glFrontFace (GL_CCW);
774 glDisable (GL_CULL_FACE);
780 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
781 /* Set the default blob colour to off-white. */
782 glColor4f (0.9, 0.9, 1.0, alpha);
787 glColor4f (0.9, 0.9, 1.0, 1.0);
790 glEnable(GL_DEPTH_TEST);
791 glEnable(GL_LIGHTING);
794 /******************************************************************************
796 * Initialise the data required to draw the blob allocating the memory as
799 * Return 0 on success.
802 initialise_blob(mirrorblobstruct *gp,
808 int i, u, v, node, side, face, base, base2 = 0;
809 int nodes_on_edge = resolution;
810 Vector3D node1, node2, result;
812 if (nodes_on_edge < 2)
815 gp->num_nodes = 2 * nodes_on_edge * nodes_on_edge - 4 * nodes_on_edge + 4;
816 gp->num_faces = 4 * (nodes_on_edge - 1) * (nodes_on_edge - 1);
818 gp->nodes = (Node_Data *) malloc (gp->num_nodes * sizeof (Node_Data));
821 fprintf (stderr, "Couldn't allocate gp->nodes buffer\n");
825 gp->faces = (Face_Data *) malloc (gp->num_faces * sizeof (Face_Data));
828 fprintf (stderr, "Couldn't allocate faces data buffer\n");
832 gp->bump_data = (Bump_Data *) malloc (bumps * sizeof (Bump_Data));
835 fprintf(stderr, "Couldn't allocate bump data buffer\n");
839 gp->bump_shape = (double *)malloc(bump_array_size * sizeof(double));
842 fprintf(stderr, "Couldn't allocate bump buffer\n");
846 gp->wall_shape = (double *)malloc(bump_array_size * sizeof(double));
849 fprintf(stderr, "Couldn't allocate wall bump buffer\n");
854 gp->dots = (Vector3D *)malloc(gp->num_nodes * sizeof(Vector3D));
857 fprintf(stderr, "Couldn't allocate nodes buffer\n");
861 gp->normals = (Vector3D *)malloc(gp->num_nodes * sizeof(Vector3D));
864 fprintf(stderr, "Couldn't allocate normals buffer\n");
868 gp->colours = (Colour *)malloc(gp->num_nodes * sizeof(Colour));
871 fprintf(stderr, "Couldn't allocate colours buffer\n");
875 gp->tex_coords = (Vector2D *)malloc(gp->num_nodes * sizeof(Vector2D));
878 fprintf(stderr, "Couldn't allocate gp->tex_coords buffer\n");
883 /* Initialise bump data */
884 for (i = 0; i < bumps; i++)
886 gp->bump_data[i].ax = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
887 gp->bump_data[i].ay = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
888 gp->bump_data[i].power = (5.0 / pow(bumps, 0.75)) * (((double)random() / (double)RAND_MAX) - 0.5);
889 gp->bump_data[i].size = 0.1 + 0.5 * (((double)random() / (double)RAND_MAX));
891 gp->bump_data[i].pos.x = 1.5 * sin(PI * gp->bump_data[i].ay)
892 * cos(PI * gp->bump_data[i].ax);
893 gp->bump_data[i].pos.y = 1.5 * cos(PI * gp->bump_data[i].ay);
894 gp->bump_data[i].pos.z = 1.5 * sin(PI * gp->bump_data[i].ay)
895 * sin(PI * gp->bump_data[i].ax);
897 gp->bump_data[i].cx = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
898 gp->bump_data[i].cy = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
899 gp->bump_data[i].cpower = (5.0 / pow(bumps, 0.75)) * (((double)random() / (double)RAND_MAX) - 0.5);
900 gp->bump_data[i].csize = 0.35; /*0.1 + 0.25 * (((double)random() / (double)RAND_MAX));*/
902 gp->bump_data[i].vx = 0.0;
903 gp->bump_data[i].vy = 0.0;
904 gp->bump_data[i].vpower = 0.0;
905 gp->bump_data[i].vsize = 0.0;
907 gp->bump_data[i].mx = 0.003 * ((double)random() / (double)RAND_MAX);
908 gp->bump_data[i].my = 0.003 * ((double)random() / (double)RAND_MAX);
909 gp->bump_data[i].mpower = 0.003 * ((double)random() / (double)RAND_MAX);
910 gp->bump_data[i].msize = 0.003 * ((double)random() / (double)RAND_MAX);
913 /* Initialise lookup table of bump strength */
914 for (i = 0; i < bump_array_size; i++)
917 xd = i / (double)bump_array_size;
919 xd2 = 48.0 * xd * xd;
920 gp->bump_shape[i] = 0.1 / (xd2 + 0.1);
922 xd2 = 40.0 * xd * xd * xd * xd;
923 gp->wall_shape[i] = 0.4 / (xd2 + 0.1);
928 for (side = 0; side < 4; side++)
936 * The start and end of the for loops below are modified based on the
937 * side of the tetrahedron that is being calculated to avoid duplication
938 * of the gp->nodes that are on the edges of the tetrahedron.
940 for (u = (side > 1); u < (nodes_on_edge - (side > 0)); u++)
942 node1 = partial (normalise (tetrahedron[side][0]),
943 normalise (tetrahedron[side][1]),
944 u / (double) (nodes_on_edge - 1));
945 node2 = partial (normalise (tetrahedron[side][0]),
946 normalise (tetrahedron[side][2]),
947 u / (double) (nodes_on_edge - 1));
949 for (v = (side > 1); v <= (u - (side > 2)); v++)
952 result = partial (node1, node2, v / (double) u);
956 gp->nodes[node].position = normalise (result);
957 gp->nodes[node].initial_position = gp->nodes[node].position;
958 gp->nodes[node].normal = zero_vector;
964 * Determine which nodes make up each face. The complexity is caused
965 * by having to determine the correct nodes for the edges of the
966 * tetrahedron since the common nodes on the edges are only calculated
969 for (u = 0; u < (nodes_on_edge - 1); u++)
971 for (v = 0; v <= u; v++)
976 gp->faces[face].node1 = base + ((u * (u + 1)) / 2) + v;
977 gp->faces[face].node2 =
978 base + ((u + 1) * (u + 2)) / 2 + v + 1;
979 gp->faces[face].node3 =
980 base + ((u + 1) * (u + 2)) / 2 + v;
982 if ((side == 1) && (u == (nodes_on_edge - 2)))
984 gp->faces[face].node3 =
985 ((u + 1) * (u + 2)) / 2 +
986 nodes_on_edge - v - 1;
987 gp->faces[face].node2 =
988 ((u + 1) * (u + 2)) / 2 +
989 nodes_on_edge - v - 2;
994 gp->faces[face].node1 =
995 base + (((u - 1) * u) / 2) + v - 1;
996 gp->faces[face].node2 = base + ((u) * (u + 1)) / 2 + v;
997 gp->faces[face].node3 =
998 base + ((u) * (u + 1)) / 2 + v - 1;
1000 if (u == (nodes_on_edge - 2))
1002 int n = nodes_on_edge - v - 1;
1003 gp->faces[face].node2 =
1005 (nodes_on_edge + 1)) / 2) +
1006 ((n - 1) * (n + 0)) / 2;
1007 gp->faces[face].node3 =
1009 (nodes_on_edge + 1)) / 2) +
1010 ((n + 0) * (n + 1)) / 2;
1014 gp->faces[face].node1 = (((u + 1) * (u + 2)) / 2) - 1;
1015 gp->faces[face].node3 = (((u + 2) * (u + 3)) / 2) - 1;
1020 gp->faces[face].node1 =
1021 base + (((u - 2) * (u - 1)) / 2) + v - 1;
1022 gp->faces[face].node2 = base + ((u - 1) * u) / 2 + v;
1023 gp->faces[face].node3 = base + ((u - 1) * u) / 2 + v - 1;
1027 gp->faces[face].node1 =
1028 base2 + ((u * (u + 1)) / 2) - 1;
1029 gp->faces[face].node3 =
1030 base2 + ((u + 1) * (u + 2)) / 2 - 1;
1032 if (u == (nodes_on_edge - 2))
1034 gp->faces[face].node3 =
1036 (nodes_on_edge + 1)) / 2) +
1037 ((v + 1) * (v + 2)) / 2 - 1;
1038 gp->faces[face].node2 =
1040 (nodes_on_edge + 1)) / 2) +
1041 ((v + 2) * (v + 3)) / 2 - 1;
1045 gp->faces[face].node1 = (u * (u + 1)) / 2;
1046 gp->faces[face].node2 = ((u + 1) * (u + 2)) / 2;
1056 gp->faces[face].node1 = base + ((u * (u + 1)) / 2) + v;
1057 gp->faces[face].node2 =
1058 base + ((u * (u + 1)) / 2) + v + 1;
1059 gp->faces[face].node3 =
1060 base + (((u + 1) * (u + 2)) / 2) + v + 1;
1062 if ((side == 1) && (u == (nodes_on_edge - 2)))
1064 gp->faces[face].node3 =
1065 ((u + 1) * (u + 2)) / 2 +
1066 nodes_on_edge - v - 2;
1071 gp->faces[face].node1 =
1072 base + ((u * (u - 1)) / 2) + v - 1;
1073 gp->faces[face].node2 = base + ((u * (u - 1)) / 2) + v;
1074 gp->faces[face].node3 = base + ((u * (u + 1)) / 2) + v;
1076 if (u == (nodes_on_edge - 2))
1078 int n = nodes_on_edge - v - 1;
1079 gp->faces[face].node3 =
1081 (nodes_on_edge + 1)) / 2) +
1082 ((n + 0) * (n - 1)) / 2;
1086 gp->faces[face].node1 = (((u + 1) * (u + 2)) / 2) - 1;
1091 gp->faces[face].node1 =
1092 base + (((u - 2) * (u - 1)) / 2) + v - 1;
1093 gp->faces[face].node2 =
1094 base + (((u - 2) * (u - 1)) / 2) + v;
1095 gp->faces[face].node3 = base + (((u - 1) * u) / 2) + v;
1099 gp->faces[face].node1 = base2 + (u * (u + 1)) / 2 - 1;
1101 if (u == (nodes_on_edge - 2))
1103 gp->faces[face].node3 =
1104 ((nodes_on_edge * (nodes_on_edge + 1)) / 2) +
1105 ((v + 2) * (v + 3)) / 2 - 1;
1109 gp->faces[face].node2 = (u * (u + 1)) / 2;
1121 /******************************************************************************
1123 * Return the magnitude of the given vector
1126 static inline double
1129 return sqrt (u.x * u.x + u.y * u.y + u.z * u.z);
1133 /******************************************************************************
1135 * Calculate the blob shape.
1138 calc_blob(mirrorblobstruct *gp,
1141 int bump_array_size,
1145 /* Loop variables */
1147 /* position of a node */
1150 Vector3D bump_vector;
1153 /* Update position and strength of bumps used to distort the blob */
1154 for (i = 0; i < bumps; i++)
1156 gp->bump_data[i].vx += gp->bump_data[i].mx*(gp->bump_data[i].cx - gp->bump_data[i].ax);
1157 gp->bump_data[i].vy += gp->bump_data[i].my*(gp->bump_data[i].cy - gp->bump_data[i].ay);
1158 gp->bump_data[i].vpower += gp->bump_data[i].mpower
1159 * (gp->bump_data[i].cpower - gp->bump_data[i].power);
1160 gp->bump_data[i].vsize += gp->bump_data[i].msize
1161 * (gp->bump_data[i].csize - gp->bump_data[i].size);
1163 gp->bump_data[i].ax += 0.1 * gp->bump_data[i].vx;
1164 gp->bump_data[i].ay += 0.1 * gp->bump_data[i].vy;
1165 gp->bump_data[i].power += 0.1 * gp->bump_data[i].vpower;
1166 gp->bump_data[i].size += 0.1 * gp->bump_data[i].vsize;
1168 gp->bump_data[i].pos.x = 1.0 * sin(PI * gp->bump_data[i].ay)
1169 * cos(PI * gp->bump_data[i].ax);
1170 gp->bump_data[i].pos.y = 1.0 * cos(PI * gp->bump_data[i].ay);
1171 gp->bump_data[i].pos.z = 1.0 * sin(PI * gp->bump_data[i].ay)
1172 * sin(PI * gp->bump_data[i].ax);
1175 /* Update calculate new position for each vertex based on an offset from
1176 * the initial position
1178 gp->blob_force = zero_vector;
1179 for (index = 0; index < gp->num_nodes; ++index)
1181 node = gp->nodes[index].initial_position;
1182 gp->nodes[index].normal = node;
1184 offset = zero_vector;
1185 for ( i = 0; i < bumps; i++)
1187 bump_vector = subtract(gp->bump_data[i].pos, node);
1189 dist = bump_array_size * dot(bump_vector, bump_vector) * gp->bump_data[i].size;
1191 if (dist < bump_array_size)
1193 add(&offset, scale(node, gp->bump_data[i].power * gp->bump_shape[dist]));
1194 add(&gp->blob_force, scale(node, gp->bump_data[i].power * gp->bump_shape[dist]));
1199 node = scale(node, zoom);
1200 add(&node, gp->blob_center);
1204 if (node.z < -limit) node.z = -limit;
1205 if (node.z > limit) node.z = limit;
1207 dist = bump_array_size * (node.z + limit) * (node.z + limit) * 0.5;
1208 if (dist < bump_array_size)
1210 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1211 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1212 gp->blob_force.z += (node.z + limit);
1216 dist = bump_array_size * (node.z - limit) * (node.z - limit) * 0.5;
1217 if (dist < bump_array_size)
1219 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1220 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1221 gp->blob_force.z -= (node.z - limit);
1224 if (node.y < -limit) node.y = -limit;
1225 if (node.y > limit) node.y = limit;
1227 dist = bump_array_size * (node.y + limit) * (node.y + limit) * 0.5;
1228 if (dist < bump_array_size)
1230 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1231 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1232 gp->blob_force.y += (node.y + limit);
1236 dist = bump_array_size * (node.y - limit) * (node.y - limit) * 0.5;
1237 if (dist < bump_array_size)
1239 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1240 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1241 gp->blob_force.y -= (node.y - limit);
1245 if (node.x < -limit) node.x = -limit;
1246 if (node.x > limit) node.x = limit;
1248 dist = bump_array_size * (node.x + limit) * (node.x + limit) * 0.5;
1249 if (dist < bump_array_size)
1251 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1252 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1253 gp->blob_force.x += (node.x + limit);
1257 dist = bump_array_size * (node.x - limit) * (node.x - limit) * 0.5;
1258 if (dist < bump_array_size)
1260 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1261 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1262 gp->blob_force.x -= (node.x - limit);
1266 if (node.y < -limit) node.y = -limit;
1267 if (node.y > limit) node.y = limit;
1270 gp->dots[index] = node;
1273 /* Determine the normal for each face */
1274 for (face = 0; face < gp->num_faces; face++)
1276 /* Use pointers to indexed nodes to help readability */
1277 int index1 = gp->faces[face].node1;
1278 int index2 = gp->faces[face].node2;
1279 int index3 = gp->faces[face].node3;
1281 gp->faces[face].normal = cross(subtract(gp->dots[index2], gp->dots[index1]),
1282 subtract(gp->dots[index3], gp->dots[index1]));
1284 /* Add the normal for the face onto the normal for the verticies of
1286 add(&gp->nodes[index1].normal, gp->faces[face].normal);
1287 add(&gp->nodes[index2].normal, gp->faces[face].normal);
1288 add(&gp->nodes[index3].normal, gp->faces[face].normal);
1291 /* Use the normal to set the colour and texture */
1292 if (do_colour || do_texture)
1294 for (index = 0; index < gp->num_nodes; ++index)
1296 gp->normals[index] = normalise(gp->nodes[index].normal);
1300 gp->colours[index].red = (int)(255.0 * fabs(gp->normals[index].x));
1301 gp->colours[index].green = (int)(255.0 * fabs(gp->normals[index].y));
1302 gp->colours[index].blue = (int)(255.0 * fabs(gp->normals[index].z));
1303 gp->colours[index].alpha = (int)(255.0 * fade);
1309 const float cube_size = 100.0;
1310 Vector3D eye = {0.0, 0.0, 50.0};
1311 Vector3D eye_r = normalise(subtract(gp->dots[index], eye));
1312 Vector3D reference = subtract(eye_r, scale(gp->normals[index], 2.0 * dot(eye_r, gp->normals[index])));
1315 double n, n_min = 10000.0, sign = 1.0;
1316 if (fabs(reference.z) > 1e-9)
1318 n = (cube_size - gp->dots[index].z) / reference.z;
1321 n = (-cube_size - gp->dots[index].z) / reference.z;
1326 x = sign * (gp->dots[index].x + n * reference.x);
1327 y = sign * (gp->dots[index].y + n * reference.y);
1331 if (fabs(reference.x) > 1e-9)
1333 n = (cube_size - gp->dots[index].x) / reference.x;
1337 n = (-cube_size - gp->dots[index].x) / reference.x;
1340 if ((n > 0.0) && (n < n_min))
1342 x = sign * (2.0 * cube_size - (gp->dots[index].z + n * reference.z));
1343 y = sign * x * (gp->dots[index].y + n * reference.y) / cube_size;
1347 if (fabs(reference.y) > 1e-9)
1349 n = (cube_size - gp->dots[index].y) / reference.y;
1353 n = (-cube_size - gp->dots[index].y) / reference.y;
1356 if ((n > 0.0) && (n < n_min))
1358 y = sign * (2.0 * cube_size -( gp->dots[index].z + n * reference.z));
1359 x = sign * y * (gp->dots[index].x + n * reference.x) / cube_size;
1363 gp->tex_coords[index].x = 0.5 + x / (cube_size * 6.0);
1364 gp->tex_coords[index].y = 0.5 - y / (cube_size * 6.0);
1368 gp->tex_coords[index].x = 0.5
1369 * (1.0 + asin(gp->normals[index].x) / (0.5 * PI));
1370 gp->tex_coords[index].y = -0.5
1371 * (1.0 + asin(gp->normals[index].y) / (0.5 * PI));
1373 /* Adjust the texture co-ordinates to from range 0..1 to
1374 * 0..width or 0..height as appropriate
1376 gp->tex_coords[index].x *= gp->tex_width[gp->current_texture];
1377 gp->tex_coords[index].y *= gp->tex_height[gp->current_texture];
1382 /* Update the center of the whole blob */
1383 add(&gp->blob_velocity, scale (subtract (gp->blob_anchor, gp->blob_center), 1.0 / 80.0));
1384 add(&gp->blob_velocity, scale (gp->blob_force, 0.01 / gp->num_nodes));
1386 add(&gp->blob_center, scale(gp->blob_velocity, 0.5));
1388 gp->blob_velocity = scale(gp->blob_velocity, 0.999);
1392 draw_vertex(mirrorblobstruct *gp, int index)
1396 glColor3ub(gp->colours[index].red,
1397 gp->colours[index].green,
1398 gp->colours[index].blue);
1402 glTexCoord2fv(&gp->tex_coords[index].x);
1404 glNormal3fv(&gp->normals[index].x);
1405 glVertex3fv(&gp->dots[index].x);
1408 /******************************************************************************
1410 * Draw the blob shape.
1414 draw_blob (mirrorblobstruct *gp)
1418 glMatrixMode(GL_MODELVIEW);
1420 /* glRotatef(current_device_rotation(), 0, 0, 1); */
1422 /* Move down the z-axis. */
1423 glTranslatef (0.0, 0.0, -4.0);
1425 gltrackball_rotate (gp->trackball);
1427 /* glColor4ub (255, 0, 0, 128); */
1428 glBegin(GL_TRIANGLES);
1429 for (face = 0; face < gp->num_faces; face++)
1431 draw_vertex(gp, gp->faces[face].node1);
1432 draw_vertex(gp, gp->faces[face].node2);
1433 draw_vertex(gp, gp->faces[face].node3);
1439 for (face = 0; face < gp->num_faces; face++)
1441 if (gp->normals[gp->faces[face].node1].z > 0.0)
1443 Vector3D end = gp->dots[gp->faces[face].node1];
1445 add(&end, scale(gp->normals[gp->faces[face].node1], 0.25));
1455 /******************************************************************************
1457 * Draw the background image simply map a texture onto a full screen quad.
1460 draw_background (ModeInfo *mi)
1462 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1463 GLfloat rot = current_device_rotation();
1465 glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
1466 glEnable (GL_TEXTURE_2D);
1467 glDisable(GL_LIGHTING);
1468 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1470 /* Reset the projection matrix to make it easier to get the size of the quad
1473 glMatrixMode(GL_PROJECTION);
1477 glRotatef (-rot, 0, 0, 1);
1479 if ((rot > 45 && rot < 135) ||
1480 (rot < -45 && rot > -135))
1482 GLfloat s = MI_WIDTH(mi) / (GLfloat) MI_HEIGHT(mi);
1483 glScalef (s, 1/s, 1);
1487 glOrtho(0.0, MI_WIDTH(mi), MI_HEIGHT(mi), 0.0, -1000.0, 1000.0);
1491 glTexCoord2f (0.0, 0.0);
1494 glTexCoord2f (0.0, gp->tex_height[gp->current_texture]);
1495 glVertex2i (0, MI_HEIGHT(mi));
1497 glTexCoord2f (gp->tex_width[gp->current_texture], gp->tex_height[gp->current_texture]);
1498 glVertex2i (MI_WIDTH(mi), MI_HEIGHT(mi));
1500 glTexCoord2f (gp->tex_width[gp->current_texture], 0.0);
1501 glVertex2i (MI_WIDTH(mi), 0);
1505 glMatrixMode (GL_MODELVIEW);
1506 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1509 /******************************************************************************
1514 draw_scene(ModeInfo * mi)
1516 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1519 double current_time;
1520 check_gl_error ("draw_scene");
1522 mi->polygon_count = 0;
1523 glColor4f (1.0, 1.0, 1.0, 1.0);
1525 current_time = double_time();
1529 glColor4f (0.0, 0.0, 0.0, 1.0);
1534 fade = 1.0 - (current_time - gp->state_start_time) / fade_time;
1537 case LOADING: /* FALL-THROUGH */
1543 /* Set the correct texture, when transitioning this ensures that the first draw
1544 * is the original texture (which has the new texture drawn over it with decreasing
1549 glBindTexture(GL_TEXTURE_2D, gp->textures[gp->current_texture]);
1552 glDisable (GL_DEPTH_TEST);
1553 if (do_paint_background)
1555 glEnable (GL_TEXTURE_2D);
1556 if (motion_blur > 0.0)
1558 glClear(GL_DEPTH_BUFFER_BIT);
1559 glEnable (GL_BLEND);
1560 glColor4f (1.0, 1.0, 1.0, motion_blur);
1564 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1566 draw_background (mi);
1567 mi->polygon_count++;
1569 /* When transitioning between two images paint the new image over the old
1570 * image with a varying alpha value to get a smooth fade.
1572 if (gp->state == TRANSITIONING)
1574 glEnable (GL_BLEND);
1575 /* Select the texture to transition to */
1576 glBindTexture (GL_TEXTURE_2D, gp->textures[1 - gp->current_texture]);
1577 glColor4f (1.0, 1.0, 1.0, 1.0 - fade);
1579 draw_background (mi);
1580 mi->polygon_count++;
1582 /* Select the original texture to draw the blob */
1583 glBindTexture (GL_TEXTURE_2D, gp->textures[gp->current_texture]);
1585 /* Clear the depth buffer bit so the backgound is behind the blob */
1586 glClear(GL_DEPTH_BUFFER_BIT);
1588 else if (motion_blur > 0.0)
1590 glEnable (GL_BLEND);
1591 glColor4f (0.0, 0.0, 0.0, motion_blur);
1592 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1593 glTranslatef (0.0, 0.0, -4.0);
1594 glRectd (-10.0, -10.0, 10.0, 10.0);
1597 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1599 glClear(GL_DEPTH_BUFFER_BIT);
1603 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1609 glDisable (GL_TEXTURE_2D);
1612 calc_blob(gp, MI_WIDTH(mi), MI_HEIGHT(mi), BUMP_ARRAY_SIZE, 2.5, fade * blend);
1614 set_blob_gl_state(fade * blend);
1618 /* Disable the colour chanels so that only the depth buffer is updated */
1619 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1621 mi->polygon_count += gp->num_faces;
1622 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1625 glDepthFunc(GL_LEQUAL);
1627 mi->polygon_count += gp->num_faces;
1629 /* While transitioning between images draw a second blob with a modified
1632 if (load_textures && (hold_time > 0))
1637 if (!gp->waiting_for_image_p)
1639 gp->state = HOLDING;
1644 if ((current_time - gp->state_start_time) > hold_time)
1646 grab_texture(mi, 1 - gp->current_texture);
1647 gp->state = LOADING;
1652 /* Once the image has loaded move to the TRANSITIONING STATE */
1653 if (!gp->waiting_for_image_p)
1655 gp->state = TRANSITIONING;
1656 /* Get the time again rather than using the current time so
1657 * that the time taken by the grab_texture function is not part
1660 gp->state_start_time = double_time();
1666 /* If the blob is textured draw over existing blob to fade between
1671 /* Select the texture to transition to */
1672 glBindTexture (GL_TEXTURE_2D, gp->textures[1 - gp->current_texture]);
1673 glEnable (GL_BLEND);
1675 /* If colour is enabled update the alpha data in the buffer and
1676 * use that in the blending since the alpha of the incomming
1677 * verticies will not be correct
1681 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
1682 glClearColor(0.0, 0.0, 0.0, (1.0 - fade) * blend);
1683 glClear(GL_COLOR_BUFFER_BIT);
1684 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1685 glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
1689 glColor4f (0.9, 0.9, 1.0, (1.0 - fade) * blend);
1693 mi->polygon_count += gp->num_faces;
1697 /* Restore the 'standard' blend functions. */
1698 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1702 if ((current_time - gp->state_start_time) > fade_time)
1704 gp->state = HOLDING;
1705 gp->state_start_time = current_time;
1706 gp->current_texture = 1 - gp->current_texture;
1714 /******************************************************************************
1716 * XMirrorblob screen update entry
1719 draw_mirrorblob(ModeInfo * mi)
1721 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1722 Display *display = MI_DISPLAY(mi);
1723 Window window = MI_WINDOW(mi);
1725 if (!gp->glx_context)
1728 /* Wait for the first image; for subsequent images, load them in the
1729 background while animating. */
1730 if (gp->waiting_for_image_p && gp->first_image_p)
1733 glXMakeCurrent(display, window, *(gp->glx_context));
1735 if (mi->fps_p) do_fps (mi);
1737 glXSwapBuffers(display, window);
1740 /******************************************************************************
1742 * XMirrorblob screen resize entry
1745 reshape_mirrorblob(ModeInfo *mi, int width, int height)
1747 glViewport( 0, 0, MI_WIDTH(mi), MI_HEIGHT(mi) );
1748 reset_projection(width, height);
1751 /****************************************************************************
1753 * Handle Mouse events
1756 mirrorblob_handle_event (ModeInfo * mi, XEvent * event)
1758 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN (mi)];
1760 if (event->xany.type == ButtonPress &&
1761 event->xbutton.button == Button4)
1766 else if (event->xany.type == ButtonPress &&
1767 event->xbutton.button == Button5)
1773 else if (gltrackball_event_handler (event, gp->trackball,
1774 MI_WIDTH (mi), MI_HEIGHT (mi),
1779 else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
1781 gp->state_start_time = 0;
1782 gp->state = HOLDING;
1789 static void free_mirrorblob(ModeInfo * mi);
1791 /******************************************************************************
1793 * XMirrorblob initialise entry
1796 init_mirrorblob(ModeInfo * mi)
1798 int screen = MI_SCREEN(mi);
1800 mirrorblobstruct *gp;
1802 MI_INIT(mi, Mirrorblob, free_mirrorblob);
1803 gp = &Mirrorblob[screen];
1805 gp->window = MI_WINDOW(mi);
1806 if ((gp->glx_context = init_GL(mi)) != NULL)
1808 reshape_mirrorblob(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1809 initialize_gl(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1815 gp->trackball = gltrackball_init(False);
1817 initialise_blob(gp, MI_WIDTH(mi), MI_HEIGHT(mi), BUMP_ARRAY_SIZE);
1818 gp->state = INITIALISING;
1819 gp->state_start_time = double_time();
1821 gp->first_image_p = True;
1824 /******************************************************************************
1826 * XMirrorblob cleanup entry
1829 free_mirrorblob(ModeInfo * mi)
1831 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1832 if (gp->nodes) free(gp->nodes);
1833 if (gp->faces) free(gp->faces);
1834 if (gp->bump_data) free(gp->bump_data);
1835 if (gp->colours) free(gp->colours);
1836 if (gp->tex_coords) free(gp->tex_coords);
1837 if (gp->dots) free(gp->dots);
1838 if (gp->wall_shape) free(gp->wall_shape);
1839 if (gp->bump_shape) free(gp->bump_shape);
1842 XSCREENSAVER_MODULE ("MirrorBlob", mirrorblob)