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"
46 # define refresh_mirrorblob 0
48 # define mirrorblob_handle_event 0
50 # include "xlockmore.h"
51 #else /* !STANDALONE */
52 # include "xlock.h" /* from the xlockmore distribution */
53 #endif /* !STANDALONE */
55 #ifdef USE_GL /* whole file */
58 #define DEF_DELAY "10000"
59 #define DEF_FPS "False"
60 #define DEF_WIRE "False"
61 #define DEF_BLEND "1.0"
62 #define DEF_FOG "False"
63 #define DEF_ANTIALIAS "False"
64 #define DEF_WALLS "False"
65 #define DEF_COLOUR "False"
66 #define DEF_ASYNC "True"
67 #define DEF_TEXTURE "True"
68 #define DEF_OFFSET_TEXTURE "False"
69 #define DEF_PAINT_BACKGROUND "True"
70 #define DEF_RESOLUTION "30"
71 #define DEF_BUMPS "10"
72 #define DEF_MOTION_BLUR "0.0"
73 #define DEF_INCREMENTAL "0"
74 #define DEF_HOLD_TIME "30.0"
75 #define DEF_FADE_TIME "5.0"
76 #define DEF_ZOOM "1.0"
80 # include <X11/Xmu/Drawing.h>
82 # include <Xmu/Drawing.h>
86 #include "gltrackball.h"
87 #include "grab-ximage.h"
90 #define countof(x) (sizeof((x)) / sizeof((*x)))
92 #define PI 3.1415926535897
94 /* Options from command line */
96 static Bool wireframe;
98 static Bool do_antialias;
100 static Bool do_texture;
101 static Bool do_paint_background;
102 static Bool do_colour;
103 static Bool offset_texture;
104 static int resolution;
106 static float motion_blur;
107 static float fade_time;
108 static float hold_time;
111 /* Internal parameters based on supplied options */
113 static Bool load_textures;
115 static XrmOptionDescRec opts[] = {
116 {"-wire", ".blob.wire", XrmoptionNoArg, "true" },
117 {"+wire", ".blob.wire", XrmoptionNoArg, "false" },
118 {"-blend", ".blob.blend", XrmoptionSepArg, 0 },
119 {"-fog", ".blob.fog", XrmoptionNoArg, "true" },
120 {"+fog", ".blob.fog", XrmoptionNoArg, "false" },
121 {"-antialias", ".blob.antialias", XrmoptionNoArg, "true" },
122 {"+antialias", ".blob.antialias", XrmoptionNoArg, "false" },
123 {"-walls", ".blob.walls", XrmoptionNoArg, "true" },
124 {"+walls", ".blob.walls", XrmoptionNoArg, "false" },
125 {"-texture", ".blob.texture", XrmoptionNoArg, "true" },
126 {"+texture", ".blob.texture", XrmoptionNoArg, "false" },
127 {"-colour", ".blob.colour", XrmoptionNoArg, "true" },
128 {"+colour", ".blob.colour", XrmoptionNoArg, "false" },
129 {"-offset-texture", ".blob.offsetTexture", XrmoptionNoArg, "true" },
130 {"+offset-texture", ".blob.offsetTexture", XrmoptionNoArg, "false" },
131 {"-paint-background", ".blob.paintBackground", XrmoptionNoArg, "true" },
132 {"+paint-background", ".blob.paintBackground", XrmoptionNoArg, "false" },
133 {"-resolution", ".blob.resolution", XrmoptionSepArg, NULL },
134 {"-bumps", ".blob.bumps", XrmoptionSepArg, NULL },
135 {"-motion-blur", ".blob.motionBlur", XrmoptionSepArg, 0 },
136 {"-fade-time", ".blob.fadeTime", XrmoptionSepArg, 0 },
137 {"-hold-time", ".blob.holdTime", XrmoptionSepArg, 0 },
138 {"-zoom", ".blob.zoom", XrmoptionSepArg, 0 },
141 static argtype vars[] = {
142 {&wireframe, "wire", "Wire", DEF_WIRE, t_Bool},
143 {&blend, "blend", "Blend", DEF_BLEND, t_Float},
144 {&do_fog, "fog", "Fog", DEF_FOG, t_Bool},
145 {&do_antialias, "antialias", "Antialias", DEF_ANTIALIAS, t_Bool},
146 {&do_walls, "walls", "Walls", DEF_WALLS, t_Bool},
147 {&do_texture, "texture", "Texture", DEF_TEXTURE, t_Bool},
148 {&do_colour, "colour", "Colour", DEF_COLOUR, t_Bool},
149 {&offset_texture, "offsetTexture","OffsetTexture", DEF_OFFSET_TEXTURE, t_Bool},
150 {&do_paint_background,"paintBackground","PaintBackground", DEF_PAINT_BACKGROUND, t_Bool},
151 {&resolution, "resolution", "Resolution", DEF_RESOLUTION, t_Int},
152 {&bumps, "bumps", "Bump", DEF_BUMPS, t_Int},
153 {&motion_blur, "motionBlur", "MotionBlur", DEF_MOTION_BLUR, t_Float},
154 {&fade_time, "fadeTime", "FadeTime", DEF_FADE_TIME, t_Float},
155 {&hold_time, "holdTime", "HoldTime", DEF_HOLD_TIME, t_Float},
156 {&zoom, "zoom", "Zoom", DEF_ZOOM, t_Float},
160 static OptionStruct desc[] =
162 {"-/+ wire", "whether to do use wireframe instead of filled (faster)"},
163 {"-/+ blend", "whether to do enable blending (slower)"},
164 {"-/+ fog", "whether to do enable fog (slower)"},
165 {"-/+ antialias", "whether to do enable antialiased lines (slower)"},
166 {"-/+ walls", "whether to add walls to the blob space (slower)"},
167 {"-/+ texture", "whether to add a texture to the blob (slower)"},
168 {"-/+ colour", "whether to colour the blob"},
169 {"-/+ offset_texture", "whether to offset texture co-ordinates"},
170 {"-/+ paint_background", "whether to display a background texture (slower)"},
171 {"-resolution", "Resolution of blob tesselation"},
172 {"-bumps", "Number of bumps used to disturb blob"},
173 {"-motion_blur", "Fade blob images (higher number = faster fade)"},
174 {"-fade_time", "Number of frames to transistion to next image"},
175 {"-hold_time", "Number of frames before next image"},
178 ENTRYPOINT ModeSpecOpt mirrorblob_opts = {countof(opts), opts, countof(vars), vars, desc};
181 ModStruct mirrorblob_description =
182 {"mirrorblob", "init_mirrorblob", "draw_mirrorblob", "release_mirrorblob",
183 "draw_mirrorblob", "init_mirrorblob", "handle_event", &mirrorblob_opts,
184 1000, 1, 2, 1, 4, 1.0, "",
185 "OpenGL mirrorblob", 0, NULL};
188 /*****************************************************************************
189 * Types used in blob code
190 *****************************************************************************/
212 GLubyte red, green, blue, alpha;
217 Vector3D initial_position;
224 int node1, node2, node3;
226 double length1, length2, length3;
229 /* Structure to hold data about bumps used to distortion sphere */
232 double cx, cy, cpower, csize;
233 double ax, ay, power, size;
234 double mx, my, mpower, msize;
235 double vx, vy, vpower, vsize;
239 /* Vertices of a tetrahedron */
240 #define sqrt_3 0.5773502692
243 #define PPP { sqrt_3, sqrt_3, sqrt_3 } /* +X, +Y, +Z */
244 #define MMP { -sqrt_3, -sqrt_3, sqrt_3 } /* -X, -Y, +Z */
245 #define MPM { -sqrt_3, sqrt_3, -sqrt_3 } /* -X, +Y, -Z */
246 #define PMM { sqrt_3, -sqrt_3, -sqrt_3 } /* +X, -Y, -Z */
248 /* Structure describing a tetrahedron */
249 static Vector3D tetrahedron[4][3] = {
256 /*****************************************************************************
258 *****************************************************************************/
260 static const Vector3D zero_vector = { 0.0, 0.0, 0.0 };
262 /* Use 2 textures to allow a gradual fade between images */
263 #define NUM_TEXTURES 2
264 #define BUMP_ARRAY_SIZE 1024
274 /* structure for holding the mirrorblob data */
276 int screen_width, screen_height;
277 GLXContext *glx_context;
281 /* Parameters controlling the position of the blob as a whole */
282 Vector3D blob_center;
283 Vector3D blob_anchor;
284 Vector3D blob_velocity;
287 /* Count of the total number of nodes and faces used to tesselate the blob */
297 Vector2D *tex_coords;
299 /* Pointer to the bump function results */
300 double *bump_shape, *wall_shape;
302 Bump_Data *bump_data;
304 /* Use 2 textures to allow a gradual fade between images */
307 /* Ratio of used texture size to total texture size */
308 GLfloat tex_width[NUM_TEXTURES], tex_height[NUM_TEXTURES];
309 GLuint textures[NUM_TEXTURES];
312 double state_start_time;
317 Bool waiting_for_image_p;
320 trackball_state *trackball;
325 static mirrorblobstruct *Mirrorblob = NULL;
327 /******************************************************************************
329 * Returns the current time in seconds as a double. Shamelessly borrowed from
337 # ifdef GETTIMEOFDAY_TWO_ARGS
339 gettimeofday(&now, &tzp);
344 return (now.tv_sec + ((double) now.tv_usec * 0.000001));
347 /******************************************************************************
349 * Change to the projection matrix and set our viewing volume.
353 reset_projection(int width, int height)
355 glMatrixMode (GL_PROJECTION);
357 gluPerspective (60.0, 1.0, 1.0, 1024.0 );
358 glMatrixMode (GL_MODELVIEW);
362 /******************************************************************************
364 * Calculate the dot product of two vectors u and v
365 * Dot product u.v = |u||v|cos(theta)
366 * Where theta = angle between u and v
369 dot (const Vector3D u, const Vector3D v)
371 return (u.x * v.x) + (u.y * v.y) + (u.z * v.z);
374 /******************************************************************************
376 * Calculate the cross product of two vectors.
377 * Gives a vector perpendicular to u and v with magnitude |u||v|sin(theta)
378 * Where theta = angle between u and v
380 static inline Vector3D
381 cross (const Vector3D u, const Vector3D v)
385 result.x = (u.y * v.z - u.z * v.y);
386 result.y = (u.z * v.x - u.x * v.z);
387 result.z = (u.x * v.y - u.y * v.x);
392 /******************************************************************************
394 * Add vector v to vector u
397 add (Vector3D *u, const Vector3D v)
404 /******************************************************************************
406 * Subtract vector v from vector u
408 static inline Vector3D
409 subtract (const Vector3D u, const Vector3D v)
413 result.x = u.x - v.x;
414 result.y = u.y - v.y;
415 result.z = u.z - v.z;
420 /******************************************************************************
422 * multiply vector v by scalar s
424 static inline Vector3D
425 scale (const Vector3D v, const double s)
435 /******************************************************************************
439 static inline Vector3D
440 normalise (const Vector3D v)
445 magnitude = sqrt (dot(v, v));
447 if (magnitude > 1e-300)
449 result = scale (v, 1.0 / magnitude);
454 result = zero_vector;
459 /******************************************************************************
461 * Calculate the transform matrix for the given quaternion
464 quaternion_transform (Quaternion q, GLfloat * transform)
472 transform[0] = (w * w) + (x * x) - (y * y) - (z * z);
473 transform[1] = (2.0 * x * y) + (2.0 * w * z);
474 transform[2] = (2.0 * x * z) - (2.0 * w * y);
477 transform[4] = (2.0 * x * y) - (2.0 * w * z);
478 transform[5] = (w * w) - (x * x) + (y * y) - (z * z);
479 transform[6] = (2.0 * y * z) + (2.0 * w * x);
482 transform[8] = (2.0 * x * z) + (2.0 * w * y);
483 transform[9] = (2.0 * y * z) - (2.0 * w * x);
484 transform[10] = (w * w) - (x * x) - (y * y) + (z * z);
490 transform[15] = (w * w) + (x * x) + (y * y) + (z * z);
493 /******************************************************************************
495 * Apply a matrix transform to the given vector
497 static inline Vector3D
498 vector_transform (Vector3D u, GLfloat * t)
502 result.x = (u.x * t[0] + u.y * t[4] + u.z * t[8] + 1.0 * t[12]);
503 result.y = (u.x * t[1] + u.y * t[5] + u.z * t[9] + 1.0 * t[13]);
504 result.z = (u.x * t[2] + u.y * t[6] + u.z * t[10] + 1.0 * t[14]);
509 /******************************************************************************
511 * Return a node that is on an arc between node1 and node2, where distance
512 * is the proportion of the distance from node1 to the total arc.
515 partial (Vector3D node1, Vector3D node2, double distance)
518 Vector3D rotation_axis;
519 GLfloat transformation[16];
523 rotation_axis = normalise (cross (node1, node2));
524 angle = acos (dot (node1, node2)) * distance;
526 rotation.x = rotation_axis.x * sin (angle / 2.0);
527 rotation.y = rotation_axis.y * sin (angle / 2.0);
528 rotation.z = rotation_axis.z * sin (angle / 2.0);
529 rotation.w = cos (angle / 2.0);
531 quaternion_transform (rotation, transformation);
533 result = vector_transform (node1, transformation);
538 /****************************************************************************
540 * Callback indicating a texture has loaded
543 image_loaded_cb (const char *filename, XRectangle *geometry,
544 int image_width, int image_height,
545 int texture_width, int texture_height,
548 mirrorblobstruct *mp = (mirrorblobstruct *) closure;
550 int texture_index = -1;
553 glGetIntegerv (GL_TEXTURE_BINDING_2D, &texid);
554 if (texid < 0) abort();
556 for (i = 0; i < NUM_TEXTURES; i++) {
557 if (mp->textures[i] == texid) {
562 if (texture_index < 0) abort();
564 mp->tex_width [texture_index] = (GLfloat) image_width / texture_width;
565 mp->tex_height[texture_index] = -(GLfloat) image_height / texture_height;
567 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
568 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
569 (mp->mipmap_p ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR));
570 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
571 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
572 glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
574 mp->waiting_for_image_p = False;
575 mp->first_image_p = True;
578 /* Load a new file into a texture
581 grab_texture(ModeInfo *mi, int texture_index)
583 mirrorblobstruct *mp = &Mirrorblob[MI_SCREEN(mi)];
586 int w = (MI_WIDTH(mi) / 2) - 1;
587 int h = (MI_HEIGHT(mi) / 2) - 1;
591 mp->waiting_for_image_p = True;
593 load_texture_async (mi->xgwa.screen, mi->window,
594 *mp->glx_context, w, h, mp->mipmap_p,
595 mp->textures[texture_index],
596 image_loaded_cb, mp);
600 /******************************************************************************
602 * Generate internal parameters based on supplied options the parameters to
603 * ensure they are consistant.
608 /* In wire frame mode do not draw a texture */
615 /* Need to load textures if either the blob or the backgound has an image */
616 if (do_texture || do_paint_background)
618 load_textures = True;
622 load_textures = False;
625 /* If theres no texture don't calculate co-ordinates. */
628 offset_texture = False;
634 /******************************************************************************
636 * Initialise the openGL state data.
639 initialize_gl(ModeInfo *mi, GLsizei width, GLsizei height)
641 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
643 /* Lighting values */
644 GLfloat ambientLight[] = { 0.2f, 0.2f, 0.2f, 1.0f };
646 GLfloat lightPos0[] = {500.0f, 100.0f, 200.0f, 1.0f };
647 GLfloat whiteLight0[] = { 0.0f, 0.0f, 0.0f, 1.0f };
648 GLfloat sourceLight0[] = { 0.6f, 0.6f, 0.6f, 1.0f };
649 GLfloat specularLight0[] = { 0.8f, 0.8f, 0.9f, 1.0f };
651 GLfloat lightPos1[] = {-50.0f, -100.0f, 2500.0f, 1.0f };
652 GLfloat whiteLight1[] = { 0.0f, 0.0f, 0.0f, 1.0f };
653 GLfloat sourceLight1[] = { 0.6f, 0.6f, 0.6f, 1.0f };
654 GLfloat specularLight1[] = { 0.7f, 0.7f, 0.7f, 1.0f };
656 GLfloat specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
658 GLfloat fogColor[4] = { 0.4, 0.4, 0.5, 0.1 };
660 /* Set the internal parameters based on the configuration settings */
663 /* Set the viewport to the width and heigh of the window */
664 glViewport (0, 0, width, height );
669 glEnable(GL_LINE_SMOOTH);
670 glEnable(GL_POLYGON_SMOOTH);
673 /* The blend function is used for trasitioning between two images even when
674 * blend is not selected.
676 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
681 glFogfv(GL_FOG_COLOR, fogColor);
682 glFogf(GL_FOG_DENSITY, 0.50);
683 glFogf(GL_FOG_START, 15.0);
684 glFogf(GL_FOG_END, 30.0);
687 /* Set the shading model to smooth (Gouraud shading). */
688 glShadeModel (GL_SMOOTH);
690 glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambientLight);
691 glLightfv (GL_LIGHT0, GL_AMBIENT, whiteLight0);
692 glLightfv (GL_LIGHT0, GL_DIFFUSE, sourceLight0);
693 glLightfv (GL_LIGHT0, GL_SPECULAR, specularLight0);
694 glLightfv (GL_LIGHT0, GL_POSITION, lightPos0);
695 glEnable (GL_LIGHT0);
696 glLightfv (GL_LIGHT1, GL_AMBIENT, whiteLight1);
697 glLightfv (GL_LIGHT1, GL_DIFFUSE, sourceLight1);
698 glLightfv (GL_LIGHT1, GL_SPECULAR, specularLight1);
699 glLightfv (GL_LIGHT1, GL_POSITION, lightPos1);
700 glEnable (GL_LIGHT1);
701 glEnable (GL_LIGHTING);
703 /* Enable color tracking */
704 glEnable (GL_COLOR_MATERIAL);
706 /* Set Material properties to follow glColor values */
707 glColorMaterial (GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
709 /* Set all materials to have specular reflectivity */
710 glMaterialfv (GL_FRONT, GL_SPECULAR, specref);
711 glMateriali (GL_FRONT, GL_SHININESS, 32);
713 /* Let GL implementation scale normal vectors. */
714 glEnable (GL_NORMALIZE);
719 glLightModeli (GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
720 glEnable (GL_TEXTURE_2D);
722 gp->current_texture = 0;
723 glGenTextures(NUM_TEXTURES, gp->textures);
724 grab_texture(mi, gp->current_texture);
726 glMatrixMode (GL_TEXTURE);
727 glRotated (180.0, 1.0, 0.0, 0.0);
728 glMatrixMode (GL_MODELVIEW);
731 /* Clear the buffer since this is not done during a draw with motion blur */
732 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
735 /******************************************************************************
737 * Initialise the openGL state data.
740 set_blob_gl_state(GLfloat alpha)
744 glEnable(GL_LINE_SMOOTH);
745 glEnable(GL_POLYGON_SMOOTH);
750 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
754 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
757 /* The blend function is used for trasitioning between two images even when
758 * blend is not selected.
760 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
765 glCullFace (GL_BACK);
766 glEnable (GL_CULL_FACE);
767 glFrontFace (GL_CCW);
771 glDisable (GL_CULL_FACE);
777 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
778 /* Set the default blob colour to off-white. */
779 glColor4f (0.9, 0.9, 1.0, alpha);
784 glColor4f (0.9, 0.9, 1.0, 1.0);
787 glEnable(GL_DEPTH_TEST);
788 glEnable(GL_LIGHTING);
791 /******************************************************************************
793 * Initialise the data required to draw the blob allocating the memory as
796 * Return 0 on success.
799 initialise_blob(mirrorblobstruct *gp,
805 int i, u, v, node, side, face, base, base2 = 0;
806 int nodes_on_edge = resolution;
807 Vector3D node1, node2, result;
809 if (nodes_on_edge < 2)
812 gp->num_nodes = 2 * nodes_on_edge * nodes_on_edge - 4 * nodes_on_edge + 4;
813 gp->num_faces = 4 * (nodes_on_edge - 1) * (nodes_on_edge - 1);
815 gp->nodes = (Node_Data *) malloc (gp->num_nodes * sizeof (Node_Data));
818 fprintf (stderr, "Couldn't allocate gp->nodes buffer\n");
822 gp->faces = (Face_Data *) malloc (gp->num_faces * sizeof (Face_Data));
825 fprintf (stderr, "Couldn't allocate faces data buffer\n");
829 gp->bump_data = (Bump_Data *) malloc (bumps * sizeof (Bump_Data));
832 fprintf(stderr, "Couldn't allocate bump data buffer\n");
836 gp->bump_shape = (double *)malloc(bump_array_size * sizeof(double));
839 fprintf(stderr, "Couldn't allocate bump buffer\n");
843 gp->wall_shape = (double *)malloc(bump_array_size * sizeof(double));
846 fprintf(stderr, "Couldn't allocate wall bump buffer\n");
851 gp->dots = (Vector3D *)malloc(gp->num_nodes * sizeof(Vector3D));
854 fprintf(stderr, "Couldn't allocate nodes buffer\n");
858 gp->normals = (Vector3D *)malloc(gp->num_nodes * sizeof(Vector3D));
861 fprintf(stderr, "Couldn't allocate normals buffer\n");
865 gp->colours = (Colour *)malloc(gp->num_nodes * sizeof(Colour));
868 fprintf(stderr, "Couldn't allocate colours buffer\n");
872 gp->tex_coords = (Vector2D *)malloc(gp->num_nodes * sizeof(Vector2D));
875 fprintf(stderr, "Couldn't allocate gp->tex_coords buffer\n");
880 /* Initialise bump data */
881 for (i = 0; i < bumps; i++)
883 gp->bump_data[i].ax = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
884 gp->bump_data[i].ay = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
885 gp->bump_data[i].power = (5.0 / pow(bumps, 0.75)) * (((double)random() / (double)RAND_MAX) - 0.5);
886 gp->bump_data[i].size = 0.1 + 0.5 * (((double)random() / (double)RAND_MAX));
888 gp->bump_data[i].pos.x = 1.5 * sin(PI * gp->bump_data[i].ay)
889 * cos(PI * gp->bump_data[i].ax);
890 gp->bump_data[i].pos.y = 1.5 * cos(PI * gp->bump_data[i].ay);
891 gp->bump_data[i].pos.z = 1.5 * sin(PI * gp->bump_data[i].ay)
892 * sin(PI * gp->bump_data[i].ax);
894 gp->bump_data[i].cx = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
895 gp->bump_data[i].cy = 2.0 * (((double)random() / (double)RAND_MAX) - 0.5);
896 gp->bump_data[i].cpower = (5.0 / pow(bumps, 0.75)) * (((double)random() / (double)RAND_MAX) - 0.5);
897 gp->bump_data[i].csize = 0.35; /*0.1 + 0.25 * (((double)random() / (double)RAND_MAX));*/
899 gp->bump_data[i].vx = 0.0;
900 gp->bump_data[i].vy = 0.0;
901 gp->bump_data[i].vpower = 0.0;
902 gp->bump_data[i].vsize = 0.0;
904 gp->bump_data[i].mx = 0.003 * ((double)random() / (double)RAND_MAX);
905 gp->bump_data[i].my = 0.003 * ((double)random() / (double)RAND_MAX);
906 gp->bump_data[i].mpower = 0.003 * ((double)random() / (double)RAND_MAX);
907 gp->bump_data[i].msize = 0.003 * ((double)random() / (double)RAND_MAX);
910 /* Initialise lookup table of bump strength */
911 for (i = 0; i < bump_array_size; i++)
914 xd = i / (double)bump_array_size;
916 xd2 = 48.0 * xd * xd;
917 gp->bump_shape[i] = 0.1 / (xd2 + 0.1);
919 xd2 = 40.0 * xd * xd * xd * xd;
920 gp->wall_shape[i] = 0.4 / (xd2 + 0.1);
925 for (side = 0; side < 4; side++)
933 * The start and end of the for loops below are modified based on the
934 * side of the tetrahedron that is being calculated to avoid duplication
935 * of the gp->nodes that are on the edges of the tetrahedron.
937 for (u = (side > 1); u < (nodes_on_edge - (side > 0)); u++)
939 node1 = partial (normalise (tetrahedron[side][0]),
940 normalise (tetrahedron[side][1]),
941 u / (double) (nodes_on_edge - 1));
942 node2 = partial (normalise (tetrahedron[side][0]),
943 normalise (tetrahedron[side][2]),
944 u / (double) (nodes_on_edge - 1));
946 for (v = (side > 1); v <= (u - (side > 2)); v++)
949 result = partial (node1, node2, v / (double) u);
953 gp->nodes[node].position = normalise (result);
954 gp->nodes[node].initial_position = gp->nodes[node].position;
955 gp->nodes[node].normal = zero_vector;
961 * Determine which nodes make up each face. The complexity is caused
962 * by having to determine the correct nodes for the edges of the
963 * tetrahedron since the common nodes on the edges are only calculated
966 for (u = 0; u < (nodes_on_edge - 1); u++)
968 for (v = 0; v <= u; v++)
973 gp->faces[face].node1 = base + ((u * (u + 1)) / 2) + v;
974 gp->faces[face].node2 =
975 base + ((u + 1) * (u + 2)) / 2 + v + 1;
976 gp->faces[face].node3 =
977 base + ((u + 1) * (u + 2)) / 2 + v;
979 if ((side == 1) && (u == (nodes_on_edge - 2)))
981 gp->faces[face].node3 =
982 ((u + 1) * (u + 2)) / 2 +
983 nodes_on_edge - v - 1;
984 gp->faces[face].node2 =
985 ((u + 1) * (u + 2)) / 2 +
986 nodes_on_edge - v - 2;
991 gp->faces[face].node1 =
992 base + (((u - 1) * u) / 2) + v - 1;
993 gp->faces[face].node2 = base + ((u) * (u + 1)) / 2 + v;
994 gp->faces[face].node3 =
995 base + ((u) * (u + 1)) / 2 + v - 1;
997 if (u == (nodes_on_edge - 2))
999 int n = nodes_on_edge - v - 1;
1000 gp->faces[face].node2 =
1002 (nodes_on_edge + 1)) / 2) +
1003 ((n - 1) * (n + 0)) / 2;
1004 gp->faces[face].node3 =
1006 (nodes_on_edge + 1)) / 2) +
1007 ((n + 0) * (n + 1)) / 2;
1011 gp->faces[face].node1 = (((u + 1) * (u + 2)) / 2) - 1;
1012 gp->faces[face].node3 = (((u + 2) * (u + 3)) / 2) - 1;
1017 gp->faces[face].node1 =
1018 base + (((u - 2) * (u - 1)) / 2) + v - 1;
1019 gp->faces[face].node2 = base + ((u - 1) * u) / 2 + v;
1020 gp->faces[face].node3 = base + ((u - 1) * u) / 2 + v - 1;
1024 gp->faces[face].node1 =
1025 base2 + ((u * (u + 1)) / 2) - 1;
1026 gp->faces[face].node3 =
1027 base2 + ((u + 1) * (u + 2)) / 2 - 1;
1029 if (u == (nodes_on_edge - 2))
1031 gp->faces[face].node3 =
1033 (nodes_on_edge + 1)) / 2) +
1034 ((v + 1) * (v + 2)) / 2 - 1;
1035 gp->faces[face].node2 =
1037 (nodes_on_edge + 1)) / 2) +
1038 ((v + 2) * (v + 3)) / 2 - 1;
1042 gp->faces[face].node1 = (u * (u + 1)) / 2;
1043 gp->faces[face].node2 = ((u + 1) * (u + 2)) / 2;
1053 gp->faces[face].node1 = base + ((u * (u + 1)) / 2) + v;
1054 gp->faces[face].node2 =
1055 base + ((u * (u + 1)) / 2) + v + 1;
1056 gp->faces[face].node3 =
1057 base + (((u + 1) * (u + 2)) / 2) + v + 1;
1059 if ((side == 1) && (u == (nodes_on_edge - 2)))
1061 gp->faces[face].node3 =
1062 ((u + 1) * (u + 2)) / 2 +
1063 nodes_on_edge - v - 2;
1068 gp->faces[face].node1 =
1069 base + ((u * (u - 1)) / 2) + v - 1;
1070 gp->faces[face].node2 = base + ((u * (u - 1)) / 2) + v;
1071 gp->faces[face].node3 = base + ((u * (u + 1)) / 2) + v;
1073 if (u == (nodes_on_edge - 2))
1075 int n = nodes_on_edge - v - 1;
1076 gp->faces[face].node3 =
1078 (nodes_on_edge + 1)) / 2) +
1079 ((n + 0) * (n - 1)) / 2;
1083 gp->faces[face].node1 = (((u + 1) * (u + 2)) / 2) - 1;
1088 gp->faces[face].node1 =
1089 base + (((u - 2) * (u - 1)) / 2) + v - 1;
1090 gp->faces[face].node2 =
1091 base + (((u - 2) * (u - 1)) / 2) + v;
1092 gp->faces[face].node3 = base + (((u - 1) * u) / 2) + v;
1096 gp->faces[face].node1 = base2 + (u * (u + 1)) / 2 - 1;
1098 if (u == (nodes_on_edge - 2))
1100 gp->faces[face].node3 =
1101 ((nodes_on_edge * (nodes_on_edge + 1)) / 2) +
1102 ((v + 2) * (v + 3)) / 2 - 1;
1106 gp->faces[face].node2 = (u * (u + 1)) / 2;
1118 /******************************************************************************
1120 * Return the magnitude of the given vector
1122 static inline double
1125 return sqrt (u.x * u.x + u.y * u.y + u.z * u.z);
1128 /******************************************************************************
1130 * Calculate the blob shape.
1133 calc_blob(mirrorblobstruct *gp,
1136 int bump_array_size,
1140 /* Loop variables */
1142 /* position of a node */
1145 Vector3D bump_vector;
1148 /* Update position and strength of bumps used to distort the blob */
1149 for (i = 0; i < bumps; i++)
1151 gp->bump_data[i].vx += gp->bump_data[i].mx*(gp->bump_data[i].cx - gp->bump_data[i].ax);
1152 gp->bump_data[i].vy += gp->bump_data[i].my*(gp->bump_data[i].cy - gp->bump_data[i].ay);
1153 gp->bump_data[i].vpower += gp->bump_data[i].mpower
1154 * (gp->bump_data[i].cpower - gp->bump_data[i].power);
1155 gp->bump_data[i].vsize += gp->bump_data[i].msize
1156 * (gp->bump_data[i].csize - gp->bump_data[i].size);
1158 gp->bump_data[i].ax += 0.1 * gp->bump_data[i].vx;
1159 gp->bump_data[i].ay += 0.1 * gp->bump_data[i].vy;
1160 gp->bump_data[i].power += 0.1 * gp->bump_data[i].vpower;
1161 gp->bump_data[i].size += 0.1 * gp->bump_data[i].vsize;
1163 gp->bump_data[i].pos.x = 1.0 * sin(PI * gp->bump_data[i].ay)
1164 * cos(PI * gp->bump_data[i].ax);
1165 gp->bump_data[i].pos.y = 1.0 * cos(PI * gp->bump_data[i].ay);
1166 gp->bump_data[i].pos.z = 1.0 * sin(PI * gp->bump_data[i].ay)
1167 * sin(PI * gp->bump_data[i].ax);
1170 /* Update calculate new position for each vertex based on an offset from
1171 * the initial position
1173 gp->blob_force = zero_vector;
1174 for (index = 0; index < gp->num_nodes; ++index)
1176 node = gp->nodes[index].initial_position;
1177 gp->nodes[index].normal = node;
1179 offset = zero_vector;
1180 for ( i = 0; i < bumps; i++)
1182 bump_vector = subtract(gp->bump_data[i].pos, node);
1184 dist = bump_array_size * dot(bump_vector, bump_vector) * gp->bump_data[i].size;
1186 if (dist < bump_array_size)
1188 add(&offset, scale(node, gp->bump_data[i].power * gp->bump_shape[dist]));
1189 add(&gp->blob_force, scale(node, gp->bump_data[i].power * gp->bump_shape[dist]));
1194 node = scale(node, zoom);
1195 add(&node, gp->blob_center);
1199 if (node.z < -limit) node.z = -limit;
1200 if (node.z > limit) node.z = limit;
1202 dist = bump_array_size * (node.z + limit) * (node.z + limit) * 0.5;
1203 if (dist < bump_array_size)
1205 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1206 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1207 gp->blob_force.z += (node.z + limit);
1211 dist = bump_array_size * (node.z - limit) * (node.z - limit) * 0.5;
1212 if (dist < bump_array_size)
1214 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1215 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1216 gp->blob_force.z -= (node.z - limit);
1219 if (node.y < -limit) node.y = -limit;
1220 if (node.y > limit) node.y = limit;
1222 dist = bump_array_size * (node.y + limit) * (node.y + limit) * 0.5;
1223 if (dist < bump_array_size)
1225 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1226 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1227 gp->blob_force.y += (node.y + limit);
1231 dist = bump_array_size * (node.y - limit) * (node.y - limit) * 0.5;
1232 if (dist < bump_array_size)
1234 node.x += (node.x - gp->blob_center.x) * gp->wall_shape[dist];
1235 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1236 gp->blob_force.y -= (node.y - limit);
1240 if (node.x < -limit) node.x = -limit;
1241 if (node.x > limit) node.x = limit;
1243 dist = bump_array_size * (node.x + limit) * (node.x + limit) * 0.5;
1244 if (dist < bump_array_size)
1246 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1247 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1248 gp->blob_force.x += (node.x + limit);
1252 dist = bump_array_size * (node.x - limit) * (node.x - limit) * 0.5;
1253 if (dist < bump_array_size)
1255 node.y += (node.y - gp->blob_center.y) * gp->wall_shape[dist];
1256 node.z += (node.z - gp->blob_center.z) * gp->wall_shape[dist];
1257 gp->blob_force.x -= (node.x - limit);
1261 if (node.y < -limit) node.y = -limit;
1262 if (node.y > limit) node.y = limit;
1265 gp->dots[index] = node;
1268 /* Determine the normal for each face */
1269 for (face = 0; face < gp->num_faces; face++)
1271 /* Use pointers to indexed nodes to help readability */
1272 int index1 = gp->faces[face].node1;
1273 int index2 = gp->faces[face].node2;
1274 int index3 = gp->faces[face].node3;
1276 gp->faces[face].normal = cross(subtract(gp->dots[index2], gp->dots[index1]),
1277 subtract(gp->dots[index3], gp->dots[index1]));
1279 /* Add the normal for the face onto the normal for the verticies of
1281 add(&gp->nodes[index1].normal, gp->faces[face].normal);
1282 add(&gp->nodes[index2].normal, gp->faces[face].normal);
1283 add(&gp->nodes[index3].normal, gp->faces[face].normal);
1286 /* Use the normal to set the colour and texture */
1287 if (do_colour || do_texture)
1289 for (index = 0; index < gp->num_nodes; ++index)
1291 gp->normals[index] = normalise(gp->nodes[index].normal);
1295 gp->colours[index].red = (int)(255.0 * fabs(gp->normals[index].x));
1296 gp->colours[index].green = (int)(255.0 * fabs(gp->normals[index].y));
1297 gp->colours[index].blue = (int)(255.0 * fabs(gp->normals[index].z));
1298 gp->colours[index].alpha = (int)(255.0 * fade);
1304 const float cube_size = 100.0;
1305 Vector3D eye = {0.0, 0.0, 50.0};
1306 Vector3D eye_r = normalise(subtract(gp->dots[index], eye));
1307 Vector3D reference = subtract(eye_r, scale(gp->normals[index], 2.0 * dot(eye_r, gp->normals[index])));
1310 double n, n_min = 10000.0, sign = 1.0;
1311 if (fabs(reference.z) > 1e-9)
1313 n = (cube_size - gp->dots[index].z) / reference.z;
1316 n = (-cube_size - gp->dots[index].z) / reference.z;
1321 x = sign * (gp->dots[index].x + n * reference.x);
1322 y = sign * (gp->dots[index].y + n * reference.y);
1326 if (fabs(reference.x) > 1e-9)
1328 n = (cube_size - gp->dots[index].x) / reference.x;
1332 n = (-cube_size - gp->dots[index].x) / reference.x;
1335 if ((n > 0.0) && (n < n_min))
1337 x = sign * (2.0 * cube_size - (gp->dots[index].z + n * reference.z));
1338 y = sign * x * (gp->dots[index].y + n * reference.y) / cube_size;
1342 if (fabs(reference.y) > 1e-9)
1344 n = (cube_size - gp->dots[index].y) / reference.y;
1348 n = (-cube_size - gp->dots[index].y) / reference.y;
1351 if ((n > 0.0) && (n < n_min))
1353 y = sign * (2.0 * cube_size -( gp->dots[index].z + n * reference.z));
1354 x = sign * y * (gp->dots[index].x + n * reference.x) / cube_size;
1358 gp->tex_coords[index].x = 0.5 + x / (cube_size * 6.0);
1359 gp->tex_coords[index].y = 0.5 - y / (cube_size * 6.0);
1363 gp->tex_coords[index].x = 0.5
1364 * (1.0 + asin(gp->normals[index].x) / (0.5 * PI));
1365 gp->tex_coords[index].y = -0.5
1366 * (1.0 + asin(gp->normals[index].y) / (0.5 * PI));
1368 /* Adjust the texture co-ordinates to from range 0..1 to
1369 * 0..width or 0..height as appropriate
1371 gp->tex_coords[index].x *= gp->tex_width[gp->current_texture];
1372 gp->tex_coords[index].y *= gp->tex_height[gp->current_texture];
1377 /* Update the center of the whole blob */
1378 add(&gp->blob_velocity, scale (subtract (gp->blob_anchor, gp->blob_center), 1.0 / 80.0));
1379 add(&gp->blob_velocity, scale (gp->blob_force, 0.01 / gp->num_nodes));
1381 add(&gp->blob_center, scale(gp->blob_velocity, 0.5));
1383 gp->blob_velocity = scale(gp->blob_velocity, 0.999);
1387 draw_vertex(mirrorblobstruct *gp, int index)
1391 glColor3ub(gp->colours[index].red,
1392 gp->colours[index].green,
1393 gp->colours[index].blue);
1397 glTexCoord2fv(&gp->tex_coords[index].x);
1399 glNormal3fv(&gp->normals[index].x);
1400 glVertex3fv(&gp->dots[index].x);
1403 /******************************************************************************
1405 * Draw the blob shape.
1409 draw_blob (mirrorblobstruct *gp)
1413 glMatrixMode(GL_MODELVIEW);
1415 glRotatef(current_device_rotation(), 0, 0, 1);
1417 /* Move down the z-axis. */
1418 glTranslatef (0.0, 0.0, -4.0);
1420 gltrackball_rotate (gp->trackball);
1422 /* glColor4ub (255, 0, 0, 128); */
1423 glBegin(GL_TRIANGLES);
1424 for (face = 0; face < gp->num_faces; face++)
1426 draw_vertex(gp, gp->faces[face].node1);
1427 draw_vertex(gp, gp->faces[face].node2);
1428 draw_vertex(gp, gp->faces[face].node3);
1434 for (face = 0; face < gp->num_faces; face++)
1436 if (gp->normals[gp->faces[face].node1].z > 0.0)
1438 Vector3D end = gp->dots[gp->faces[face].node1];
1440 add(&end, scale(gp->normals[gp->faces[face].node1], 0.25));
1450 /******************************************************************************
1452 * Draw the background image simply map a texture onto a full screen quad.
1455 draw_background (ModeInfo *mi)
1457 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1458 GLfloat rot = current_device_rotation();
1460 glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
1461 glEnable (GL_TEXTURE_2D);
1462 glDisable(GL_LIGHTING);
1463 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1465 /* Reset the projection matrix to make it easier to get the size of the quad
1468 glMatrixMode(GL_PROJECTION);
1472 glRotatef (rot, 0, 0, 1);
1473 if ((rot > 45 && rot < 135) ||
1474 (rot < -45 && rot > -135))
1476 GLfloat s = MI_WIDTH(mi) / (GLfloat) MI_HEIGHT(mi);
1477 glScalef (s, 1/s, 1);
1480 glOrtho(0.0, MI_WIDTH(mi), MI_HEIGHT(mi), 0.0, -1000.0, 1000.0);
1484 glTexCoord2f (0.0, 0.0);
1487 glTexCoord2f (0.0, gp->tex_height[gp->current_texture]);
1488 glVertex2i (0, MI_HEIGHT(mi));
1490 glTexCoord2f (gp->tex_width[gp->current_texture], gp->tex_height[gp->current_texture]);
1491 glVertex2i (MI_WIDTH(mi), MI_HEIGHT(mi));
1493 glTexCoord2f (gp->tex_width[gp->current_texture], 0.0);
1494 glVertex2i (MI_WIDTH(mi), 0);
1498 glMatrixMode (GL_MODELVIEW);
1499 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1502 /******************************************************************************
1507 draw_scene(ModeInfo * mi)
1509 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1512 double current_time;
1513 check_gl_error ("draw_scene");
1515 mi->polygon_count = 0;
1516 glColor4f (1.0, 1.0, 1.0, 1.0);
1518 current_time = double_time();
1522 glColor4f (0.0, 0.0, 0.0, 1.0);
1527 fade = 1.0 - (current_time - gp->state_start_time) / fade_time;
1530 case LOADING: /* FALL-THROUGH */
1536 /* Set the correct texture, when transitioning this ensures that the first draw
1537 * is the original texture (which has the new texture drawn over it with decreasing
1542 glBindTexture(GL_TEXTURE_2D, gp->textures[gp->current_texture]);
1545 glDisable (GL_DEPTH_TEST);
1546 if (do_paint_background)
1548 glEnable (GL_TEXTURE_2D);
1549 if (motion_blur > 0.0)
1551 glClear(GL_DEPTH_BUFFER_BIT);
1552 glEnable (GL_BLEND);
1553 glColor4f (1.0, 1.0, 1.0, motion_blur);
1557 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1559 draw_background (mi);
1560 mi->polygon_count++;
1562 /* When transitioning between two images paint the new image over the old
1563 * image with a varying alpha value to get a smooth fade.
1565 if (gp->state == TRANSITIONING)
1567 glEnable (GL_BLEND);
1568 /* Select the texture to transition to */
1569 glBindTexture (GL_TEXTURE_2D, gp->textures[1 - gp->current_texture]);
1570 glColor4f (1.0, 1.0, 1.0, 1.0 - fade);
1572 draw_background (mi);
1573 mi->polygon_count++;
1575 /* Select the original texture to draw the blob */
1576 glBindTexture (GL_TEXTURE_2D, gp->textures[gp->current_texture]);
1578 /* Clear the depth buffer bit so the backgound is behind the blob */
1579 glClear(GL_DEPTH_BUFFER_BIT);
1581 else if (motion_blur > 0.0)
1583 glEnable (GL_BLEND);
1584 glColor4f (0.0, 0.0, 0.0, motion_blur);
1585 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1586 glTranslatef (0.0, 0.0, -4.0);
1587 glRectd (-10.0, -10.0, 10.0, 10.0);
1590 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1592 glClear(GL_DEPTH_BUFFER_BIT);
1596 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1602 glDisable (GL_TEXTURE_2D);
1605 calc_blob(gp, MI_WIDTH(mi), MI_HEIGHT(mi), BUMP_ARRAY_SIZE, 2.5, fade * blend);
1607 set_blob_gl_state(fade * blend);
1611 /* Disable the colour chanels so that only the depth buffer is updated */
1612 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1614 mi->polygon_count += gp->num_faces;
1615 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1618 glDepthFunc(GL_LEQUAL);
1620 mi->polygon_count += gp->num_faces;
1622 /* While transitioning between images draw a second blob with a modified
1625 if (load_textures && (hold_time > 0))
1630 if (!gp->waiting_for_image_p)
1632 gp->state = HOLDING;
1637 if ((current_time - gp->state_start_time) > hold_time)
1639 grab_texture(mi, 1 - gp->current_texture);
1640 gp->state = LOADING;
1645 /* Once the image has loaded move to the TRANSITIONING STATE */
1646 if (!gp->waiting_for_image_p)
1648 gp->state = TRANSITIONING;
1649 /* Get the time again rather than using the current time so
1650 * that the time taken by the grab_texture function is not part
1653 gp->state_start_time = double_time();
1659 /* If the blob is textured draw over existing blob to fade between
1664 /* Select the texture to transition to */
1665 glBindTexture (GL_TEXTURE_2D, gp->textures[1 - gp->current_texture]);
1666 glEnable (GL_BLEND);
1668 /* If colour is enabled update the alpha data in the buffer and
1669 * use that in the blending since the alpha of the incomming
1670 * verticies will not be correct
1674 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
1675 glClearColor(0.0, 0.0, 0.0, (1.0 - fade) * blend);
1676 glClear(GL_COLOR_BUFFER_BIT);
1677 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1678 glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
1682 glColor4f (0.9, 0.9, 1.0, (1.0 - fade) * blend);
1686 mi->polygon_count += gp->num_faces;
1690 /* Restore the 'standard' blend functions. */
1691 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1695 if ((current_time - gp->state_start_time) > fade_time)
1697 gp->state = HOLDING;
1698 gp->state_start_time = current_time;
1699 gp->current_texture = 1 - gp->current_texture;
1707 /******************************************************************************
1709 * XMirrorblob screen update entry
1712 draw_mirrorblob(ModeInfo * mi)
1714 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN(mi)];
1715 Display *display = MI_DISPLAY(mi);
1716 Window window = MI_WINDOW(mi);
1718 if (!gp->glx_context)
1721 /* Wait for the first image; for subsequent images, load them in the
1722 background while animating. */
1723 if (gp->waiting_for_image_p && gp->first_image_p)
1726 glXMakeCurrent(display, window, *(gp->glx_context));
1728 if (mi->fps_p) do_fps (mi);
1730 glXSwapBuffers(display, window);
1733 /******************************************************************************
1735 * XMirrorblob screen resize entry
1738 reshape_mirrorblob(ModeInfo *mi, int width, int height)
1740 glViewport( 0, 0, MI_WIDTH(mi), MI_HEIGHT(mi) );
1741 reset_projection(width, height);
1744 /****************************************************************************
1746 * Handle Mouse events
1749 mirrorblob_handle_event (ModeInfo * mi, XEvent * event)
1751 mirrorblobstruct *gp = &Mirrorblob[MI_SCREEN (mi)];
1753 if (event->xany.type == ButtonPress &&
1754 event->xbutton.button == Button1)
1756 gp->button_down = 1;
1757 gltrackball_start (gp->trackball, event->xbutton.x,
1758 event->xbutton.y, MI_WIDTH (mi), MI_HEIGHT (mi));
1761 else if (event->xany.type == ButtonRelease &&
1762 event->xbutton.button == Button1)
1764 gp->button_down = 0;
1767 else if (event->xany.type == ButtonPress &&
1768 event->xbutton.button == Button4)
1773 else if (event->xany.type == ButtonPress &&
1774 event->xbutton.button == Button5)
1780 else if (event->xany.type == MotionNotify && gp->button_down)
1782 gltrackball_track (gp->trackball, event->xmotion.x,
1783 event->xmotion.y, MI_WIDTH (mi), MI_HEIGHT (mi));
1789 /******************************************************************************
1791 * XMirrorblob initialise entry
1794 init_mirrorblob(ModeInfo * mi)
1796 int screen = MI_SCREEN(mi);
1798 mirrorblobstruct *gp;
1800 if (Mirrorblob == NULL)
1802 if ((Mirrorblob = (mirrorblobstruct *)
1803 calloc(MI_NUM_SCREENS(mi), sizeof (mirrorblobstruct))) == NULL)
1808 gp = &Mirrorblob[screen];
1810 gp->window = MI_WINDOW(mi);
1811 if ((gp->glx_context = init_GL(mi)) != NULL)
1813 reshape_mirrorblob(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1814 initialize_gl(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1820 gp->trackball = gltrackball_init();
1822 initialise_blob(gp, MI_WIDTH(mi), MI_HEIGHT(mi), BUMP_ARRAY_SIZE);
1823 gp->state = INITIALISING;
1824 gp->state_start_time = double_time();
1826 gp->first_image_p = True;
1829 /******************************************************************************
1831 * XMirrorblob cleanup entry
1834 release_mirrorblob(ModeInfo * mi)
1836 if (Mirrorblob != NULL) {
1838 for (i = 0; i < MI_NUM_SCREENS(mi); i++) {
1839 mirrorblobstruct *gp = &Mirrorblob[i];
1840 if (gp->nodes) free(gp->nodes);
1841 if (gp->faces) free(gp->faces);
1842 if (gp->bump_data) free(gp->bump_data);
1843 if (gp->colours) free(gp->colours);
1844 if (gp->tex_coords) free(gp->tex_coords);
1845 if (gp->dots) free(gp->dots);
1846 if (gp->wall_shape) free(gp->wall_shape);
1847 if (gp->bump_shape) free(gp->bump_shape);
1856 XSCREENSAVER_MODULE ("MirrorBlob", mirrorblob)