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
22 * The mirrorblob screensaver draws a pulsing blob on the screen. Options
23 * include adding a background (via screen_to_texture), texturing the blob,
24 * making the blob semi-transparent and varying the resolution of the blob
27 * The blob was inspired by a lavalamp is in no way a simulation. The code is
28 * just an attempt to generate some eye-candy.
30 * Much of xmirrorblob code framework is taken from the pulsar module by David
31 * Konerding and the glslideshow by Mike Oliphant and Jamie Zawinski.
39 "*delay: " DEF_DELAY "\n" \
40 "*showFPS: " DEF_FPS "\n" \
43 # define refresh_mirrorblob 0
45 # define mirrorblob_handle_event 0
47 # include "xlockmore.h" /* from the xmirrorblob distribution */
48 #else /* !STANDALONE */
49 # include "xlock.h" /* from the xlockmore distribution */
50 #endif /* !STANDALONE */
52 #ifdef USE_GL /* whole file */
55 #define DEF_DELAY "10000"
56 #define DEF_FPS "False"
57 #define DEF_WIRE "False"
58 #define DEF_BLEND "1.0"
59 #define DEF_FOG "False"
60 #define DEF_ANTIALIAS "False"
61 #define DEF_WALLS "False"
62 #define DEF_COLOUR "False"
63 #define DEF_ASYNC "True"
64 #define DEF_TEXTURE "True"
65 #define DEF_OFFSET_TEXTURE "False"
66 #define DEF_PAINT_BACKGROUND "True"
67 #define DEF_RESOLUTION "30"
68 #define DEF_BUMPS "10"
69 #define DEF_MOTION_BLUR "0.0"
70 #define DEF_INCREMENTAL "0"
71 #define DEF_HOLD_TIME "30.0"
72 #define DEF_FADE_TIME "5.0"
73 #define DEF_ZOOM "1.0"
77 # include <X11/Xmu/Drawing.h>
79 # include <Xmu/Drawing.h>
83 #include "gltrackball.h"
84 #include "grab-ximage.h"
87 #define countof(x) (sizeof((x)) / sizeof((*x)))
89 #define PI 3.1415926535897
91 /* Options from command line */
93 static Bool wireframe;
95 static Bool do_antialias;
97 static Bool do_texture;
98 static Bool do_paint_background;
99 static Bool do_colour;
100 static Bool offset_texture;
101 static int resolution;
103 static float motion_blur;
104 static float fade_time;
105 static float hold_time;
108 /* Internal parameters based on supplied options */
110 static Bool load_textures;
112 static XrmOptionDescRec opts[] = {
113 {"-wire", ".blob.wire", XrmoptionNoArg, "true" },
114 {"+wire", ".blob.wire", XrmoptionNoArg, "false" },
115 {"-blend", ".blob.blend", XrmoptionSepArg, 0 },
116 {"-fog", ".blob.fog", XrmoptionNoArg, "true" },
117 {"+fog", ".blob.fog", XrmoptionNoArg, "false" },
118 {"-antialias", ".blob.antialias", XrmoptionNoArg, "true" },
119 {"+antialias", ".blob.antialias", XrmoptionNoArg, "false" },
120 {"-walls", ".blob.walls", XrmoptionNoArg, "true" },
121 {"+walls", ".blob.walls", XrmoptionNoArg, "false" },
122 {"-texture", ".blob.texture", XrmoptionNoArg, "true" },
123 {"+texture", ".blob.texture", XrmoptionNoArg, "false" },
124 {"-colour", ".blob.colour", XrmoptionNoArg, "true" },
125 {"+colour", ".blob.colour", XrmoptionNoArg, "false" },
126 {"-offset-texture", ".blob.offset_texture", XrmoptionNoArg, "true" },
127 {"+offset-texture", ".blob.offset_texture", XrmoptionNoArg, "false" },
128 {"-paint-background", ".blob.paint_background", XrmoptionNoArg, "true" },
129 {"+paint-background", ".blob.paint_background", XrmoptionNoArg, "false" },
130 {"-resolution", ".blob.resolution", XrmoptionSepArg, NULL },
131 {"-bumps", ".blob.bumps", XrmoptionSepArg, NULL },
132 {"-motion-blur", ".blob.motion_blur", XrmoptionSepArg, 0 },
133 {"-fade-time", ".blob.fade_time", XrmoptionSepArg, 0 },
134 {"-hold-time", ".blob.hold_time", XrmoptionSepArg, 0 },
135 {"-zoom", ".blob.zoom", XrmoptionSepArg, 0 },
138 static argtype vars[] = {
139 {&wireframe, "wire", "Wire", DEF_WIRE, t_Bool},
140 {&blend, "blend", "Blend", DEF_BLEND, t_Float},
141 {&do_fog, "fog", "Fog", DEF_FOG, t_Bool},
142 {&do_antialias, "antialias", "Antialias", DEF_ANTIALIAS, t_Bool},
143 {&do_walls, "walls", "Walls", DEF_WALLS, t_Bool},
144 {&do_texture, "texture", "Texture", DEF_TEXTURE, t_Bool},
145 {&do_colour, "colour", "Colour", DEF_COLOUR, t_Bool},
146 {&offset_texture, "offset_texture","Offset_Texture", DEF_OFFSET_TEXTURE, t_Bool},
147 {&do_paint_background,"paint_background","Paint_Background", DEF_PAINT_BACKGROUND, t_Bool},
148 {&resolution, "resolution", "Resolution", DEF_RESOLUTION, t_Int},
149 {&bumps, "bumps", "Bump", DEF_BUMPS, t_Int},
150 {&motion_blur, "motion_blur", "Motion_Blur", DEF_MOTION_BLUR, t_Float},
151 {&fade_time, "fade_time", "Fade_Time", DEF_FADE_TIME, t_Float},
152 {&hold_time, "hold_time", "Hold_Time", DEF_HOLD_TIME, t_Float},
153 {&zoom, "zoom", "Zoom", DEF_ZOOM, t_Float},
157 static OptionStruct desc[] =
159 {"-/+ wire", "whether to do use wireframe instead of filled (faster)"},
160 {"-/+ blend", "whether to do enable blending (slower)"},
161 {"-/+ fog", "whether to do enable fog (slower)"},
162 {"-/+ antialias", "whether to do enable antialiased lines (slower)"},
163 {"-/+ walls", "whether to add walls to the blob space (slower)"},
164 {"-/+ texture", "whether to add a texture to the blob (slower)"},
165 {"-/+ colour", "whether to colour the blob"},
166 {"-/+ offset_texture", "whether to offset texture co-ordinates"},
167 {"-/+ paint_background", "whether to display a background texture (slower)"},
168 {"-resolution", "Resolution of blob tesselation"},
169 {"-bumps", "Number of bumps used to disturb blob"},
170 {"-motion_blur", "Fade blob images (higher number = faster fade)"},
171 {"-fade_time", "Number of frames to transistion to next image"},
172 {"-hold_time", "Number of frames before next image"},
175 ENTRYPOINT ModeSpecOpt mirrorblob_opts = {countof(opts), opts, countof(vars), vars, desc};
178 ModStruct mirrorblob_description =
179 {"mirrorblob", "init_mirrorblob", "draw_mirrorblob", "release_mirrorblob",
180 "draw_mirrorblob", "init_mirrorblob", "handle_event", &mirrorblob_opts,
181 1000, 1, 2, 1, 4, 1.0, "",
182 "OpenGL mirrorblob", 0, NULL};
186 /*****************************************************************************
187 * Types used in blob code
188 *****************************************************************************/
210 GLubyte red, green, blue, alpha;
215 Vector3D initial_position;
222 int node1, node2, node3;
224 double length1, length2, length3;
227 /* Structure to hold data about bumps used to distortion sphere */
230 double cx, cy, cpower, csize;
231 double ax, ay, power, size;
232 double mx, my, mpower, msize;
233 double vx, vy, vpower, vsize;
237 /* Vertices of a tetrahedron */
238 #define sqrt_3 0.5773502692
241 #define PPP { sqrt_3, sqrt_3, sqrt_3 } /* +X, +Y, +Z */
242 #define MMP { -sqrt_3, -sqrt_3, sqrt_3 } /* -X, -Y, +Z */
243 #define MPM { -sqrt_3, sqrt_3, -sqrt_3 } /* -X, +Y, -Z */
244 #define PMM { sqrt_3, -sqrt_3, -sqrt_3 } /* +X, -Y, -Z */
246 /* Structure describing a tetrahedron */
247 Vector3D tetrahedron[4][3] = {
254 /*****************************************************************************
256 *****************************************************************************/
258 const Vector3D zero_vector = { 0.0, 0.0, 0.0 };
260 /* Use 2 textures to allow a gradual fade between images */
261 #define NUM_TEXTURES 2
262 #define BUMP_ARRAY_SIZE 1024
271 /* structure for holding the mirrorblob data */
273 int screen_width, screen_height;
274 GLXContext *glx_context;
278 /* Parameters controlling the position of the blob as a whole */
279 Vector3D blob_center;
280 Vector3D blob_anchor;
281 Vector3D blob_velocity;
284 /* Count of the total number of nodes and faces used to tesselate the blob */
294 Vector2D *tex_coords;
296 /* Pointer to the bump function results */
297 double *bump_shape, *wall_shape;
299 Bump_Data *bump_data;
301 /* Use 2 textures to allow a gradual fade between images */
304 /* Ratio of used texture size to total texture size */
305 GLfloat tex_width[NUM_TEXTURES], tex_height[NUM_TEXTURES];
306 GLuint textures[NUM_TEXTURES];
309 double state_start_time;
314 Bool waiting_for_image_p;
317 trackball_state *trackball;
322 static mirrorblobstruct *Mirrorblob = NULL;
324 /******************************************************************************
326 * Returns the current time in seconds as a double. Shamelessly borrowed from
334 # ifdef GETTIMEOFDAY_TWO_ARGS
336 gettimeofday(&now, &tzp);
341 return (now.tv_sec + ((double) now.tv_usec * 0.000001));
344 /******************************************************************************
346 * Change to the projection matrix and set our viewing volume.
350 reset_projection(int width, int height)
352 glMatrixMode (GL_PROJECTION);
354 gluPerspective (60.0, 1.0, 1.0, 1024.0 );
355 glMatrixMode (GL_MODELVIEW);
359 /******************************************************************************
361 * Calculate the dot product of two vectors u and v
362 * Dot product u.v = |u||v|cos(theta)
363 * Where theta = angle between u and v
366 dot (const Vector3D u, const Vector3D v)
368 return (u.x * v.x) + (u.y * v.y) + (u.z * v.z);
371 /******************************************************************************
373 * Calculate the cross product of two vectors.
374 * Gives a vector perpendicular to u and v with magnitude |u||v|sin(theta)
375 * Where theta = angle between u and v
377 static inline Vector3D
378 cross (const Vector3D u, const Vector3D v)
382 result.x = (u.y * v.z - u.z * v.y);
383 result.y = (u.z * v.x - u.x * v.z);
384 result.z = (u.x * v.y - u.y * v.x);
389 /******************************************************************************
391 * Add vector v to vector u
394 add (Vector3D *u, const Vector3D v)
401 /******************************************************************************
403 * Subtract vector v from vector u
405 static inline Vector3D
406 subtract (const Vector3D u, const Vector3D v)
410 result.x = u.x - v.x;
411 result.y = u.y - v.y;
412 result.z = u.z - v.z;
417 /******************************************************************************
419 * multiply vector v by scalar s
421 static inline Vector3D
422 scale (const Vector3D v, const double s)
432 /******************************************************************************
436 static inline Vector3D
437 normalise (const Vector3D v)
442 magnitude = sqrt (dot(v, v));
444 if (magnitude > 1e-300)
446 result = scale (v, 1.0 / magnitude);
451 result = zero_vector;
456 /******************************************************************************
458 * Calculate the transform matrix for the given quaternion
461 quaternion_transform (Quaternion q, GLdouble * transform)
469 transform[0] = (w * w) + (x * x) - (y * y) - (z * z);
470 transform[1] = (2.0 * x * y) + (2.0 * w * z);
471 transform[2] = (2.0 * x * z) - (2.0 * w * y);
474 transform[4] = (2.0 * x * y) - (2.0 * w * z);
475 transform[5] = (w * w) - (x * x) + (y * y) - (z * z);
476 transform[6] = (2.0 * y * z) + (2.0 * w * x);
479 transform[8] = (2.0 * x * z) + (2.0 * w * y);
480 transform[9] = (2.0 * y * z) - (2.0 * w * x);
481 transform[10] = (w * w) - (x * x) - (y * y) + (z * z);
487 transform[15] = (w * w) + (x * x) + (y * y) + (z * z);
490 /******************************************************************************
492 * Apply a matrix transform to the given vector
494 static inline Vector3D
495 vector_transform (Vector3D u, GLdouble * t)
499 result.x = (u.x * t[0] + u.y * t[4] + u.z * t[8] + 1.0 * t[12]);
500 result.y = (u.x * t[1] + u.y * t[5] + u.z * t[9] + 1.0 * t[13]);
501 result.z = (u.x * t[2] + u.y * t[6] + u.z * t[10] + 1.0 * t[14]);
506 /******************************************************************************
508 * Return a node that is on an arc between node1 and node2, where distance
509 * is the proportion of the distance from node1 to the total arc.
512 partial (Vector3D node1, Vector3D node2, double distance)
515 Vector3D rotation_axis;
516 GLdouble transformation[16];
520 rotation_axis = normalise (cross (node1, node2));
521 angle = acos (dot (node1, node2)) * distance;
523 rotation.x = rotation_axis.x * sin (angle / 2.0);
524 rotation.y = rotation_axis.y * sin (angle / 2.0);
525 rotation.z = rotation_axis.z * sin (angle / 2.0);
526 rotation.w = cos (angle / 2.0);
528 quaternion_transform (rotation, transformation);
530 result = vector_transform (node1, transformation);
535 /****************************************************************************
541 image_loaded_cb (const char *filename, XRectangle *geometry,
542 int image_width, int image_height,
543 int texture_width, int texture_height,
546 mirrorblobstruct *mp = (mirrorblobstruct *) closure;
548 int texture_index = -1;
551 glGetIntegerv (GL_TEXTURE_BINDING_2D, &texid);
552 if (texid < 0) abort();
554 for (i = 0; i < NUM_TEXTURES; i++) {
555 if (mp->textures[i] == texid) {
560 if (texture_index < 0) abort();
562 mp->tex_width [texture_index] = (GLfloat) image_width / texture_width;
563 mp->tex_height[texture_index] = -(GLfloat) image_height / texture_height;
565 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
566 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
567 (mp->mipmap_p ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR));
568 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
569 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
570 glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
572 mp->waiting_for_image_p = False;
573 mp->first_image_p = True;
578 grab_texture(ModeInfo *mi, int texture_index)
580 mirrorblobstruct *mp = &Mirrorblob[MI_SCREEN(mi)];
582 mp->waiting_for_image_p = True;
584 load_texture_async (mi->xgwa.screen, mi->window,
585 *mp->glx_context, 0, 0, mp->mipmap_p,
586 mp->textures[texture_index],
587 image_loaded_cb, mp);
590 /******************************************************************************
592 * Generate internal parameters based on supplied options the parameters to
593 * ensure they are consistant.
598 /* In wire frame mode do not draw a texture */
605 /* Need to load textures if either the blob or the backgound has an image */
606 if (do_texture || do_paint_background)
608 load_textures = True;
612 load_textures = False;
615 /* If theres no texture don't calculate co-ordinates. */
618 offset_texture = False;
624 /******************************************************************************
626 * Initialise the openGL state data.
629 initialize_gl(ModeInfo *mi, GLsizei width, GLsizei height)
631 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
633 /* Lighting values */
634 GLfloat ambientLight[] = { 0.2f, 0.2f, 0.2f, 1.0f };
636 GLfloat lightPos0[] = {500.0f, 100.0f, 200.0f, 1.0f };
637 GLfloat whiteLight0[] = { 0.0f, 0.0f, 0.0f, 1.0f };
638 GLfloat sourceLight0[] = { 0.6f, 0.6f, 0.6f, 1.0f };
639 GLfloat specularLight0[] = { 0.8f, 0.8f, 0.9f, 1.0f };
641 GLfloat lightPos1[] = {0.0f, -500.0f, 500.0f, 1.0f };
642 GLfloat whiteLight1[] = { 0.0f, 0.0f, 0.0f, 1.0f };
643 GLfloat sourceLight1[] = { 0.6f, 0.6f, 0.6f, 1.0f };
644 GLfloat specularLight1[] = { 0.7f, 0.7f, 0.7f, 1.0f };
646 GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
648 GLfloat fogColor[4] = { 0.4, 0.4, 0.5, 0.1 };
650 /* Set the internal parameters based on the configuration settings */
653 /* Set the viewport to the width and heigh of the window */
654 glViewport (0, 0, width, height );
659 glEnable(GL_LINE_SMOOTH);
660 glEnable(GL_POLYGON_SMOOTH);
663 /* The blend function is used for trasitioning between two images even when
664 * blend is not selected.
666 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
671 glFogfv(GL_FOG_COLOR, fogColor);
672 glFogf(GL_FOG_DENSITY, 0.50);
673 glFogf(GL_FOG_START, 15.0);
674 glFogf(GL_FOG_END, 30.0);
677 /* Set the shading model to smooth (Gouraud shading). */
678 glShadeModel (GL_SMOOTH);
680 /* Set the clear color. */
681 glClearColor( 0, 0, 0, 0 );
683 glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambientLight);
684 glLightfv (GL_LIGHT0, GL_AMBIENT, whiteLight0);
685 glLightfv (GL_LIGHT0, GL_DIFFUSE, sourceLight0);
686 glLightfv (GL_LIGHT0, GL_SPECULAR, specularLight0);
687 glLightfv (GL_LIGHT0, GL_POSITION, lightPos0);
688 glEnable (GL_LIGHT0);
689 glLightfv (GL_LIGHT1, GL_AMBIENT, whiteLight1);
690 glLightfv (GL_LIGHT1, GL_DIFFUSE, sourceLight1);
691 glLightfv (GL_LIGHT1, GL_SPECULAR, specularLight1);
692 glLightfv (GL_LIGHT1, GL_POSITION, lightPos1);
693 glEnable (GL_LIGHT1);
694 glEnable (GL_LIGHTING);
696 /* Enable color tracking */
697 glEnable (GL_COLOR_MATERIAL);
699 /* Set Material properties to follow glColor values */
700 glColorMaterial (GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
702 /* Set all materials to have specular reflectivity */
703 glMaterialfv (GL_FRONT, GL_SPECULAR, specref);
704 glMateriali (GL_FRONT, GL_SHININESS, 32);
706 /* Let GL implementation scale normal vectors. */
707 glEnable (GL_NORMALIZE);
712 glLightModeli (GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
713 glEnable (GL_TEXTURE_2D);
715 gp->current_texture = 0;
716 glGenTextures (NUM_TEXTURES, gp->textures);
717 grab_texture (mi, gp->current_texture);
721 glEnableClientState (GL_TEXTURE_COORD_ARRAY);
723 glMatrixMode (GL_TEXTURE);
724 glRotated (180.0, 1.0, 0.0, 0.0);
725 glMatrixMode (GL_MODELVIEW);
730 glEnableClientState (GL_COLOR_ARRAY);
732 glEnableClientState (GL_NORMAL_ARRAY);
733 glEnableClientState (GL_VERTEX_ARRAY);
735 /* Clear the buffer since this is not done during a draw with motion blur */
736 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
739 /******************************************************************************
741 * Initialise the openGL state data.
744 set_blob_gl_state(GLdouble alpha)
748 glEnable(GL_LINE_SMOOTH);
749 glEnable(GL_POLYGON_SMOOTH);
754 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
758 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
761 /* The blend function is used for trasitioning between two images even when
762 * blend is not selected.
764 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
769 glCullFace (GL_BACK);
770 glEnable (GL_CULL_FACE);
771 glFrontFace (GL_CCW);
775 glDisable (GL_CULL_FACE);
781 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
782 /* Set the default blob colour to off-white. */
783 glColor4d (0.9, 0.9, 1.0, alpha);
788 glColor4d (0.9, 0.9, 1.0, 1.0);
791 glEnable(GL_DEPTH_TEST);
792 glEnable(GL_LIGHTING);
795 /******************************************************************************
797 * Initialise the data required to draw the blob allocating the memory as
800 * Return 0 on success.
803 initialise_blob(mirrorblobstruct *gp,
809 int i, u, v, node, side, face, base, base2 = 0;
810 int nodes_on_edge = resolution;
811 Vector3D node1, node2, result;
813 if (nodes_on_edge < 2)
816 gp->num_nodes = 2 * nodes_on_edge * nodes_on_edge - 4 * nodes_on_edge + 4;
817 gp->num_faces = 4 * (nodes_on_edge - 1) * (nodes_on_edge - 1);
819 gp->nodes = (Node_Data *) malloc (gp->num_nodes * sizeof (Node_Data));
822 fprintf (stderr, "Couldn't allocate gp->nodes buffer\n");
826 gp->faces = (Face_Data *) malloc (gp->num_faces * sizeof (Face_Data));
829 fprintf (stderr, "Couldn't allocate faces data buffer\n");
833 gp->bump_data = (Bump_Data *) malloc (bumps * sizeof (Bump_Data));
836 fprintf(stderr, "Couldn't allocate bump data buffer\n");
840 gp->bump_shape = (double *)malloc(bump_array_size * sizeof(double));
843 fprintf(stderr, "Couldn't allocate bump buffer\n");
847 gp->wall_shape = (double *)malloc(bump_array_size * sizeof(double));
850 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");
860 glVertexPointer (3, GL_DOUBLE, 0, (GLvoid *) gp->dots);
862 gp->normals = (Vector3D *)malloc(gp->num_nodes * sizeof(Vector3D));
865 fprintf(stderr, "Couldn't allocate normals buffer\n");
868 glNormalPointer (GL_DOUBLE, 0, (GLvoid *) gp->normals);
872 gp->colours = (Colour *)malloc(gp->num_nodes * sizeof(Colour));
875 fprintf(stderr, "Couldn't allocate colours buffer\n");
878 glColorPointer (4, GL_UNSIGNED_BYTE, 0, (GLvoid *) gp->colours);
883 gp->tex_coords = (Vector2D *)malloc(gp->num_nodes * sizeof(Vector2D));
886 fprintf(stderr, "Couldn't allocate gp->tex_coords buffer\n");
889 glTexCoordPointer (2, GL_DOUBLE, 0, (GLvoid *) gp->tex_coords);
892 /* Initialise bump data */
893 for (i = 0; i < bumps; i++)
895 gp->bump_data[i].ax = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
896 gp->bump_data[i].ay = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
897 gp->bump_data[i].power = (5.0 / pow(bumps, 0.75)) * (((double)random() / (double)RAND_MAX) - 0.5);
898 gp->bump_data[i].size = 0.1 + 0.5 * (((double)random() / (double)RAND_MAX));
900 gp->bump_data[i].pos.x = 1.5 * sin(PI * gp->bump_data[i].ay)
901 * cos(PI * gp->bump_data[i].ax);
902 gp->bump_data[i].pos.y = 1.5 * cos(PI * gp->bump_data[i].ay);
903 gp->bump_data[i].pos.z = 1.5 * sin(PI * gp->bump_data[i].ay)
904 * sin(PI * gp->bump_data[i].ax);
906 gp->bump_data[i].cx = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
907 gp->bump_data[i].cy = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
908 gp->bump_data[i].cpower = (5.0 / pow(bumps, 0.75)) * (((double)random() / (double)RAND_MAX) - 0.5);
909 gp->bump_data[i].csize = 0.35; /*0.1 + 0.25 * (((double)random() / (double)RAND_MAX));*/
911 gp->bump_data[i].vx = 0.0;
912 gp->bump_data[i].vy = 0.0;
913 gp->bump_data[i].vpower = 0.0;
914 gp->bump_data[i].vsize = 0.0;
916 gp->bump_data[i].mx = 0.003 * ((double)random() / (double)RAND_MAX);
917 gp->bump_data[i].my = 0.003 * ((double)random() / (double)RAND_MAX);
918 gp->bump_data[i].mpower = 0.003 * ((double)random() / (double)RAND_MAX);
919 gp->bump_data[i].msize = 0.003 * ((double)random() / (double)RAND_MAX);
922 /* Initialise lookup table of bump strength */
923 for (i = 0; i < bump_array_size; i++)
926 xd = i / (double)bump_array_size;
928 xd2 = 48.0 * xd * xd;
929 gp->bump_shape[i] = 0.1 / (xd2 + 0.1);
931 xd2 = 40.0 * xd * xd * xd * xd;
932 gp->wall_shape[i] = 0.4 / (xd2 + 0.1);
937 for (side = 0; side < 4; side++)
945 * The start and end of the for loops below are modified based on the
946 * side of the tetrahedron that is being calculated to avoid duplication
947 * of the gp->nodes that are on the edges of the tetrahedron.
949 for (u = (side > 1); u < (nodes_on_edge - (side > 0)); u++)
951 node1 = partial (normalise (tetrahedron[side][0]),
952 normalise (tetrahedron[side][1]),
953 u / (double) (nodes_on_edge - 1));
954 node2 = partial (normalise (tetrahedron[side][0]),
955 normalise (tetrahedron[side][2]),
956 u / (double) (nodes_on_edge - 1));
958 for (v = (side > 1); v <= (u - (side > 2)); v++)
961 result = partial (node1, node2, v / (double) u);
965 gp->nodes[node].position = normalise (result);
966 gp->nodes[node].initial_position = gp->nodes[node].position;
967 gp->nodes[node].normal = zero_vector;
973 * Determine which nodes make up each face. The complexity is caused
974 * by having to determine the correct nodes for the edges of the
975 * tetrahedron since the common nodes on the edges are only calculated
978 for (u = 0; u < (nodes_on_edge - 1); u++)
980 for (v = 0; v <= u; v++)
985 gp->faces[face].node1 = base + ((u * (u + 1)) / 2) + v;
986 gp->faces[face].node2 =
987 base + ((u + 1) * (u + 2)) / 2 + v + 1;
988 gp->faces[face].node3 =
989 base + ((u + 1) * (u + 2)) / 2 + v;
991 if ((side == 1) && (u == (nodes_on_edge - 2)))
993 gp->faces[face].node3 =
994 ((u + 1) * (u + 2)) / 2 +
995 nodes_on_edge - v - 1;
996 gp->faces[face].node2 =
997 ((u + 1) * (u + 2)) / 2 +
998 nodes_on_edge - v - 2;
1003 gp->faces[face].node1 =
1004 base + (((u - 1) * u) / 2) + v - 1;
1005 gp->faces[face].node2 = base + ((u) * (u + 1)) / 2 + v;
1006 gp->faces[face].node3 =
1007 base + ((u) * (u + 1)) / 2 + v - 1;
1009 if (u == (nodes_on_edge - 2))
1011 int n = nodes_on_edge - v - 1;
1012 gp->faces[face].node2 =
1014 (nodes_on_edge + 1)) / 2) +
1015 ((n - 1) * (n + 0)) / 2;
1016 gp->faces[face].node3 =
1018 (nodes_on_edge + 1)) / 2) +
1019 ((n + 0) * (n + 1)) / 2;
1023 gp->faces[face].node1 = (((u + 1) * (u + 2)) / 2) - 1;
1024 gp->faces[face].node3 = (((u + 2) * (u + 3)) / 2) - 1;
1029 gp->faces[face].node1 =
1030 base + (((u - 2) * (u - 1)) / 2) + v - 1;
1031 gp->faces[face].node2 = base + ((u - 1) * u) / 2 + v;
1032 gp->faces[face].node3 = base + ((u - 1) * u) / 2 + v - 1;
1036 gp->faces[face].node1 =
1037 base2 + ((u * (u + 1)) / 2) - 1;
1038 gp->faces[face].node3 =
1039 base2 + ((u + 1) * (u + 2)) / 2 - 1;
1041 if (u == (nodes_on_edge - 2))
1043 gp->faces[face].node3 =
1045 (nodes_on_edge + 1)) / 2) +
1046 ((v + 1) * (v + 2)) / 2 - 1;
1047 gp->faces[face].node2 =
1049 (nodes_on_edge + 1)) / 2) +
1050 ((v + 2) * (v + 3)) / 2 - 1;
1054 gp->faces[face].node1 = (u * (u + 1)) / 2;
1055 gp->faces[face].node2 = ((u + 1) * (u + 2)) / 2;
1065 gp->faces[face].node1 = base + ((u * (u + 1)) / 2) + v;
1066 gp->faces[face].node2 =
1067 base + ((u * (u + 1)) / 2) + v + 1;
1068 gp->faces[face].node3 =
1069 base + (((u + 1) * (u + 2)) / 2) + v + 1;
1071 if ((side == 1) && (u == (nodes_on_edge - 2)))
1073 gp->faces[face].node3 =
1074 ((u + 1) * (u + 2)) / 2 +
1075 nodes_on_edge - v - 2;
1080 gp->faces[face].node1 =
1081 base + ((u * (u - 1)) / 2) + v - 1;
1082 gp->faces[face].node2 = base + ((u * (u - 1)) / 2) + v;
1083 gp->faces[face].node3 = base + ((u * (u + 1)) / 2) + v;
1085 if (u == (nodes_on_edge - 2))
1087 int n = nodes_on_edge - v - 1;
1088 gp->faces[face].node3 =
1090 (nodes_on_edge + 1)) / 2) +
1091 ((n + 0) * (n - 1)) / 2;
1095 gp->faces[face].node1 = (((u + 1) * (u + 2)) / 2) - 1;
1100 gp->faces[face].node1 =
1101 base + (((u - 2) * (u - 1)) / 2) + v - 1;
1102 gp->faces[face].node2 =
1103 base + (((u - 2) * (u - 1)) / 2) + v;
1104 gp->faces[face].node3 = base + (((u - 1) * u) / 2) + v;
1108 gp->faces[face].node1 = base2 + (u * (u + 1)) / 2 - 1;
1110 if (u == (nodes_on_edge - 2))
1112 gp->faces[face].node3 =
1113 ((nodes_on_edge * (nodes_on_edge + 1)) / 2) +
1114 ((v + 2) * (v + 3)) / 2 - 1;
1118 gp->faces[face].node2 = (u * (u + 1)) / 2;
1130 /******************************************************************************
1132 * Return the magnitude of the given vector
1134 static inline double
1137 return sqrt (u.x * u.x + u.y * u.y + u.z * u.z);
1140 /******************************************************************************
1142 * Calculate the blob shape.
1145 calc_blob(mirrorblobstruct *gp,
1148 int bump_array_size,
1152 /* Loop variables */
1154 /* position of a node */
1157 Vector3D bump_vector;
1160 /* Update position and strength of bumps used to distort the blob */
1161 for (i = 0; i < bumps; i++)
1163 gp->bump_data[i].vx += gp->bump_data[i].mx*(gp->bump_data[i].cx - gp->bump_data[i].ax);
1164 gp->bump_data[i].vy += gp->bump_data[i].my*(gp->bump_data[i].cy - gp->bump_data[i].ay);
1165 gp->bump_data[i].vpower += gp->bump_data[i].mpower
1166 * (gp->bump_data[i].cpower - gp->bump_data[i].power);
1167 gp->bump_data[i].vsize += gp->bump_data[i].msize
1168 * (gp->bump_data[i].csize - gp->bump_data[i].size);
1170 gp->bump_data[i].ax += 0.1 * gp->bump_data[i].vx;
1171 gp->bump_data[i].ay += 0.1 * gp->bump_data[i].vy;
1172 gp->bump_data[i].power += 0.1 * gp->bump_data[i].vpower;
1173 gp->bump_data[i].size += 0.1 * gp->bump_data[i].vsize;
1175 gp->bump_data[i].pos.x = 1.0 * sin(PI * gp->bump_data[i].ay)
1176 * cos(PI * gp->bump_data[i].ax);
1177 gp->bump_data[i].pos.y = 1.0 * cos(PI * gp->bump_data[i].ay);
1178 gp->bump_data[i].pos.z = 1.0 * sin(PI * gp->bump_data[i].ay)
1179 * sin(PI * gp->bump_data[i].ax);
1182 /* Update calculate new position for each vertex based on an offset from
1183 * the initial position
1185 gp->blob_force = zero_vector;
1186 for (index = 0; index < gp->num_nodes; ++index)
1188 node = gp->nodes[index].initial_position;
1189 gp->nodes[index].normal = zero_vector;
1191 offset = zero_vector;
1192 for ( i = 0; i < bumps; i++)
1194 bump_vector = subtract(gp->bump_data[i].pos, node);
1196 dist = bump_array_size * dot(bump_vector, bump_vector) * gp->bump_data[i].size;
1198 if (dist < bump_array_size)
1200 add(&offset, scale(node, gp->bump_data[i].power * gp->bump_shape[dist]));
1201 add(&gp->blob_force, scale(node, gp->bump_data[i].power * gp->bump_shape[dist]));
1206 node = scale(node, zoom);
1207 add(&node, gp->blob_center);
1211 if (node.z < -limit) node.z = -limit;
1212 if (node.z > limit) node.z = limit;
1214 dist = bump_array_size * (node.z + limit) * (node.z + limit) * 0.5;
1215 if (dist < bump_array_size)
1217 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1218 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1219 gp->blob_force.z += (node.z + limit);
1223 dist = bump_array_size * (node.z - limit) * (node.z - limit) * 0.5;
1224 if (dist < bump_array_size)
1226 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1227 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1228 gp->blob_force.z -= (node.z - limit);
1231 if (node.y < -limit) node.y = -limit;
1232 if (node.y > limit) node.y = limit;
1234 dist = bump_array_size * (node.y + limit) * (node.y + limit) * 0.5;
1235 if (dist < bump_array_size)
1237 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1238 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1239 gp->blob_force.y += (node.y + limit);
1243 dist = bump_array_size * (node.y - limit) * (node.y - limit) * 0.5;
1244 if (dist < bump_array_size)
1246 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1247 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1248 gp->blob_force.y -= (node.y - limit);
1252 if (node.x < -limit) node.x = -limit;
1253 if (node.x > limit) node.x = limit;
1255 dist = bump_array_size * (node.x + limit) * (node.x + limit) * 0.5;
1256 if (dist < bump_array_size)
1258 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1259 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1260 gp->blob_force.x += (node.x + limit);
1264 dist = bump_array_size * (node.x - limit) * (node.x - limit) * 0.5;
1265 if (dist < bump_array_size)
1267 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1268 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1269 gp->blob_force.x -= (node.x - limit);
1273 if (node.y < -limit) node.y = -limit;
1274 if (node.y > limit) node.y = limit;
1277 gp->dots[index] = node;
1280 /* Determine the normal for each face */
1281 for (face = 0; face < gp->num_faces; face++)
1283 /* Use nodeers to indexed nodes to help readability */
1284 Node_Data *node1 = &gp->nodes[gp->faces[face].node1];
1285 Node_Data *node2 = &gp->nodes[gp->faces[face].node2];
1286 Node_Data *node3 = &gp->nodes[gp->faces[face].node3];
1288 gp->faces[face].normal = cross(subtract(node2->position, node1->position),
1289 subtract(node3->position, node1->position));
1291 /* Add the normal for the face onto the normal for the verticies of
1293 add(&node1->normal, gp->faces[face].normal);
1294 add(&node2->normal, gp->faces[face].normal);
1295 add(&node3->normal, gp->faces[face].normal);
1298 /* Use the normal to set the colour and texture */
1299 if (do_colour || do_texture)
1301 for (index = 0; index < gp->num_nodes; ++index)
1303 gp->normals[index] = normalise(gp->nodes[index].normal);
1307 gp->colours[index].red = (int)(255.0 * fabs(gp->normals[index].x));
1308 gp->colours[index].green = (int)(255.0 * fabs(gp->normals[index].y));
1309 gp->colours[index].blue = (int)(255.0 * fabs(gp->normals[index].z));
1310 gp->colours[index].alpha = (int)(255.0 * fade);
1316 gp->tex_coords[index].x = gp->dots[index].x * 0.125 + 0.5
1317 * (1.0 + 0.25 * asin(gp->normals[index].x) / (0.5 * PI));
1318 gp->tex_coords[index].y = -gp->dots[index].y * 0.125 - 0.5
1319 * (1.0 + 0.25 * asin(gp->normals[index].y) / (0.5 * PI));
1323 gp->tex_coords[index].x = 0.5
1324 * (1.0 + asin(gp->normals[index].x) / (0.5 * PI));
1325 gp->tex_coords[index].y = -0.5
1326 * (1.0 + asin(gp->normals[index].y) / (0.5 * PI));
1328 /* Adjust the texture co-ordinates to from range 0..1 to
1329 * 0..width or 0..height as appropriate
1331 gp->tex_coords[index].x *= gp->tex_width[gp->current_texture];
1332 gp->tex_coords[index].y *= gp->tex_height[gp->current_texture];
1337 /* Update the center of the whole blob */
1338 add(&gp->blob_velocity, scale (subtract (gp->blob_anchor, gp->blob_center), 1.0 / 80.0));
1339 add(&gp->blob_velocity, scale (gp->blob_force, 0.01 / gp->num_nodes));
1341 add(&gp->blob_center, scale(gp->blob_velocity, 0.5));
1343 gp->blob_velocity = scale(gp->blob_velocity, 0.999);
1346 /******************************************************************************
1348 * Draw the blob shape.
1352 draw_blob (mirrorblobstruct *gp)
1356 glMatrixMode (GL_MODELVIEW);
1359 /* Move down the z-axis. */
1360 glTranslatef (0.0, 0.0, -4.0);
1362 gltrackball_rotate (gp->trackball);
1364 /* glColor4ub (255, 0, 0, 128); */
1365 glBegin (GL_TRIANGLES);
1366 for (face = 0; face < gp->num_faces; face++)
1368 glArrayElement (gp->faces[face].node1);
1369 glArrayElement (gp->faces[face].node2);
1370 glArrayElement (gp->faces[face].node3);
1376 /******************************************************************************
1378 * Draw the background image simply map a texture onto a full screen quad.
1381 draw_background (ModeInfo *mi)
1383 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1385 glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
1386 glEnable (GL_TEXTURE_2D);
1387 glDisable(GL_LIGHTING);
1388 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1390 /* Reset the projection matrix to make it easier to get the size of the quad
1393 glMatrixMode(GL_PROJECTION);
1397 glOrtho(0.0, MI_WIDTH(mi), MI_HEIGHT(mi), 0.0, -1000.0, 1000.0);
1401 glTexCoord2f (0.0, 0.0);
1404 glTexCoord2f (0.0, gp->tex_height[gp->current_texture]);
1405 glVertex2i (0, MI_HEIGHT(mi));
1407 glTexCoord2f (gp->tex_width[gp->current_texture], gp->tex_height[gp->current_texture]);
1408 glVertex2i (MI_WIDTH(mi), MI_HEIGHT(mi));
1410 glTexCoord2f (gp->tex_width[gp->current_texture], 0.0);
1411 glVertex2i (MI_WIDTH(mi), 0);
1415 glMatrixMode (GL_MODELVIEW);
1416 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1419 /******************************************************************************
1424 draw_scene(ModeInfo * mi)
1426 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1429 double current_time;
1430 check_gl_error ("draw_scene");
1432 glColor4d(1.0, 1.0, 1.0, 1.0);
1434 current_time = double_time();
1438 fade = 1.0 - (current_time - gp->state_start_time) / fade_time;
1441 case LOADING: /* FALL-THROUGH */
1447 /* Set the correct texture, when transitioning this ensures that the first draw
1448 * is the original texture (which has the new texture drawn over it with decreasing
1453 glBindTexture (GL_TEXTURE_2D, gp->textures[gp->current_texture]);
1456 glDisable (GL_DEPTH_TEST);
1457 if (do_paint_background)
1459 glEnable (GL_TEXTURE_2D);
1460 if (motion_blur > 0.0)
1462 glClear(GL_DEPTH_BUFFER_BIT);
1463 glEnable (GL_BLEND);
1464 glColor4d (1.0, 1.0, 1.0, motion_blur);
1468 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1470 draw_background (mi);
1472 /* When transitioning between two images paint the new image over the old
1473 * image with a varying alpha value to get a smooth fade.
1475 if (gp->state == TRANSITIONING)
1477 glEnable (GL_BLEND);
1478 /* Select the texture to transition to */
1479 glBindTexture (GL_TEXTURE_2D, gp->textures[1 - gp->current_texture]);
1480 glColor4d (1.0, 1.0, 1.0, 1.0 - fade);
1482 draw_background (mi);
1484 /* Select the original texture to draw the blob */
1485 glBindTexture (GL_TEXTURE_2D, gp->textures[gp->current_texture]);
1487 /* Clear the depth buffer bit so the backgound is behind the blob */
1488 glClear(GL_DEPTH_BUFFER_BIT);
1490 else if (motion_blur > 0.0)
1492 glEnable (GL_BLEND);
1493 glColor4d (0.0, 0.0, 0.0, motion_blur);
1494 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1495 glTranslatef (0.0, 0.0, -4.0);
1496 glRectd (-10.0, -10.0, 10.0, 10.0);
1499 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1501 glClear (GL_DEPTH_BUFFER_BIT);
1505 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1511 glDisable (GL_TEXTURE_2D);
1514 calc_blob(gp, MI_WIDTH(mi), MI_HEIGHT(mi), BUMP_ARRAY_SIZE, 2.5, fade * blend);
1516 set_blob_gl_state(fade * blend);
1520 /* Disable the three colour chanels so that only the depth buffer is updated */
1521 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1523 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1524 glDepthFunc(GL_LEQUAL);
1526 glDepthFunc(GL_LEQUAL);
1529 /* While transitioning between images draw a second blob with a modified
1532 if (load_textures && (hold_time > 0))
1537 if ((current_time - gp->state_start_time) > hold_time)
1539 grab_texture(mi, 1 - gp->current_texture);
1540 gp->state = LOADING;
1545 /* Once the image has loaded move to the TRANSITIONING STATE */
1546 if (!gp->waiting_for_image_p)
1548 gp->state = TRANSITIONING;
1549 /* Get the time again rather than using the current time so
1550 * that the time taken by the grab_texture function is not part
1553 gp->state_start_time = double_time();
1559 /* If the blob is textured draw over existing blob to fade between
1564 /* Select the texture to transition to */
1565 glBindTexture (GL_TEXTURE_2D, gp->textures[1 - gp->current_texture]);
1566 glEnable (GL_BLEND);
1568 /* If colour is enabled update the alpha data in the buffer and
1569 * use that in the blending since the alpha of the incomming
1570 * verticies will not be correct
1574 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
1575 glClearColor(0.0, 0.0, 0.0, (1.0 - fade) * blend);
1576 glClear(GL_COLOR_BUFFER_BIT);
1577 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1578 glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
1582 glColor4d(0.9, 0.9, 1.0, (1.0 - fade) * blend);
1589 /* Restore the 'standard' blend functions. */
1590 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1594 if ((current_time - gp->state_start_time) > fade_time)
1596 gp->state = HOLDING;
1597 gp->state_start_time = current_time;
1598 gp->current_texture = 1 - gp->current_texture;
1606 /******************************************************************************
1608 * XMirrorblob screen update entry
1611 draw_mirrorblob(ModeInfo * mi)
1613 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1614 Display *display = MI_DISPLAY(mi);
1615 Window window = MI_WINDOW(mi);
1617 if (!gp->glx_context)
1620 /* Wait for the first image; for subsequent images, load them in the
1621 background while animating. */
1622 if (gp->waiting_for_image_p && gp->first_image_p)
1625 glXMakeCurrent(display, window, *(gp->glx_context));
1627 if (mi->fps_p) do_fps (mi);
1628 glXSwapBuffers(display, window);
1631 /******************************************************************************
1633 * XMirrorblob screen resize entry
1636 reshape_mirrorblob(ModeInfo *mi, int width, int height)
1638 glViewport( 0, 0, MI_WIDTH(mi), MI_HEIGHT(mi) );
1639 reset_projection(width, height);
1642 /****************************************************************************
1644 * Handle Mouse events
1647 mirrorblob_handle_event (ModeInfo * mi, XEvent * event)
1649 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN (mi)];
1651 if (event->xany.type == ButtonPress &&
1652 event->xbutton.button == Button1)
1654 gp->button_down = 1;
1655 gltrackball_start (gp->trackball, event->xbutton.x,
1656 event->xbutton.y, MI_WIDTH (mi), MI_HEIGHT (mi));
1659 else if (event->xany.type == ButtonRelease &&
1660 event->xbutton.button == Button1)
1662 gp->button_down = 0;
1665 else if (event->xany.type == ButtonPress &&
1666 event->xbutton.button == Button4)
1671 else if (event->xany.type == ButtonPress &&
1672 event->xbutton.button == Button5)
1678 else if (event->xany.type == MotionNotify && gp->button_down)
1680 gltrackball_track (gp->trackball, event->xmotion.x,
1681 event->xmotion.y, MI_WIDTH (mi), MI_HEIGHT (mi));
1687 /******************************************************************************
1689 * XMirrorblob initialise entry
1692 init_mirrorblob(ModeInfo * mi)
1694 int screen = MI_SCREEN(mi);
1696 mirrorblobstruct *gp;
1698 if (Mirrorblob == NULL)
1700 if ((Mirrorblob = (mirrorblobstruct *)
1701 calloc(MI_NUM_SCREENS(mi), sizeof (mirrorblobstruct))) == NULL)
1706 gp = &Mirrorblob[screen];
1708 gp->window = MI_WINDOW(mi);
1709 if ((gp->glx_context = init_GL(mi)) != NULL)
1711 reshape_mirrorblob(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1712 initialize_gl(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1718 gp->trackball = gltrackball_init ();
1720 initialise_blob(gp, MI_WIDTH(mi), MI_HEIGHT(mi), BUMP_ARRAY_SIZE);
1721 gp->state_start_time = double_time();
1723 gp->first_image_p = True;
1726 /******************************************************************************
1728 * XMirrorblob cleanup entry
1731 release_mirrorblob(ModeInfo * mi)
1733 if (Mirrorblob != NULL) {
1735 for (i = 0; i < MI_NUM_SCREENS(mi); i++) {
1736 mirrorblobstruct *gp = &Mirrorblob[i];
1737 if (gp->nodes) free(gp->nodes);
1738 if (gp->faces) free(gp->faces);
1739 if (gp->bump_data) free(gp->bump_data);
1740 if (gp->colours) free(gp->colours);
1741 if (gp->tex_coords) free(gp->tex_coords);
1742 if (gp->dots) free(gp->dots);
1743 if (gp->wall_shape) free(gp->wall_shape);
1744 if (gp->bump_shape) free(gp->bump_shape);
1753 XSCREENSAVER_MODULE ("MirrorBlob", mirrorblob)