6.09HEADmaster

1 files changed, 0 insertions, 3339 deletions

diff --git a/hacks/glx/sphereeversion.c b/hacks/glx/sphereeversion.c
deleted file mode 100644
index cd58275..0000000
--- a/hacks/glx/sphereeversion.c
+++ /dev/null
@@ -1,3339 +0,0 @@
-/* sphereeversion --- Shows a sphere eversion, i.e., a smooth deformation
-   (homotopy) that turns a sphere inside out.  During the eversion, the
-   deformed sphere is allowed to intersect itself transversally.  However,
-   no creases or pinch points are allowed to occur. */
-
-#if 0
-static const char sccsid[] = "@(#)sphereeversion.c  1.1 20/03/22 xlockmore";
-#endif
-
-/* Copyright (c) 2020-2021 Carsten Steger <carsten@mirsanmir.org>. */
-
-/*
- * Permission to use, copy, modify, and distribute this software and its
- * documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright notice appear in all copies and that
- * both that copyright notice and this permission notice appear in
- * supporting documentation.
- *
- * This file is provided AS IS with no warranties of any kind.  The author
- * shall have no liability with respect to the infringement of copyrights,
- * trade secrets or any patents by this file or any part thereof.  In no
- * event will the author be liable for any lost revenue or profits or
- * other special, indirect and consequential damages.
- *
- * REVISION HISTORY:
- * C. Steger - 20/03/22: Initial version
- * C. Steger - 20/04/10: Added blending between visualization modes
- * C. Steger - 20/06/01: Removed blending because accumulation buffers have
- * *                     been deprecated since OpenGL 3.0
- * C. Steger - 20/07/26: Make the polygon offset work under OpenGL ES
- * C. Steger - 20/08/03: Add an easing function for one part of the animation
- * C. Steger - 20/10/11: Add easing functions for more parts of the animation
- * C. Steger - 21/01/03: Added per-fragment shading
- * C. Steger - 21/01/05: Added blending between visualization modes using
- *                       multiple render passes
- */
-
-/*
- * This program shows a sphere eversion, i.e., a smooth deformation
- * (homotopy) that turns a sphere inside out.  During the eversion,
- * the deformed sphere is allowed to intersect itself transversally.
- * However, no creases or pinch points are allowed to occur.
- *
- * The deformed sphere can be projected to the screen either
- * perspectively or orthographically.
- *
- * There are three display modes for the sphere: solid, transparent,
- * or random.  If random mode is selected, the mode is changed each
- * time an eversion has been completed.
- *
- * The appearance of the sphere can be as a solid object, as a set of
- * see-through bands, or random.  The bands can be parallel bands or
- * meridian bands, i.e., bands that run along the parallels (lines of
- * latitude) or bands that run along the meridians (lines of
- * longitude) of the sphere.  If random mode is selected, the
- * appearance is changed each time an eversion has been completed.
- *
- * It is also possible to display a graticule (i.e., a coordinate grid
- * consisting of parallel and meridian lines) on top of the surface.
- * The graticule mode can be set to on, off, or random.  If random
- * mode is selected, the graticule mode is changed each time an
- * eversion has been completed.
- *
- * It is possible to define a surface order of the sphere eversion as
- * random or as a value between 2 and 5.  This determines the the
- * complexity of the deformation.  For higher surface orders, some
- * z-fighting might occur around the central stage of the eversion,
- * which might lead to some irregular flickering of the displayed
- * surface if it is displayed as a solid object.  For odd surface
- * orders, z-fighting will occur very close to the central stage of
- * the eversion since the deformed sphere is a doubly covered Boy
- * surface (for surface order 3) or a doubly covered generalized Boy
- * surface (for surface order 5) in this case.  If you find this
- * distracting, you should set the surface order to 2.  If a random
- * surface order is selected, the surface order is changed each time
- * an eversion has been completed.
- *
- * The colors with with the sphere is drawn can be set to two-sided,
- * parallel, meridian, or random.  In two-sided mode, the sphere is
- * drawn with red on one side and green on the other side.  In
- * parallel mode, the sphere is displayed with colors that run from
- * red to cyan on one side of the surface and from green to violet on
- * the other side.  The colors are aligned with the parallels of the
- * sphere in this mode.  In meridian mode, the the sphere is displayed
- * with colors that run from red to white to cyan to black and back to
- * red on one side of the surface and from green to white to violet to
- * black and back to green on the other side.  The colors are aligned
- * with the meridians of the sphere in this mode. If random mode is
- * selected, the color scheme is changed each time an eversion has
- * been completed.
- *
- * By default, the sphere is rotated to a new viewing position each
- * time an eversion has been completed.  In addition, it is possible
- * to rotate the sphere while it is deforming.  The rotation speed for
- * each of the three coordinate axes around which the sphere rotates
- * can be chosen arbitrarily.  For best effects, however, it is
- * suggested to rotate only around the z axis while the sphere is
- * deforming.
- *
- * This program is inspired by the following paper: Adam Bednorz,
- * Witold Bednorz: "Analytic sphere eversion using ruled surfaces",
- * Differential Geometry and its Applications 64:59-79, 2019.
- */
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-#define DISP_SURFACE               0
-#define DISP_TRANSPARENT           1
-#define NUM_DISPLAY_MODES          2
-
-#define APPEARANCE_SOLID           0
-#define APPEARANCE_PARALLEL_BANDS  1
-#define APPEARANCE_MERIDIAN_BANDS  2
-#define NUM_APPEARANCES            3
-
-#define COLORS_TWOSIDED            0
-#define COLORS_PARALLEL            1
-#define COLORS_MERIDIAN            2
-#define NUM_COLORS                 3
-
-#define DISP_PERSPECTIVE           0
-#define DISP_ORTHOGRAPHIC          1
-#define NUM_DISP_MODES             2
-
-#define DEF_DISPLAY_MODE           "random"
-#define DEF_APPEARANCE             "random"
-#define DEF_GRATICULE              "random"
-#define DEF_COLORS                 "random"
-#define DEF_PROJECTION             "random"
-#define DEF_SPEEDX                 "0.0"
-#define DEF_SPEEDY                 "0.0"
-#define DEF_SPEEDZ                 "0.0"
-#define DEF_DEFORM_SPEED           "10.0"
-#define DEF_SURFACE_ORDER          "random"
-
-
-/* For some strange reason, the color buffer must be initialized
-   and used on macOS. Otherwise one- and two-sided lighting will
-   not work. */
-#if (defined(HAVE_COCOA) || defined(__APPLE__)) && !defined(HAVE_IPHONE)
-#define VERTEXATTRIBARRAY_WORKAROUND
-#endif
-
-#ifdef STANDALONE
-# define DEFAULTS           "*delay:      10000 \n" \
-                            "*showFPS:    False \n" \
-                            "*prefersGLSL: True \n" \
-
-# define release_sphereeversion 0
-# include "xlockmore.h"         /* from the xscreensaver distribution */
-#else  /* !STANDALONE */
-# include "xlock.h"             /* from the xlockmore distribution */
-#endif /* !STANDALONE */
-
-#ifdef USE_GL
-
-#include "glsl-utils.h"
-#include "gltrackball.h"
-#include "pow2.h"
-
-#include <float.h>
-
-
-#ifdef USE_MODULES
-ModStruct sphereeversion_description =
-{"sphereeversion", "init_sphereeversion", "draw_sphereeversion",
- NULL, "draw_sphereeversion", "change_sphereeversion",
- "free_sphereeversion", &sphereeversion_opts, 25000, 1, 1, 1, 1.0, 4, "",
- "Show a sphere eversion", 0, NULL};
-
-#endif
-
-
-static char *mode;
-static char *appear;
-static char *color_mode;
-static char *graticule;
-static char *proj;
-static float speed_x;
-static float speed_y;
-static float speed_z;
-static float deform_speed;
-static char *surface_order;
-
-
-static XrmOptionDescRec opts[] =
-{
-  {"-mode",                ".displayMode",   XrmoptionSepArg, 0 },
-  {"-surface",             ".displayMode",   XrmoptionNoArg,  "surface" },
-  {"-transparent",         ".displayMode",   XrmoptionNoArg,  "transparent" },
-  {"-appearance",          ".appearance",    XrmoptionSepArg, 0 },
-  {"-solid",               ".appearance",    XrmoptionNoArg,  "solid" },
-  {"-parallel-bands",      ".appearance",    XrmoptionNoArg,  "parallel-bands" },
-  {"-meridian-bands",      ".appearance",    XrmoptionNoArg,  "meridian-bands" },
-  {"-graticule",           ".graticule",     XrmoptionSepArg, 0 },
-  {"-colors",              ".colors",        XrmoptionSepArg, 0 },
-  {"-twosided-colors",     ".colors",        XrmoptionNoArg,  "two-sided" },
-  {"-parallel-colors",     ".colors",        XrmoptionNoArg,  "parallel" },
-  {"-meridian-colors",     ".colors",        XrmoptionNoArg,  "meridian" },
-  {"-projection",          ".projection",    XrmoptionSepArg, 0 },
-  {"-perspective",         ".projection",    XrmoptionNoArg,  "perspective" },
-  {"-orthographic",        ".projection",    XrmoptionNoArg,  "orthographic" },
-  {"-speed-x",             ".speedx",        XrmoptionSepArg, 0 },
-  {"-speed-y",             ".speedy",        XrmoptionSepArg, 0 },
-  {"-speed-z",             ".speedz",        XrmoptionSepArg, 0 },
-  {"-deformation-speed",   ".deformSpeed",   XrmoptionSepArg, 0 },
-  {"-surface-order",       ".surfaceOrder",  XrmoptionSepArg, 0 },
-};
-
-static argtype vars[] =
-{
-  { &mode,           "displayMode",   "DisplayMode",   DEF_DISPLAY_MODE,   t_String },
-  { &appear,         "appearance",    "Appearance",    DEF_APPEARANCE,     t_String },
-  { &graticule,      "graticule",     "Graticule",     DEF_GRATICULE,      t_String },
-  { &color_mode,     "colors",        "Colors",        DEF_COLORS,         t_String },
-  { &surface_order,  "surfaceOrder",  "SurfaceOrder",  DEF_SURFACE_ORDER,  t_String },
-  { &proj,           "projection",    "Projection",    DEF_PROJECTION,     t_String },
-  { &speed_x,        "speedx",        "Speedx",        DEF_SPEEDX,         t_Float},
-  { &speed_y,        "speedy",        "Speedy",        DEF_SPEEDY,         t_Float},
-  { &speed_z,        "speedz",        "Speedz",        DEF_SPEEDZ,         t_Float},
-  { &deform_speed,   "deformSpeed",   "DeformSpeed",   DEF_DEFORM_SPEED,   t_Float},
-};
-
-ENTRYPOINT ModeSpecOpt sphereeversion_opts =
-{sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, NULL};
-
-
-/* Shape parameters for the Bednorz sphere eversion. */
-#define BEDNORZ_OMEGA 2.0
-#define BEDNORZ_Q (2.0/3.0)
-#define BEDNORZ_ETA_MIN (3.0/4.0)
-#define BEDNORZ_BETA_MAX 0.1
-#define BEDNORZ_ALPHA 1.0
-#define BEDNORZ_EPS2 0.001
-#define BEDNORZ_EPS3 0.002
-#define BEDNORZ_EPS4 0.001
-#define BEDNORZ_EPS5 0.002
-
-#define BEDNORZ_TAU1 (1.0/BEDNORZ_Q)
-#define BEDNORZ_TAU2 2.5
-#define BEDNORZ_TAU3 4.5
-#define BEDNORZ_TAU4 6.0
-
-#define BEDNORZ_TAU_MIN (-BEDNORZ_TAU4)
-#define BEDNORZ_TAU_MAX (BEDNORZ_TAU4)
-
-/* Number of subdivisions of the surface */
-#define NUMTH 256
-#define NUMPH 256
-
-/* Number of subdivisions between grid lines */
-#define NUMGRID 32
-
-/* Number of subdivisions per band */
-#define NUMBDIR  16
-#define NUMBDIST 16
-
-/* Animation states */
-#define ANIM_DEFORM 0
-#define ANIM_TURN   1
-
-/* Angle of a single turn step */
-#define TURN_STEP 1.0
-
-typedef struct {
-  int n;
-  double kappa;
-  double omega;
-  double t;
-  double p;
-  double q;
-  double xi;
-  double eta;
-  double alpha;
-  double beta;
-  double gamma;
-  double lambda;
-  double eps;
-} bednorz_shape_par;
-
-
-typedef struct {
-  GLint WindH, WindW;
-  GLXContext *glx_context;
-  /* Options */
-  int display_mode[2];
-  Bool random_display_mode;
-  int appearance[2];
-  Bool random_appearance;
-  Bool graticule[2];
-  Bool random_graticule;
-  int colors[2];
-  Bool random_colors;
-  int projection;
-  /* 3D rotation angles */
-  float alpha, beta, delta;
-  /* Animation state */
-  int anim_state;
-  /* Deformation parameters */
-  float tau;
-  int defdir;
-  /* Turning parameters */
-  int turn_step;
-  int num_turn;
-  float qs[4], qe[4];
-  /* Two global shape parameters of the Bednorz sphere eversion */
-  float eta_min, beta_max;
-  /* The order of the Bednorz sphere eversion */
-  int g;
-  Bool random_g;
-  /* The viewing offset in 3d */
-  float offset3d[3];
-  /* The 3d coordinates of the surface and the corresponding normal vectors */
-  float *se;
-  float *sen;
-  /* The precomputed colors of the surface */
-  float *colf[2];
-  float *colb[2];
-  /* Aspect ratio of the current window */
-  float aspect;
-  /* Trackball states */
-  trackball_state *trackball;
-  Bool button_pressed;
-  /* A random factor to modify the rotation speeds */
-  float speed_scale;
-#ifdef HAVE_GLSL
-  GLuint *solid_indices, *parallel_indices;
-  GLuint *meridian_indices, *line_indices;
-  Bool use_shaders, buffers_initialized;
-  GLuint poly_shader_program;
-  GLint poly_pos_index, poly_normal_index;
-  GLint poly_colorf_index, poly_colorb_index;
-  GLint poly_mv_index, poly_proj_index;
-  GLint poly_glbl_ambient_index, poly_lt_ambient_index;
-  GLint poly_lt_diffuse_index, poly_lt_specular_index;
-  GLint poly_lt_direction_index, poly_lt_halfvect_index;
-  GLint poly_front_ambient_index, poly_back_ambient_index;
-  GLint poly_front_diffuse_index, poly_back_diffuse_index;
-  GLint poly_specular_index, poly_shininess_index;
-  GLuint line_shader_program;
-  GLint line_pos_index, line_color_index;
-  GLint line_mv_index, line_proj_index;
-  GLint max_tex_size;
-  GLuint color_textures[2];
-  GLuint blend_shader_program;
-  GLint blend_vertex_p_index, blend_vertex_t_index;
-  GLint blend_t_index, blend_sampler0_index, blend_sampler1_index;
-  GLuint vertex_pos_buffer, vertex_normal_buffer;
-  GLuint vertex_colorf_buffer[2], vertex_colorb_buffer[2];
-  GLuint solid_indices_buffer, parallel_indices_buffer;
-  GLuint meridian_indices_buffer, line_indices_buffer;
-  GLint num_solid_strips, num_solid_triangles;
-  GLint num_parallel_strips, num_parallel_triangles;
-  GLint num_meridian_strips, num_meridian_triangles;
-  GLint num_lines;
-#endif /* HAVE_GLSL */
-} sphereeversionstruct;
-
-static sphereeversionstruct *sphereeversion = (sphereeversionstruct *) NULL;
-
-
-#ifdef HAVE_GLSL
-
-/* The GLSL versions that correspond to different versions of OpenGL. */
-static const GLchar *shader_version_2_1 =
-  "#version 120\n";
-static const GLchar *shader_version_3_0 =
-  "#version 130\n";
-static const GLchar *shader_version_3_0_es =
-  "#version 300 es\n"
-  "precision highp float;\n"
-  "precision highp int;\n";
-
-/* The vertex shader code is composed of code fragments that depend on
-   the OpenGL version and code fragments that are version-independent.
-   They are concatenated by glShaderSource in the function init_glsl(). */
-static const GLchar *poly_vertex_shader_attribs_2_1 =
-  "attribute vec3 VertexPosition;\n"
-  "attribute vec3 VertexNormal;\n"
-  "attribute vec4 VertexColorF;\n"
-  "attribute vec4 VertexColorB;\n"
-  "\n"
-  "varying vec3 Normal;\n"
-  "varying vec4 ColorF;\n"
-  "varying vec4 ColorB;\n"
-  "\n";
-static const GLchar *poly_vertex_shader_attribs_3_0 =
-  "in vec3 VertexPosition;\n"
-  "in vec3 VertexNormal;\n"
-  "in vec4 VertexColorF;\n"
-  "in vec4 VertexColorB;\n"
-  "\n"
-  "out vec3 Normal;\n"
-  "out vec4 ColorF;\n"
-  "out vec4 ColorB;\n"
-  "\n";
-static const GLchar *poly_vertex_shader_main =
-  "uniform mat4 MatModelView;\n"
-  "uniform mat4 MatProj;\n"
-  "\n"
-  "void main (void)\n"
-  "{\n"
-  "  ColorF = VertexColorF;\n"
-  "  ColorB = VertexColorB;\n"
-  "  Normal = normalize(MatModelView*vec4(VertexNormal,0.0f)).xyz;\n"
-  "  vec4 Position = MatModelView*vec4(VertexPosition,1.0f);\n"
-  "  gl_Position = MatProj*Position;\n"
-  "}\n";
-
-/* The fragment shader code is composed of code fragments that depend on
-   the OpenGL version and code fragments that are version-independent.
-   They are concatenated by glsl_CompileAndLinkShaders in the function
-   init_glsl(). */
-static const GLchar *poly_fragment_shader_attribs_2_1 =
-  "varying vec3 Normal;\n"
-  "varying vec4 ColorF;\n"
-  "varying vec4 ColorB;\n"
-  "\n";
-static const GLchar *poly_fragment_shader_attribs_3_0 =
-  "in vec3 Normal;\n"
-  "in vec4 ColorF;\n"
-  "in vec4 ColorB;\n"
-  "\n"
-  "out vec4 FragColor;\n"
-  "\n";
-static const GLchar *poly_fragment_shader_main =
-  "uniform vec4 LtGlblAmbient;\n"
-  "uniform vec4 LtAmbient, LtDiffuse, LtSpecular;\n"
-  "uniform vec3 LtDirection, LtHalfVector;\n"
-  "uniform vec4 MatFrontAmbient, MatBackAmbient;\n"
-  "uniform vec4 MatFrontDiffuse, MatBackDiffuse;\n"
-  "uniform vec4 MatSpecular;\n"
-  "uniform float MatShininess;\n"
-  "\n"
-  "void main (void)\n"
-  "{\n"
-  "  vec3 normalDirection;\n"
-  "  vec4 ambientColor, diffuseColor, sceneColor;\n"
-  "  vec4 ambientLighting, diffuseReflection, specularReflection, color;\n"
-  "  float ndotl, ndoth, pf;\n"
-  "  \n"
-  "  if (gl_FrontFacing)\n"
-  "  {\n"
-  "    normalDirection = normalize(Normal);\n"
-  "    sceneColor = ColorF*MatFrontAmbient*LtGlblAmbient;\n"
-  "    ambientColor = ColorF*MatFrontAmbient;\n"
-  "    diffuseColor = ColorF*MatFrontDiffuse;\n"
-  "  }\n"
-  "  else\n"
-  "  {\n"
-  "    normalDirection = -normalize(Normal);\n"
-  "    sceneColor = ColorB*MatBackAmbient*LtGlblAmbient;\n"
-  "    ambientColor = ColorB*MatBackAmbient;\n"
-  "    diffuseColor = ColorB*MatBackDiffuse;\n"
-  "  }\n"
-  "  \n"
-  "  ndotl = max(0.0f,dot(normalDirection,LtDirection));\n"
-  "  ndoth = max(0.0f,dot(normalDirection,LtHalfVector));\n"
-  "  if (ndotl == 0.0f)\n"
-  "    pf = 0.0f;\n"
-  "  else\n"
-  "    pf = pow(ndoth,MatShininess);\n"
-  "  ambientLighting = ambientColor*LtAmbient;\n"
-  "  diffuseReflection = LtDiffuse*diffuseColor*ndotl;\n"
-  "  specularReflection = LtSpecular*MatSpecular*pf;\n"
-  "  color = sceneColor+ambientLighting+diffuseReflection+\n"
-  "          specularReflection;\n";
-static const GLchar *poly_fragment_shader_out_2_1 =
-  "  gl_FragColor = clamp(color,0.0f,1.0f);\n"
-  "}\n";
-static const GLchar *poly_fragment_shader_out_3_0 =
-  "  FragColor = clamp(color,0.0f,1.0f);\n"
-  "}\n";
-
-/* The vertex shader code is composed of code fragments that depend on
-   the OpenGL version and code fragments that are version-independent.
-   They are concatenated by glsl_CompileAndLinkShaders in the function
-   init_glsl(). */
-static const GLchar *line_vertex_shader_attribs_2_1 =
-  "attribute vec3 VertexPosition;\n"
-  "\n";
-static const GLchar *line_vertex_shader_attribs_3_0 =
-  "in vec3 VertexPosition;\n"
-  "\n";
-static const GLchar *line_vertex_shader_main =
-  "uniform mat4 MatModelView;\n"
-  "uniform mat4 MatProj;\n"
-  "\n"
-  "void main (void)\n"
-  "{\n"
-  "  vec4 Position = MatModelView*vec4(VertexPosition,1.0f);\n"
-  "  gl_Position = MatProj*Position;\n"
-  "}\n";
-
-/* The fragment shader code is composed of code fragments that depend on
-   the OpenGL version and code fragments that are version-independent.
-   They are concatenated by glsl_CompileAndLinkShaders in the function
-   init_glsl(). */
-static const GLchar *line_fragment_shader_attribs_2_1 =
-  "";
-static const GLchar *line_fragment_shader_attribs_3_0 =
-  "out vec4 FragColor;\n"
-  "\n";
-static const GLchar *line_fragment_shader_main =
-  "uniform vec4 LineColor;\n"
-  "\n"
-  "void main (void)\n"
-  "{\n";
-static const GLchar *line_fragment_shader_out_2_1 =
-  "  gl_FragColor = LineColor;\n"
-  "}\n";
-static const GLchar *line_fragment_shader_out_3_0 =
-  "  FragColor = LineColor;\n"
-  "}\n";
-
-/* The vertex shader code is composed of code fragments that depend on
-   the OpenGL version and code fragments that are version-independent.
-   They are concatenated by glsl_CompileAndLinkShaders in the function
-   init_glsl(). */
-static const GLchar *blend_vertex_shader_attribs_2_1 =
-  "attribute vec2 VertexP;\n"
-  "attribute vec2 VertexT;\n"
-  "\n"
-  "varying vec2 TexCoord;\n"
-  "\n";
-static const GLchar *blend_vertex_shader_attribs_3_0 =
-  "in vec2 VertexP;\n"
-  "in vec2 VertexT;\n"
-  "\n"
-  "out vec2 TexCoord;\n"
-  "\n";
-static const GLchar *blend_vertex_shader_main =
-  "void main (void)\n"
-  "{\n"
-  "  gl_Position = vec4(VertexP,0.0f,1.0f);\n"
-  "  TexCoord = VertexT;\n"
-  "}\n";
-
-/* The fragment shader code is composed of code fragments that depend on
-   the OpenGL version and code fragments that are version-independent.
-   They are concatenated by glsl_CompileAndLinkShaders in the function
-   init_glsl(). */
-static const GLchar *blend_fragment_shader_attribs_2_1 =
-  "varying vec2 TexCoord;\n"
-  "\n";
-static const GLchar *blend_fragment_shader_attribs_3_0 =
-  "in vec2 TexCoord;\n"
-  "\n"
-  "out vec4 FragColor;\n"
-  "\n";
-static const GLchar *blend_fragment_shader_main =
-  "uniform sampler2D TextureSampler0;"
-  "uniform sampler2D TextureSampler1;"
-  "uniform float T;"
-  "\n"
-  "void main (void)\n"
-  "{\n";
-static const GLchar *blend_fragment_shader_out_2_1 =
-  "  vec3 Color0 = texture2D(TextureSampler0,TexCoord.st).rgb;\n"
-  "  vec3 Color1 = texture2D(TextureSampler1,TexCoord.st).rgb;\n"
-  "  gl_FragColor = vec4(T*Color0+(1.0f-T)*Color1,1.0f);\n"
-  "}\n";
-static const GLchar *blend_fragment_shader_out_3_0 =
-  "  vec3 Color0 = texture(TextureSampler0,TexCoord.st).rgb;\n"
-  "  vec3 Color1 = texture(TextureSampler1,TexCoord.st).rgb;\n"
-  "  FragColor = vec4(T*Color0+(1.0f-T)*Color1,1.0f);\n"
-  "}\n";
-
-#endif /* HAVE_GLSL */
-
-
-/* Add a rotation around the x-axis to the matrix m. */
-static void rotatex(float m[3][3], float phi)
-{
-  float c, s, u, v;
-  int i;
-
-  phi *= M_PI/180.0;
-  c = cos(phi);
-  s = sin(phi);
-  for (i=0; i<3; i++)
-  {
-    u = m[i][1];
-    v = m[i][2];
-    m[i][1] = c*u+s*v;
-    m[i][2] = -s*u+c*v;
-  }
-}
-
-
-/* Add a rotation around the y-axis to the matrix m. */
-static void rotatey(float m[3][3], float phi)
-{
-  float c, s, u, v;
-  int i;
-
-  phi *= M_PI/180.0;
-  c = cos(phi);
-  s = sin(phi);
-  for (i=0; i<3; i++)
-  {
-    u = m[i][0];
-    v = m[i][2];
-    m[i][0] = c*u-s*v;
-    m[i][2] = s*u+c*v;
-  }
-}
-
-
-/* Add a rotation around the z-axis to the matrix m. */
-static void rotatez(float m[3][3], float phi)
-{
-  float c, s, u, v;
-  int i;
-
-  phi *= M_PI/180.0;
-  c = cos(phi);
-  s = sin(phi);
-  for (i=0; i<3; i++)
-  {
-    u = m[i][0];
-    v = m[i][1];
-    m[i][0] = c*u+s*v;
-    m[i][1] = -s*u+c*v;
-  }
-}
-
-
-/* Compute the rotation matrix m from the rotation angles. */
-static void rotateall(float al, float be, float de, float m[3][3])
-{
-  int i, j;
-
-  for (i=0; i<3; i++)
-    for (j=0; j<3; j++)
-      m[i][j] = (i==j);
-  rotatex(m,al);
-  rotatey(m,be);
-  rotatez(m,de);
-}
-
-
-/* Multiply two rotation matrices: o=m*n. */
-static void mult_rotmat(float m[3][3], float n[3][3], float o[3][3])
-{
-  int i, j, k;
-
-  for (i=0; i<3; i++)
-  {
-    for (j=0; j<3; j++)
-    {
-      o[i][j] = 0.0;
-      for (k=0; k<3; k++)
-        o[i][j] += m[i][k]*n[k][j];
-    }
-  }
-}
-
-
-/* Compute 3D rotation angles from a unit quaternion. */
-static void quat_to_angles(float q[4], float *alpha, float *beta, float *delta)
-{
-  double r00, r01, r02, r12, r22;
-
-  r00 = q[0]*q[0]+q[1]*q[1]-q[2]*q[2]-q[3]*q[3];
-  r01 = 2.0*(q[1]*q[2]-q[0]*q[3]);
-  r02 = 2.0*(q[1]*q[3]+q[0]*q[2]);
-  r12 = 2.0*(q[2]*q[3]-q[0]*q[1]);
-  r22 = q[0]*q[0]-q[1]*q[1]-q[2]*q[2]+q[3]*q[3];
-
-  *alpha = atan2(-r12,r22)*180.0/M_PI;
-  *beta = atan2(r02,sqrt(r00*r00+r01*r01))*180.0/M_PI;
-  *delta = atan2(-r01,r00)*180.0/M_PI;
-}
-
-
-/* Compute a 3D rotation matrix from an xscreensaver unit quaternion. Note
-   that xscreensaver has a different convention for unit quaternions than
-   the one that is used in this hack. */
-static void quat_to_rotmat(float p[4], float m[3][3])
-{
-  float al, be, de;
-  double r00, r01, r02, r12, r22;
-
-  r00 = 1.0-2.0*(p[1]*p[1]+p[2]*p[2]);
-  r01 = 2.0*(p[0]*p[1]+p[2]*p[3]);
-  r02 = 2.0*(p[2]*p[0]-p[1]*p[3]);
-  r12 = 2.0*(p[1]*p[2]+p[0]*p[3]);
-  r22 = 1.0-2.0*(p[1]*p[1]+p[0]*p[0]);
-
-  al = atan2(-r12,r22)*180.0/M_PI;
-  be = atan2(r02,sqrt(r00*r00+r01*r01))*180.0/M_PI;
-  de = atan2(-r01,r00)*180.0/M_PI;
-  rotateall(al,be,de,m);
-}
-
-
-/* Compute a quaternion from angles in degrees. */
-static void angles_to_quat(float alpha, float beta, float delta, float p[4])
-{
-  alpha *= M_PI/180.0;
-  beta *= M_PI/180.0;
-  delta *= M_PI/180.0;
-  p[0] = (cos(0.5*alpha)*cos(0.5*beta)*cos(0.5*delta)-
-          sin(0.5*alpha)*sin(0.5*beta)*sin(0.5*delta));
-  p[1] = (sin(0.5*alpha)*cos(0.5*beta)*cos(0.5*delta)+
-          cos(0.5*alpha)*sin(0.5*beta)*sin(0.5*delta));
-  p[2] = (cos(0.5*alpha)*sin(0.5*beta)*cos(0.5*delta)-
-          sin(0.5*alpha)*cos(0.5*beta)*sin(0.5*delta));
-  p[3] = (cos(0.5*alpha)*cos(0.5*beta)*sin(0.5*delta)+
-          sin(0.5*alpha)*sin(0.5*beta)*cos(0.5*delta));
-}
-
-
-/* Perform a spherical linear interpolation between two quaternions. */
-static void quat_slerp(float t, float qs[4], float qe[4], float q[4])
-{
-  double cos_t, sin_t, alpha, beta, theta, phi, l;
-
-  alpha = t;
-  cos_t = qs[0]*qe[0]+qs[1]*qe[1]+qs[2]*qe[2]+qs[3]*qe[3];
-  if (1.0-cos_t < FLT_EPSILON)
-  {
-    beta = 1.0-alpha;
-  }
-  else
-  {
-    theta = acos(cos_t);
-    phi = theta;
-    sin_t = sin(theta);
-    beta = sin(theta-alpha*phi)/sin_t;
-    alpha = sin(alpha*phi)/sin_t;
-  }
-  q[0] = beta*qs[0]+alpha*qe[0];
-  q[1] = beta*qs[1]+alpha*qe[1];
-  q[2] = beta*qs[2]+alpha*qe[2];
-  q[3] = beta*qs[3]+alpha*qe[3];
-  l = 1.0/sqrt(q[0]*q[0]+q[1]*q[1]+q[2]*q[2]+q[3]*q[3]);
-  q[0] *= l;
-  q[1] *= l;
-  q[2] *= l;
-  q[3] *= l;
-}
-
-
-/* Compute a fully saturated and bright color based on an angle and a color
-   rotation matrix. */
-static void color(sphereeversionstruct *se, float angle, float mat[3][3],
-                  float colf[4], float colb[4])
-{
-  float ca, sa;
-  float m;
-
-  ca = cosf(angle);
-  sa = sinf(angle);
-  colf[0] = ca*mat[0][0]+sa*mat[0][2];
-  colf[1] = ca*mat[1][0]+sa*mat[1][2];
-  colf[2] = ca*mat[2][0]+sa*mat[2][2];
-  m = 0.5f/fmaxf(fmaxf(fabsf(colf[0]),fabsf(colf[1])),fabsf(colf[2]));
-  colf[0] = m*colf[0]+0.5f;
-  colf[1] = m*colf[1]+0.5f;
-  colf[2] = m*colf[2]+0.5f;
-  if (se->display_mode[0] == DISP_TRANSPARENT)
-    colf[3] = 0.7f;
-  else
-    colf[3] = 1.0f;
-
-  colb[0] = ca*mat[0][1]+sa*mat[0][2];
-  colb[1] = ca*mat[1][1]+sa*mat[1][2];
-  colb[2] = ca*mat[2][1]+sa*mat[2][2];
-  m = 0.5f/fmaxf(fmaxf(fabsf(colb[0]),fabsf(colb[1])),fabsf(colb[2]));
-  colb[0] = m*colb[0]+0.5f;
-  colb[1] = m*colb[1]+0.5f;
-  colb[2] = m*colb[2]+0.5f;
-  if (se->display_mode[0] == DISP_TRANSPARENT)
-    colb[3] = 0.7f;
-  else
-    colb[3] = 1.0f;
-}
-
-
-/* Compute the cross product between the vectors a and b. */
-static inline void cross(float a[3], float b[3], float c[3])
-{
-  c[0] = a[1]*b[2]-a[2]*b[1];
-  c[1] = a[2]*b[0]-a[0]*b[2];
-  c[2] = a[0]*b[1]-a[1]*b[0];
-}
-
-
-/* Compute x^n for integers 0 <= n <= 11 efficiently. */
-static inline double ipow(double x, int n)
-{
-  double x2, x4, x8;
-
-  switch (n)
-  {
-    case 0:
-      return 1.0;
-    case 1:
-      return x;
-    case 2:
-      x2 = x*x;
-      return x2;
-    case 3:
-      x2 = x*x;
-      return x2*x;
-    case 4:
-      x2 = x*x;
-      x4 = x2*x2;
-      return x4;
-    case 5:
-      x2 = x*x;
-      x4 = x2*x2;
-      return x4*x;
-    case 6:
-      x2 = x*x;
-      x4 = x2*x2;
-      return x4*x2;
-    case 7:
-      x2 = x*x;
-      x4 = x2*x2;
-      return x4*x2*x;
-    case 8:
-      x2 = x*x;
-      x4 = x2*x2;
-      x8 = x4*x4;
-      return x8;
-    case 9:
-      x2 = x*x;
-      x4 = x2*x2;
-      x8 = x4*x4;
-      return x8*x;
-    case 10:
-      x2 = x*x;
-      x4 = x2*x2;
-      x8 = x4*x4;
-      return x8*x2;
-    case 11:
-      x2 = x*x;
-      x4 = x2*x2;
-      x8 = x4*x4;
-      return x8*x2*x;
-    default:
-      return pow(x,n);
-  }
-}
-
-
-/* Compute the Bednorz shape parameter kappa based on the eversion order n. */
-static inline double bednorz_get_kappa(int n)
-{
-  return (n-1.0)/(2.0*n);
-}
-
-
-/* Compute the Bednorz shape parameter t based on the deformation
-   parameter tau. */
-static inline double bednorz_get_t(double tau)
-{
-  return (tau >= BEDNORZ_TAU1 ?
-          BEDNORZ_TAU1 :
-          (tau <= -BEDNORZ_TAU1 ?
-           -BEDNORZ_TAU1 :
-           tau));
-}
-
-
-/* Compute the Bednorz shape parameter q based on the deformation
-   parameter tau. */
-static inline double bednorz_get_q(double tau)
-{
-  double abs_tau;
-
-  abs_tau = fabs(tau);
-  return (abs_tau < BEDNORZ_TAU1 ?
-          0.0 :
-          (abs_tau < BEDNORZ_TAU2 ?
-           BEDNORZ_Q*(abs_tau-BEDNORZ_TAU1)/(BEDNORZ_TAU2-BEDNORZ_TAU1) :
-           BEDNORZ_Q));
-}
-
-
-/* Compute the Bednorz shape parameter p based on the deformation
-   parameter tau. */
-static inline double bednorz_get_p(double tau)
-{
-  return 1.0-fabs(bednorz_get_q(tau)*bednorz_get_t(tau));
-}
-
-
-/* Compute the Bednorz shape parameter xi based on the deformation
-   parameter tau. */
-static inline double bednorz_get_xi(double tau)
-{
-  double abs_tau;
-
-  abs_tau = fabs(tau);
-  return (abs_tau < BEDNORZ_TAU2 ?
-          1.0 :
-          (abs_tau < BEDNORZ_TAU3 ?
-           (BEDNORZ_TAU3-abs_tau)/(BEDNORZ_TAU3-BEDNORZ_TAU2) :
-           0.0));
-}
-
-
-/* Compute the Bednorz shape parameter eta based on the deformation
-   parameter tau and the shape parameter eta_min. */
-static inline double bednorz_get_eta(double tau, double eta_min)
-{
-  double abs_tau;
-
-  abs_tau = fabs(tau);
-  return (abs_tau < BEDNORZ_TAU2 ?
-          eta_min :
-          (abs_tau < BEDNORZ_TAU3 ?
-           (eta_min+(1.0-eta_min)*
-            (abs_tau-BEDNORZ_TAU2)/(BEDNORZ_TAU3-BEDNORZ_TAU2)) :
-           1.0));
-}
-
-
-/* Compute the Bednorz shape parameter alpha based on the deformation
-   parameter tau. */
-static inline double bednorz_get_alpha(double tau)
-{
-  double xi;
-
-  xi = bednorz_get_xi(tau);
-  return BEDNORZ_ALPHA*ipow(xi,2);
-}
-
-
-/* Compute the Bednorz shape parameter beta based on the deformation
-   parameter tau and the shape parameter beta_max. */
-static inline double bednorz_get_beta(double tau, double beta_max)
-{
-  double xi;
-
-  xi = bednorz_get_xi(tau);
-  return ipow(1.0-xi,2)+beta_max*ipow(xi,3);
-}
-
-
-/* Compute the Bednorz shape parameter gamma based on the shape
-   parameters alpha and beta. */
-static inline double bednorz_get_gamma(double alpha, double beta)
-{
-  return 2.0*sqrt(alpha*beta);
-}
-
-
-/* Compute the Bednorz shape parameter lambda based on the deformation
-   parameter tau. */
-static inline double bednorz_get_lambda(double tau)
-{
-  double abs_tau;
-
-  abs_tau = fabs(tau);
-  return (abs_tau < BEDNORZ_TAU3 ?
-          1.0 :
-          (abs_tau < BEDNORZ_TAU4 ?
-           (BEDNORZ_TAU4-abs_tau)/(BEDNORZ_TAU4-BEDNORZ_TAU3) :
-           0.0));
-}
-
-
-/* Compute the Bednorz shape parameter eps based on the deformation
-   parameter tau and the eversion order n.  This is an extension to the
-   original approach that prevents z fighting to some extent in certain
-   stages of the eversion. */
-static inline double bednorz_get_eps(double tau, int n)
-{
-  double sgn_tau, abs_tau;
-
-  sgn_tau = (tau < 0.0 ? -1.0 : (tau > 0.0 ? 1.0 : 0.0));
-  abs_tau = fabs(tau);
-  switch (n)
-  {
-    case 2:
-      return (abs_tau < BEDNORZ_TAU1 ?
-              0.0 :
-              (abs_tau < BEDNORZ_TAU2 ?
-               (BEDNORZ_EPS2*sgn_tau*
-                (abs_tau-BEDNORZ_TAU1)/(BEDNORZ_TAU2-BEDNORZ_TAU1)) :
-               (abs_tau < BEDNORZ_TAU3 ?
-                BEDNORZ_EPS2*sgn_tau :
-                (abs_tau < BEDNORZ_TAU4 ?
-                 (BEDNORZ_EPS2*sgn_tau*
-                  (BEDNORZ_TAU4-abs_tau)/(BEDNORZ_TAU4-BEDNORZ_TAU3)) :
-                 0.0))));
-    case 3:
-      return (abs_tau < BEDNORZ_TAU1 ?
-              BEDNORZ_EPS3*sgn_tau*abs_tau/BEDNORZ_TAU1 :
-              (abs_tau < BEDNORZ_TAU3 ?
-               BEDNORZ_EPS3*sgn_tau :
-               (abs_tau < BEDNORZ_TAU4 ?
-                (BEDNORZ_EPS3*sgn_tau*
-                 (BEDNORZ_TAU4-abs_tau)/(BEDNORZ_TAU4-BEDNORZ_TAU3)) :
-                0.0)));
-    case 4:
-      return (abs_tau < BEDNORZ_TAU1 ?
-              BEDNORZ_EPS4*sgn_tau*abs_tau/BEDNORZ_TAU1 :
-              (abs_tau < BEDNORZ_TAU3 ?
-               BEDNORZ_EPS4*sgn_tau :
-               (abs_tau < BEDNORZ_TAU4 ?
-                (BEDNORZ_EPS4*sgn_tau*
-                 (BEDNORZ_TAU4-abs_tau)/(BEDNORZ_TAU4-BEDNORZ_TAU3)) :
-                0.0)));
-    case 5:
-      return (abs_tau < BEDNORZ_TAU1 ?
-              BEDNORZ_EPS5*sgn_tau*abs_tau/BEDNORZ_TAU1 :
-              (abs_tau < BEDNORZ_TAU3 ?
-               BEDNORZ_EPS5*sgn_tau :
-               (abs_tau < BEDNORZ_TAU4 ?
-                (BEDNORZ_EPS5*sgn_tau*
-                 (BEDNORZ_TAU4-abs_tau)/(BEDNORZ_TAU4-BEDNORZ_TAU3)) :
-                0.0)));
-    default:
-      return 0.0;
-  }
-}
-
-
-/* Compute the equations for a point x and its partial derivatives dxdph and
-   dxdth in the Bednorz sphere eversion based on the sphere parameters phi
-   (longitude) and theta (latitude) and the shape parameters bsp.  This
-   corresponds to equations (4), (12), and (15) in the paper. */
-static inline void bednorz_get_p0(double phi, double theta,
-                                  bednorz_shape_par *bsp, double x[3],
-                                  double dxdph[3], double dxdth[3])
-{
-  int n;
-  double kappa, omega, t, p, q, eta, lambda;
-  double ct, st, cp, sp, cnm1p, snm1p, cnp, snp;
-  double ctn, ictn, ictnp1, ct2, st2, ct2n, ict2n, ict2np1, ton;
-  double oml, omlplctn, pe1pk, tat2k, nst2pct2, ost, snpmqt;
-  double nm1p, ostictn, oictnp1, nst2pct2oictnp1, tcp, tsp;
-  double lost, tomlplctn, lostcp, lostsp, tomlplctncp, tomlplctnsp;
-  double tomlplctncpmlostsp, tomlplctnspplostcp, ntctnst, oct2;
-  double omlpe1pktat2k, nst2;
-
-  n = bsp->n;
-  kappa = bsp->kappa;
-  omega = bsp->omega;
-  t = bsp->t;
-  p = bsp->p;
-  q = bsp->q;
-  eta = bsp->eta;
-  lambda = bsp->lambda;
-
-  ct = cos(theta);
-  st = sin(theta);
-  cp = cos(phi);
-  sp = sin(phi);
-  cnp = cos(n*phi);
-  snp = sin(n*phi);
-  ctn = ipow(ct,n);
-  ictn = 1.0/ctn;
-  ictnp1 = ictn/ct;
-  ct2 = ct*ct;
-  st2 = st*st;
-  ton = t/n;
-  snpmqt = snp-q*t;
-  ost = omega*st;
-
-  if (lambda >= 1.0)
-  {
-    cnm1p = cos((n-1)*phi);
-    snm1p = sin((n-1)*phi);
-    nst2pct2 = n*st2+ct2;
-    nm1p = (n-1)*p;
-    tcp = t*cp;
-    tsp = t*sp;
-    ostictn = ost*ictn;
-    oictnp1 = omega*ictnp1;
-    nst2pct2oictnp1 = nst2pct2*oictnp1;
-    x[0] = p*snm1p-sp*ostictn+tcp;
-    x[1] = p*cnm1p+cp*ostictn+tsp;
-    x[2] = snpmqt*ostictn-ton*cnp;
-    dxdph[0] = nm1p*cnm1p-cp*ostictn-tsp;
-    dxdph[1] = -nm1p*snm1p-sp*ostictn+tcp;
-    dxdph[2] = n*cnp*ostictn+t*snp;
-    dxdth[0] = -sp*nst2pct2oictnp1;
-    dxdth[1] = cp*nst2pct2oictnp1;
-    dxdth[2] = snpmqt*nst2pct2oictnp1;
-    /* The same formulas written out in full glory:
-       x[0] = (t*cos(phi)+
-               p*sin((n-1)*phi)-
-               (omega*sin(theta)/ipow(cos(theta),n))*sin(phi));
-       x[1] = (t*sin(phi)+
-               p*cos((n-1)*phi)+
-               (omega*sin(theta)/ipow(cos(theta),n))*cos(phi));
-       x[2] = ((omega*sin(theta)/ipow(cos(theta),n))*sin(n*phi)-
-               (t/n)*cos(n*phi)-
-               omega*q*t*sin(theta)/ipow(cos(theta),n));
-       dxdph[0] = (-t*sin(phi)+
-                   (n-1)*p*cos((n-1)*phi)-
-                   (omega*sin(theta)/ipow(cos(theta),n))*cos(phi));
-       dxdph[1] = (t*cos(phi)-
-                   (n-1)*p*sin((n-1)*phi)-
-                   (omega*sin(theta)/ipow(cos(theta),n))*sin(phi));
-       dxdph[2] = ((n*omega*sin(theta)/ipow(cos(theta),n))*cos(n*phi)+
-                   t*sin(n*phi));
-       dxdth[0] = -((omega*sin(phi)*(n*ipow(sin(theta),2)+ipow(cos(theta),2)))/
-                    ipow(cos(theta),n+1));
-       dxdth[1] = ((omega*cos(phi)*(n*ipow(sin(theta),2)+ipow(cos(theta),2)))/
-                   ipow(cos(theta),n+1));
-       dxdth[2] = ((omega*sin(n*phi)*(n*ipow(sin(theta),2)+ipow(cos(theta),2))/
-                    ipow(cos(theta),n+1))-
-                   (omega*q*t*(n*ipow(sin(theta),2)+ipow(cos(theta),2))/
-                    ipow(cos(theta),n+1)));
-     */
-  }
-  else
-  {
-    ct2n = ipow(ct,2*n);
-    ict2n = 1.0/ct2n;
-    ict2np1 = ict2n/ct;
-    oml = 1.0-lambda;
-    omlplctn = oml+lambda*ctn;
-    pe1pk = pow(eta,1.0+kappa);
-    tat2k = t*pow(fabs(t),2.0*kappa);
-    lost = lambda*ost;
-    lostcp = lost*cp;
-    lostsp = lost*sp;
-    tomlplctn = t*omlplctn;
-    tomlplctncp = tomlplctn*cp;
-    tomlplctnsp = tomlplctn*sp;
-    tomlplctncpmlostsp = tomlplctncp-lostsp;
-    tomlplctnspplostcp = tomlplctnsp+lostcp;
-    ntctnst = n*t*ctn*st;
-    oct2 = omega*ct2;
-    omlpe1pktat2k = oml*pe1pk*tat2k;
-    nst2 = n*st2;
-    x[0] = tomlplctncpmlostsp*ictn;
-    x[1] = tomlplctnspplostcp*ictn;
-    x[2] = lambda*(ost*snpmqt*ictn-ton*cnp)-omlpe1pktat2k*st*ict2n;
-    dxdph[0] = -tomlplctnspplostcp*ictn;
-    dxdph[1] = tomlplctncpmlostsp*ictn;
-    dxdph[2] = lambda*(omega*n*st*cnp*ictn+t*snp);
-    dxdth[0] = (n*tomlplctncpmlostsp*st-lambda*(ntctnst*cp+oct2*sp))*ictnp1;
-    dxdth[1] = (n*tomlplctnspplostcp*st-lambda*(ntctnst*sp-oct2*cp))*ictnp1;
-    dxdth[2] = (lambda*omega*snpmqt*(nst2+ct2)*ictnp1-
-                omlpe1pktat2k*(2.0*nst2+ct2)*ict2np1);
-    /* The same formulas written out in full glory:
-       x[0] = ((t*(1.0-lambda+lambda*ipow(cos(theta),n))*cos(phi)-
-                lambda*omega*sin(theta)*sin(phi))/
-               ipow(cos(theta),n));
-       x[1] = ((t*(1.0-lambda+lambda*ipow(cos(theta),n))*sin(phi)+
-                lambda*omega*sin(theta)*cos(phi))/
-               ipow(cos(theta),n));
-       x[2] = (lambda*(omega*sin(theta)*(sin(n*phi)-q*t)/ipow(cos(theta),n)-
-                       (t/n)*cos(n*phi))-
-               (1.0-lambda)*pow(eta,1.0+kappa)*
-               t*pow(fabs(t),2.0*kappa)*sin(theta)/ipow(cos(theta),2*n));
-       dxdph[0] = ((-t*(1.0-lambda+lambda*ipow(cos(theta),n))*sin(phi)-
-                    lambda*omega*sin(theta)*cos(phi))/
-                   ipow(cos(theta),n));
-       dxdph[1] = ((t*(1.0-lambda+lambda*ipow(cos(theta),n))*cos(phi)-
-                    lambda*omega*sin(theta)*sin(phi))/
-                   ipow(cos(theta),n));
-       dxdph[2] = (lambda*(omega*n*sin(theta)*(cos(n*phi))/ipow(cos(theta),n)+
-                           t*sin(n*phi)));
-       dxdth[0] = ((n*(t*(1.0-lambda+lambda*ipow(cos(theta),n))*cos(phi)-
-                       lambda*omega*sin(theta)*sin(phi))*sin(theta)/
-                    ipow(cos(theta),n+1))-
-                   (lambda*(n*t*ipow(cos(theta),n)*sin(theta)*cos(phi)+
-                            omega*ipow(cos(theta),2)*sin(phi))/
-                    ipow(cos(theta),n+1)));
-       dxdth[1] = ((n*(t*(1.0-lambda+lambda*ipow(cos(theta),n))*sin(phi)+
-                       lambda*omega*sin(theta)*cos(phi))*sin(theta)/
-                    ipow(cos(theta),n+1))-
-                   (lambda*(n*t*ipow(cos(theta),n)*sin(theta)*sin(phi)-
-                            omega*ipow(cos(theta),2)*cos(phi))/
-                    ipow(cos(theta),n+1)));
-       dxdth[2] = ((lambda*omega*(sin(n*phi)-q*t)*
-                    (n*ipow(sin(theta),2)+ipow(cos(theta),2))/
-                    ipow(cos(theta),n+1))-
-                   ((1.0-lambda)*pow(eta,1.0+kappa)*t*pow(fabs(t),2.0*kappa)*
-                    (2.0*n*ipow(sin(theta),2)+ipow(cos(theta),2))/
-                    ipow(cos(theta),2*n+1)));
-     */
-  }
-}
-
-
-/* Compute the equations for a point y and its partial derivatives dydph and
-   dydth in the Bednorz sphere eversion based on the sphere parameters phi
-   (longitude) and theta (latitude) and the shape parameters bsp.  This
-   corresponds to equation (7) in the paper. */
-static inline void bednorz_get_p1(double phi, double theta,
-                                  bednorz_shape_par *bsp, double y[3],
-                                  double dydph[3], double dydth[3])
-{
-  double kappa, xi, eta;
-  double x[3], dxdph[3], dxdth[3];
-  double x0, x1, x2, x02, x12, x02px12, ex02px12, xipex02px12;
-  double ixipex02px122, ixipex02px12k, ixipex02px12kp1;
-  double x0dx0dphpx1dx1dph, x0dx0dthpx1dx1dth;
-  double tex0dx0dphpx1dx1dph, tex0dx0dthpx1dx1dth;
-  double ktex0dx0dphpx1dx1dph, ktex0dx0dthpx1dx1dth;
-
-  kappa = bsp->kappa;
-  xi = bsp->xi;
-  eta = bsp->eta;
-
-  bednorz_get_p0(phi,theta,bsp,x,dxdph,dxdth);
-
-  x0 = x[0];
-  x1 = x[1];
-  x2 = x[2];
-  x02 = x0*x0;
-  x12 = x1*x1;
-  x02px12 = x02+x12;
-  ex02px12 = eta*x02px12;
-  xipex02px12 = xi+ex02px12;
-  ixipex02px122 = 1.0/(xipex02px12*xipex02px12);
-  ixipex02px12k = 1.0/pow(xipex02px12,kappa);
-  ixipex02px12kp1 = ixipex02px12k/xipex02px12;
-  x0dx0dphpx1dx1dph = x0*dxdph[0]+x1*dxdph[1];
-  x0dx0dthpx1dx1dth = x0*dxdth[0]+x1*dxdth[1];
-  tex0dx0dphpx1dx1dph = 2.0*eta*x0dx0dphpx1dx1dph;
-  tex0dx0dthpx1dx1dth = 2.0*eta*x0dx0dthpx1dx1dth;
-  ktex0dx0dphpx1dx1dph = kappa*tex0dx0dphpx1dx1dph;
-  ktex0dx0dthpx1dx1dth = kappa*tex0dx0dthpx1dx1dth;
-
-  y[0] = x0*ixipex02px12k;
-  y[1] = x1*ixipex02px12k;
-  y[2] = x2/xipex02px12;
-  dydph[0] = (dxdph[0]*xipex02px12-ktex0dx0dphpx1dx1dph*x0)*ixipex02px12kp1;
-  dydph[1] = (dxdph[1]*xipex02px12-ktex0dx0dphpx1dx1dph*x1)*ixipex02px12kp1;
-  dydph[2] = (dxdph[2]*xipex02px12-tex0dx0dphpx1dx1dph*x2)*ixipex02px122;
-  dydth[0] = (dxdth[0]*xipex02px12-ktex0dx0dthpx1dx1dth*x0)*ixipex02px12kp1;
-  dydth[1] = (dxdth[1]*xipex02px12-ktex0dx0dthpx1dx1dth*x1)*ixipex02px12kp1;
-  dydth[2] = (dxdth[2]*xipex02px12-tex0dx0dthpx1dx1dth*x2)*ixipex02px122;
-
-  /* The same formulas written out in full glory:
-     y[0] = x[0]/pow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),kappa);
-     y[1] = x[1]/pow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),kappa);
-     y[2] = x[2]/(xi+eta*(ipow(x[0],2)+ipow(x[1],2)));
-     dydph[0] = ((dxdph[0]*(xi+eta*(ipow(x[0],2)+ipow(x[1],2)))-
-                  2.0*eta*kappa*x[0]*(x[0]*dxdph[0]+x[1]*dxdph[1]))/
-                 pow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),kappa+1.0));
-     dydph[1] = ((dxdph[1]*(xi+eta*(ipow(x[0],2)+ipow(x[1],2)))-
-                  2.0*eta*kappa*x[1]*(x[0]*dxdph[0]+x[1]*dxdph[1]))/
-                 pow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),kappa+1.0));
-     dydph[2] = ((dxdph[2]*(xi+eta*(ipow(x[0],2)+ipow(x[1],2)))-
-                  2.0*eta*x[2]*(x[0]*dxdph[0]+x[1]*dxdph[1]))/
-                 ipow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),2));
-     dydth[0] = ((dxdth[0]*(xi+eta*(ipow(x[0],2)+ipow(x[1],2)))-
-                  2.0*eta*kappa*x[0]*(x[0]*dxdth[0]+x[1]*dxdth[1]))/
-                 pow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),kappa+1.0));
-     dydth[1] = ((dxdth[1]*(xi+eta*(ipow(x[0],2)+ipow(x[1],2)))-
-                  2.0*eta*kappa*x[1]*(x[0]*dxdth[0]+x[1]*dxdth[1]))/
-                 pow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),kappa+1.0));
-     dydth[2] = ((dxdth[2]*(xi+eta*(ipow(x[0],2)+ipow(x[1],2)))-
-                  2.0*eta*x[2]*(x[0]*dxdth[0]+x[1]*dxdth[1]))/
-                 ipow(xi+eta*(ipow(x[0],2)+ipow(x[1],2)),2));
-  */
-}
-
-
-/* Compute the equations for a point z and its partial derivatives dzdph and
-   dzdth in the Bednorz sphere eversion based on the sphere parameters phi
-   (longitude) and theta (latitude) and the shape parameters bsp.  This
-   corresponds to equations (8) and (9) in the paper. */
-static void inline bednorz_get_p2(double phi, double theta,
-                                  bednorz_shape_par *bsp, double z[3],
-                                  double dzdph[3], double dzdth[3])
-{
-  double alpha, beta, gamma;
-  double y[3], dydph[3], dydth[3];
-  double y0, y1, y2, y02, y12, y02py12, egy2, apby02py12, amby02py12;
-  double iapby02py12, iapby02py122, igapby02py12, igapby02py122;
-  double ambogapb, egy2apby02py12, egy2amby02py12, tbegy2;
-  double y0dy0dphpy1dy1dph, y0dy0dthpy1dy1dth;
-  double iy02py12, iy02py122, ty0dy0dphpy1dy1dph, ty0dy0dthpy1dy1dth;
-  double tbegy2y0dy0dphpy1dy1dph, tbegy2y0dy0dthpy1dy1dth;
-  double gigapby02py122, gegy2amby02py12;
-
-  alpha = bsp->alpha;
-  beta = bsp->beta;
-  gamma = bsp->gamma;
-
-  bednorz_get_p1(phi,theta,bsp,y,dydph,dydth);
-
-  y0 = y[0];
-  y1 = y[1];
-  y2 = y[2];
-  y02 = y0*y0;
-  y12 = y1*y1;
-  y02py12 = y02+y12;
-  y0dy0dphpy1dy1dph = y0*dydph[0]+y1*dydph[1];
-  y0dy0dthpy1dy1dth = y0*dydth[0]+y1*dydth[1];
-
-  if (alpha > 0.0)
-  {
-    /* For the north and south poles, the equations in bednorz_get_p0
-       and bednorz_get_p1 become singular.  Therefore, we include a special
-       treatment here.  Furthermore, we compute the surface normal vector
-       based on the cross product of the partial derivative vectors in
-       bednorz_point_normal.  For the north and south poles, the partial
-       derivative vectors are linearly dependent and thus don't yield a
-       useful normal vector.  Therefore, we have to include a special
-       treatment for the two poles. */
-    if (fabs(theta-M_PI/2.0) <= 1.0e-4)
-    {
-      z[0] = 0.0;
-      z[1] = 0.0;
-      z[2] = -sqrt(alpha/beta)/(alpha+beta);
-      dzdph[0] = 1.0;
-      dzdph[1] = 0.0;
-      dzdph[2] = 0.0;
-      dzdth[0] = 0.0;
-      dzdth[1] = 1.0;
-      dzdth[2] = 0.0;
-    }
-    else if (fabs(theta+M_PI/2.0) <= 1.0e-4)
-    {
-      z[0] = 0.0;
-      z[1] = 0.0;
-      z[2] = -sqrt(alpha/beta)/(alpha+beta);
-      dzdph[0] = 1.0;
-      dzdph[1] = 0.0;
-      dzdph[2] = 0.0;
-      dzdth[0] = 0.0;
-      dzdth[1] = -1.0;
-      dzdth[2] = 0.0;
-    }
-    else
-    {
-      egy2 = exp(gamma*y2);
-      apby02py12 = alpha+beta*y02py12;
-      amby02py12 = alpha-beta*y02py12;
-      iapby02py12 = 1.0/apby02py12;
-      iapby02py122 = iapby02py12*iapby02py12;
-      igapby02py12 = iapby02py12/gamma;
-      igapby02py122 = igapby02py12*igapby02py12;
-      ambogapb = (alpha-beta)/(gamma*(alpha+beta));
-      egy2apby02py12 = egy2*apby02py12;
-      egy2amby02py12 = egy2*amby02py12;
-      tbegy2 = 2.0*beta*egy2;
-      tbegy2y0dy0dphpy1dy1dph = tbegy2*y0dy0dphpy1dy1dph;
-      tbegy2y0dy0dthpy1dy1dth = tbegy2*y0dy0dthpy1dy1dth;
-      gigapby02py122 = gamma*igapby02py122;
-      gegy2amby02py12 = gamma*egy2amby02py12;
-
-      z[0] = y0*egy2*iapby02py12;
-      z[1] = y1*egy2*iapby02py12;
-      z[2] = egy2amby02py12*igapby02py12-ambogapb;
-      dzdph[0] = ((y0*gamma*dydph[2]+dydph[0])*egy2apby02py12-
-                  y0*tbegy2y0dy0dphpy1dy1dph)*iapby02py122;
-      dzdph[1] = ((y1*gamma*dydph[2]+dydph[1])*egy2apby02py12-
-                  y1*tbegy2y0dy0dphpy1dy1dph)*iapby02py122;
-      dzdph[2] = (((gegy2amby02py12*dydph[2]-tbegy2y0dy0dphpy1dy1dph)*
-                   apby02py12-tbegy2y0dy0dphpy1dy1dph*amby02py12)*
-                  gigapby02py122);
-      dzdth[0] = ((y0*gamma*dydth[2]+dydth[0])*egy2apby02py12-
-                  y0*tbegy2y0dy0dthpy1dy1dth)*iapby02py122;
-      dzdth[1] = ((y1*gamma*dydth[2]+dydth[1])*egy2apby02py12-
-                  y1*tbegy2y0dy0dthpy1dy1dth)*iapby02py122;
-      dzdth[2] = (((gegy2amby02py12*dydth[2]-tbegy2y0dy0dthpy1dy1dth)*
-                   apby02py12-tbegy2y0dy0dthpy1dy1dth*amby02py12)*
-                  gigapby02py122);
-    }
-
-    /* The same formulas written out in full glory:
-       z[0] = (y[0]*exp(gamma*y[2]))/(alpha+beta*(ipow(y[0],2)+ipow(y[1],2)));
-       z[1] = (y[1]*exp(gamma*y[2]))/(alpha+beta*(ipow(y[0],2)+ipow(y[1],2)));
-       z[2] = ((exp(gamma*y[2])*(alpha-beta*(ipow(y[0],2)+ipow(y[1],2))))/
-               (gamma*(alpha+beta*(ipow(y[0],2)+ipow(y[1],2))))-
-               ((alpha-beta)/(gamma*(alpha+beta))));
-       dzdph[0] = (((exp(gamma*y[2])*(gamma*y[0]*dydph[2]+dydph[0])*
-                     (alpha+beta*(ipow(y[0],2)+ipow(y[1],2))))-
-                    (2.0*beta*exp(gamma*y[2])*y[0]*
-                     (y[0]*dydph[0]+y[1]*dydph[1])))/
-                   ipow(alpha+beta*(ipow(y[0],2)+ipow(y[1],2)),2));
-       dzdph[1] = (((exp(gamma*y[2])*(gamma*y[1]*dydph[2]+dydph[1])*
-                     (alpha+beta*(ipow(y[0],2)+ipow(y[1],2))))-
-                    (2.0*beta*exp(gamma*y[2])*y[1]*
-                     (y[0]*dydph[0]+y[1]*dydph[1])))/
-                   ipow(alpha+beta*(ipow(y[0],2)+ipow(y[1],2)),2));
-       dzdph[2] = (((gamma*exp(gamma*y[2])*
-                     (alpha-beta*(ipow(y[0],2)+ipow(y[1],2)))*dydph[2]-
-                     2.0*beta*exp(gamma*y[2])*(y[0]*dydph[0]+y[1]*dydph[1]))*
-                    (gamma*(alpha+beta*(ipow(y[0],2)+ipow(y[1],2))))-
-                    (2.0*gamma*beta*exp(gamma*y[2])*
-                     (alpha-beta*(ipow(y[0],2)+ipow(y[1],2)))*
-                     (y[0]*dydph[0]+y[1]*dydph[1])))/
-                   ipow(gamma*(alpha+beta*(ipow(y[0],2)+ipow(y[1],2))),2));
-       dzdth[0] = (((exp(gamma*y[2])*(gamma*y[0]*dydth[2]+dydth[0])*
-                     (alpha+beta*(ipow(y[0],2)+ipow(y[1],2))))-
-                    (2.0*beta*exp(gamma*y[2])*y[0]*
-                     (y[0]*dydth[0]+y[1]*dydth[1])))/
-                   ipow(alpha+beta*(ipow(y[0],2)+ipow(y[1],2)),2));
-       dzdth[1] = (((exp(gamma*y[2])*(gamma*y[1]*dydth[2]+dydth[1])*
-                     (alpha+beta*(ipow(y[0],2)+ipow(y[1],2))))-
-                    (2.0*beta*exp(gamma*y[2])*y[1]*
-                     (y[0]*dydth[0]+y[1]*dydth[1])))/
-                   ipow(alpha+beta*(ipow(y[0],2)+ipow(y[1],2)),2));
-       dzdth[2] = (((gamma*exp(gamma*y[2])*
-                     (alpha-beta*(ipow(y[0],2)+ipow(y[1],2)))*dydth[2]-
-                     2.0*beta*exp(gamma*y[2])*(y[0]*dydth[0]+y[1]*dydth[1]))*
-                    (gamma*(alpha+beta*(ipow(y[0],2)+ipow(y[1],2))))-
-                    (2.0*gamma*beta*exp(gamma*y[2])*
-                     (alpha-beta*(ipow(y[0],2)+ipow(y[1],2)))*
-                     (y[0]*dydth[0]+y[1]*dydth[1])))/
-                   ipow(gamma*(alpha+beta*(ipow(y[0],2)+ipow(y[1],2))),2));
-     */
-  }
-  else
-  {
-    iy02py12 = 1.0/y02py12;
-    iy02py122 = iy02py12*iy02py12;
-    ty0dy0dphpy1dy1dph = 2.0*y0dy0dphpy1dy1dph;
-    ty0dy0dthpy1dy1dth = 2.0*y0dy0dthpy1dy1dth;
-
-    z[0] = y0*iy02py12;
-    z[1] = y1*iy02py12;
-    z[2] = -y2;
-
-    /* We compute the surface normal vector based on the cross product
-       of the partial derivative vectors in bednorz_point_normal.  For the
-       north and south poles, the partial derivative vectors are linearly
-       dependent and thus don't yield a useful normal vector.  Therefore,
-       we have to include a special treatment for the two poles. */
-    if (fabs(theta-M_PI/2.0) <= 1.0e-4)
-    {
-      dzdph[0] = 1.0;
-      dzdph[1] = 0.0;
-      dzdph[2] = 0.0;
-      dzdth[0] = 0.0;
-      dzdth[1] = 1.0;
-      dzdth[2] = 0.0;
-    }
-    else if (fabs(theta+M_PI/2.0) <= 1.0e-4)
-    {
-      dzdph[0] = 1.0;
-      dzdph[1] = 0.0;
-      dzdph[2] = 0.0;
-      dzdth[0] = 0.0;
-      dzdth[1] = -1.0;
-      dzdth[2] = 0.0;
-    }
-    else
-    {
-      dzdph[0] = (dydph[0]*y02py12-y0*ty0dy0dphpy1dy1dph)*iy02py122;
-      dzdph[1] = (dydph[1]*y02py12-y1*ty0dy0dphpy1dy1dph)*iy02py122;
-      dzdph[2] = -dydph[2];
-      dzdth[0] = (dydth[0]*y02py12-y0*ty0dy0dthpy1dy1dth)*iy02py122;
-      dzdth[1] = (dydth[1]*y02py12-y1*ty0dy0dthpy1dy1dth)*iy02py122;
-      dzdth[2] = -dydth[2];
-    }
-
-    /* The same formulas written out in full glory:
-       z[0] = y[0]/(ipow(y[0],2)+ipow(y[1],2));
-       z[1] = y[1]/(ipow(y[0],2)+ipow(y[1],2));
-       z[2] = -y[2];
-       dzdph[0] = ((dydph[0]*(ipow(y[0],2)+ipow(y[1],2))-
-                    2.0*y[0]*(y[0]*dydph[0]+y[1]*dydph[1]))/
-                   ipow(ipow(y[0],2)+ipow(y[1],2),2));
-       dzdph[1] = ((dydph[1]*(ipow(y[0],2)+ipow(y[1],2))-
-                    2.0*y[1]*(y[0]*dydph[0]+y[1]*dydph[1]))/
-                   ipow(ipow(y[0],2)+ipow(y[1],2),2));
-       dzdph[2] = -dydph[2];
-       dzdth[0] = ((dydth[0]*(ipow(y[0],2)+ipow(y[1],2))-
-                    2.0*y[0]*(y[0]*dydth[0]+y[1]*dydth[1]))/
-                   ipow(ipow(y[0],2)+ipow(y[1],2),2));
-       dzdth[1] = ((dydth[1]*(ipow(y[0],2)+ipow(y[1],2))-
-                    2.0*y[1]*(y[0]*dydth[0]+y[1]*dydth[1]))/
-                   ipow(ipow(y[0],2)+ipow(y[1],2),2));
-       dzdth[2] = -dydth[2];
-     */
-  }
-}
-
-
-/* Compute a point p and its surface normal n in the Bednorz sphere
-   eversion based on the sphere parameters phi (longitude) and theta
-   (latitude) and the shape parameters bsp. */
-static void inline bednorz_point_normal(double phi, double theta,
-                                        bednorz_shape_par *bsp,
-                                        float p[3], float n[3])
-{
-  double z[3], dzdph[3], dzdth[3];
-  float a[3], b[3], t;
-  float lambda, eps, oz;
-  int i;
-
-  bednorz_get_p2(phi,theta,bsp,z,dzdph,dzdth);
-
-  for (i=0; i<3; i++)
-  {
-    p[i] = z[i];
-    a[i] = dzdph[i];
-    b[i] = dzdth[i];
-  }
-
-  /* In the original version of the Bednorz sphere eversion, the regions
-     around the north and south poles of the sphere are deformed to points
-     that lie very close to each other.  This leads to a significant amount
-     of z fighting, especially for higher eversion orders, which is visually
-     unpleasant.  Therefore, we modify the shape of the deformed sphere very
-     slightly to avoid or at least ameliorate the z fighting. */
-  lambda = bsp->lambda;
-  eps = bsp->eps;
-  if (lambda == 1.0)
-    oz = eps*sin(theta);
-  else
-    oz = 0.0f;
-  p[2] += oz;
-
-  cross(a,b,n);
-  t = 1.0f/sqrtf(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);
-  n[0] *= t;
-  n[1] *= t;
-  n[2] *= t;
-}
-
-
-/* Set up the surface colors for the main pass (i.e., index 0). */
-static void setup_surface_colors(ModeInfo *mi, float phi_min, float phi_max,
-                                 float theta_min, float theta_max,
-                                 int num_phi, int num_theta)
-{
-  int i, j, o;
-  float matc[3][3];
-  float phi, theta, phi_range, theta_range;
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-
-  if (se->colors[0] != COLORS_TWOSIDED)
-  {
-    /* Compute the rotation that rotates the color basis vectors. */
-    for (i=0; i<3; i++)
-      for (j=0; j<3; j++)
-        matc[i][j] = (i==j);
-    rotatez(matc,-26.565051177078015);
-    rotatey(matc,-335.90515744788928);
-    rotatex(matc,-50.768479516407787);
-
-    phi_range = phi_max-phi_min;
-    theta_range = theta_max-theta_min;
-    for (j=0; j<=num_phi; j++)
-    {
-      phi = phi_range*j/num_phi+phi_min;
-      for (i=0; i<=num_theta; i++)
-      {
-        o = j*(num_theta+1)+i;
-        theta = theta_range*i/num_theta+theta_min;
-        if (se->colors[0] == COLORS_PARALLEL)
-          color(se,(2.0f*theta+M_PI)*(2.0f/3.0f),matc,&se->colf[0][4*o],
-              &se->colb[0][4*o]);
-        else /* se->colors[0] == COLORS_MERIDIAN */
-          color(se,phi+M_PI,matc,&se->colf[0][4*o],&se->colb[0][4*o]);
-      }
-    }
-  }
-#ifdef VERTEXATTRIBARRAY_WORKAROUND
-  else /* se->colors[0] == COLORS_TWOSIDED */
-  {
-    /* For some strange reason, the color buffer must be initialized
-       and used on macOS. Otherwise two-sided lighting will not
-       work. */
-    int k;
-    for (j=0; j<=num_phi; j++)
-    {
-      for (i=0; i<=num_theta; i++)
-      {
-        o = j*(num_theta+1)+i;
-        for (k=0; k<4; k++)
-        {
-          se->colf[0][4*o+k] = 1.0f;
-          se->colb[0][4*o+k] = 1.0f;
-        }
-      }
-    }
-  }
-#endif /* VERTEXATTRIBARRAY_WORKAROUND */
-
-#ifdef HAVE_GLSL
-  if (se->use_shaders)
-  {
-    glBindBuffer(GL_ARRAY_BUFFER,se->vertex_colorf_buffer[0]);
-    glBufferData(GL_ARRAY_BUFFER,
-                 4*(num_phi+1)*(num_theta+1)*sizeof(GLfloat),
-                 se->colf[0],GL_STATIC_DRAW);
-    glBindBuffer(GL_ARRAY_BUFFER,0);
-
-    glBindBuffer(GL_ARRAY_BUFFER,se->vertex_colorb_buffer[0]);
-    glBufferData(GL_ARRAY_BUFFER,
-                 4*(num_phi+1)*(num_theta+1)*sizeof(GLfloat),
-                 se->colb[0],GL_STATIC_DRAW);
-      glBindBuffer(GL_ARRAY_BUFFER,0);
-  }
-#endif /* HAVE_GLSL */
-}
-
-
-/* Draw the Bednorz sphere eversion using OpenGL's fixed
-   functionality. */
-static int bednorz_sphere_eversion_ff(ModeInfo *mi, float phi_min,
-                                      float phi_max, float theta_min,
-                                      float theta_max, int num_phi,
-                                      int num_theta, int numb_dist,
-                                      int numb_dir, int num_grid)
-{
-  static const GLfloat light_ambient[]        = { 0.0, 0.0, 0.0, 1.0 };
-  static const GLfloat light_diffuse[]        = { 1.0, 1.0, 1.0, 1.0 };
-  static const GLfloat light_specular[]       = { 1.0, 1.0, 1.0, 1.0 };
-  static const GLfloat light_position[]       = { 1.0, 1.0, 1.0, 0.0 };
-  static const GLfloat mat_specular[]         = { 1.0, 1.0, 1.0, 1.0 };
-  static const GLfloat mat_diff_front[]       = { 1.0, 0.0, 0.0, 1.0 };
-  static const GLfloat mat_diff_back[]        = { 0.0, 1.0, 0.0, 1.0 };
-  static const GLfloat mat_diff_trans_front[] = { 1.0, 0.0, 0.0, 0.7 };
-  static const GLfloat mat_diff_trans_back[]  = { 0.0, 1.0, 0.0, 0.7 };
-  float p[3], n[3], mat[3][3];
-  int i, j, k, l, m, o;
-  int numb_dist_mask, numb_dist_min, numb_dist_max;
-  int numb_dir_mask, numb_dir_min, numb_dir_max;
-  float phi, theta, phi_range, theta_range;
-  float *xx, *xn, *cf, *cb;
-  float a, b, c, d, e, tau, tau_min, tau_max, r, s;
-  float x, y, z, zmin, zmax, rmax, scale, offset_z;
-  bednorz_shape_par bsp;
-  float qu[4], r1[3][3], r2[3][3];
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-  int polys;
-
-  tau = se->tau;
-  /* Apply easing functions to the different ranges of tau. */
-  if (fabsf(tau) <= BEDNORZ_TAU4)
-  {
-    if (fabsf(tau) <= BEDNORZ_TAU1)
-    {
-      tau_min = 0.0f;
-      tau_max = BEDNORZ_TAU1;
-    }
-    else
-    if (fabsf(tau) <= BEDNORZ_TAU2)
-    {
-      tau_min = BEDNORZ_TAU1;
-      tau_max = BEDNORZ_TAU2;
-    }
-    else if (fabsf(tau) <= BEDNORZ_TAU3)
-    {
-      tau_min = BEDNORZ_TAU2;
-      tau_max = BEDNORZ_TAU3;
-    }
-    else /* fabsf(tau) <= BEDNORZ_TAU4 */
-    {
-      tau_min = BEDNORZ_TAU3;
-      tau_max = BEDNORZ_TAU4;
-    }
-    e = 1.0f/(tau_min*tau_min-2.0f*tau_min*tau_max+tau_max*tau_max);
-    a = -2.0f*e;
-    b = 3.0f*(tau_min+tau_max)*e;
-    c = -6.0f*tau_min*tau_max*e;
-    d = tau_min*tau_max*(tau_min+tau_max)*e;
-    if (tau >= 0.0f)
-      tau = ((a*tau+b)*tau+c)*tau+d;
-    else
-      tau = ((a*tau-b)*tau+c)*tau-d;
-  }
-  /* Set up the shape parameters. */
-  bsp.n = se->g;
-  bsp.kappa = bednorz_get_kappa(bsp.n);
-  bsp.omega = BEDNORZ_OMEGA;
-  bsp.t = bednorz_get_t(tau);
-  bsp.p = bednorz_get_p(tau);
-  bsp.q = bednorz_get_q(tau);
-  bsp.xi = bednorz_get_xi(tau);
-  bsp.eta = bednorz_get_eta(tau,se->eta_min);
-  bsp.alpha = bednorz_get_alpha(tau);
-  bsp.beta = bednorz_get_beta(tau,se->beta_max);
-  bsp.gamma = bednorz_get_gamma(bsp.alpha,bsp.beta);
-  bsp.lambda = bednorz_get_lambda(tau);
-  bsp.eps = bednorz_get_eps(tau,bsp.n);
-
-  /* Compute the surface points and normals. */
-  phi_range = phi_max-phi_min;
-  theta_range = theta_max-theta_min;
-  for (j=0; j<=num_phi; j++)
-  {
-    phi = phi_range*j/num_phi+phi_min;
-    for (i=0; i<=num_theta; i++)
-    {
-      o = j*(num_theta+1)+i;
-      theta = theta_range*i/num_theta+theta_min;
-      bednorz_point_normal(phi,theta,&bsp,&se->se[3*o],&se->sen[3*o]);
-    }
-  }
-
-  /* Compute the z offset. */
-  zmin = FLT_MAX;
-  zmax = -FLT_MAX;
-  for (j=0; j<=num_phi; j++)
-  {
-    for (i=0; i<=num_theta; i++)
-    {
-      o = j*(num_theta+1)+i;
-      z = se->se[3*o+2];
-      if (z < zmin)
-        zmin = z;
-      if (z > zmax)
-        zmax = z;
-    }
-  }
-  offset_z = -0.5f*(zmin+zmax);
-
-  /* Shift the surface in the z direction and compute the scale. */
-  rmax = -FLT_MAX;
-  for (j=0; j<=num_phi; j++)
-  {
-    for (i=0; i<=num_theta; i++)
-    {
-      o = j*(num_theta+1)+i;
-      se->se[3*o+2] += offset_z;
-      x = se->se[3*o];
-      y = se->se[3*o+1];
-      z = se->se[3*o+2];
-      r = x*x+y*y+z*z;
-      if (r > rmax)
-        rmax = r;
-    }
-  }
-  scale = 0.75f/sqrtf(rmax);
-
-  /* Scale the surface. */
-  for (j=0; j<=num_phi; j++)
-  {
-    for (i=0; i<=num_theta; i++)
-    {
-      o = j*(num_theta+1)+i;
-      se->se[3*o] *= scale;
-      se->se[3*o+1] *= scale;
-      se->se[3*o+2] *= scale;
-    }
-  }
-
-  /* Compute the rotation that rotates the surface in 3D, including the
-     trackball rotations. */
-  rotateall(se->alpha,se->beta,se->delta,r1);
-
-  gltrackball_get_quaternion(se->trackball,qu);
-  quat_to_rotmat(qu,r2);
-
-  mult_rotmat(r2,r1,mat);
-
-  numb_dist_mask = numb_dist-1;
-  numb_dist_min = numb_dist/4;
-  numb_dist_max = 3*numb_dist/4;
-  numb_dir_mask = numb_dir-1;
-  numb_dir_min = numb_dir/4;
-  numb_dir_max = 3*numb_dir/4;
-
-  glClearColor(0.0f,0.0f,0.0f,1.0f);
-  glClearDepth(1.0f);
-  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-
-  glMatrixMode(GL_PROJECTION);
-  glLoadIdentity();
-  if (se->projection == DISP_PERSPECTIVE)
-  {
-      gluPerspective(60.0,se->aspect,0.1,10.0);
-  }
-  else
-  {
-    if (se->aspect >= 1.0)
-      glOrtho(-se->aspect,se->aspect,-1.0,1.0,0.1,10.0);
-    else
-      glOrtho(-1.0,1.0,-1.0/se->aspect,1.0/se->aspect,0.1,10.0);
-  }
-  glMatrixMode(GL_MODELVIEW);
-  glLoadIdentity();
-
-  if (se->display_mode[0] == DISP_SURFACE)
-  {
-    glDisable(GL_CULL_FACE);
-    glEnable(GL_DEPTH_TEST);
-    glDepthFunc(GL_LESS);
-    glShadeModel(GL_SMOOTH);
-    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
-    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
-    glEnable(GL_LIGHTING);
-    glEnable(GL_LIGHT0);
-    glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
-    glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
-    glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular);
-    glLightfv(GL_LIGHT0,GL_POSITION,light_position);
-    glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
-    glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0);
-    glDepthMask(GL_TRUE);
-    glDisable(GL_BLEND);
-  }
-  else /* se->display_mode[0] == DISP_TRANSPARENT */
-  {
-    glDisable(GL_CULL_FACE);
-    glDisable(GL_DEPTH_TEST);
-    glShadeModel(GL_SMOOTH);
-    glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
-    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
-    glEnable(GL_LIGHTING);
-    glEnable(GL_LIGHT0);
-    glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
-    glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
-    glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular);
-    glLightfv(GL_LIGHT0,GL_POSITION,light_position);
-    glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
-    glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0);
-    glDepthMask(GL_FALSE);
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA,GL_ONE);
-  }
-
-  if (se->colors[0] == COLORS_TWOSIDED)
-  {
-    glColor3fv(mat_diff_front);
-    if (se->display_mode[0] == DISP_TRANSPARENT)
-    {
-      glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_front);
-      glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_back);
-    }
-    else
-    {
-      glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_front);
-      glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_back);
-    }
-  }
-  glEnable(GL_POLYGON_OFFSET_FILL);
-  glPolygonOffset(1.0f,1.0f);
-
-  if (se->appearance[0] == APPEARANCE_PARALLEL_BANDS)
-  {
-    for (i=0; i<num_theta; i++)
-    {
-      if (((i & numb_dist_mask) >= numb_dist_min) &&
-          ((i & numb_dist_mask) < numb_dist_max))
-        continue;
-      glBegin(GL_TRIANGLE_STRIP);
-      for (j=num_phi; j>=0; j--)
-      {
-        for (k=0; k<=1; k++)
-        {
-          l = i+k;
-          m = j;
-          o = m*(num_theta+1)+l;
-          phi = phi_range*m/num_phi+phi_min;
-          theta = theta_range*l/num_theta+theta_min;
-          xx = &se->se[3*o];
-          xn = &se->sen[3*o];
-          for (l=0; l<3; l++)
-          {
-            r = 0.0f;
-            s = 0.0f;
-            for (m=0; m<3; m++)
-            {
-              r += mat[l][m]*xx[m];
-              s += mat[l][m]*xn[m];
-            }
-            p[l] = r+se->offset3d[l];
-            n[l] = s;
-          }
-          if (se->colors[0] != COLORS_TWOSIDED)
-          {
-            cf = &se->colf[0][4*o];
-            cb = &se->colb[0][4*o];
-            glColor3fv(cf);
-            glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,cf);
-            glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,cb);
-          }
-          glNormal3fv(n);
-          glVertex3fv(p);
-        }
-      }
-      glEnd();
-    }
-    polys = num_theta*(num_phi+1);
-  }
-  else /* se->appearance[0] != APPEARANCE_PARALLEL_BANDS */
-  {
-    for (j=0; j<num_phi; j++)
-    {
-      if (se->appearance[0] == APPEARANCE_MERIDIAN_BANDS &&
-          ((j & numb_dir_mask) >= numb_dir_min) &&
-          ((j & numb_dir_mask) < numb_dir_max))
-        continue;
-      glBegin(GL_TRIANGLE_STRIP);
-      for (i=0; i<=num_theta; i++)
-      {
-        for (k=0; k<=1; k++)
-        {
-          l = i;
-          m = j+k;
-          o = m*(num_theta+1)+l;
-          phi = phi_range*m/num_phi+phi_min;
-          theta = theta_range*l/num_theta+theta_min;
-          xx = &se->se[3*o];
-          xn = &se->sen[3*o];
-          for (l=0; l<3; l++)
-          {
-            r = 0.0f;
-            s = 0.0f;
-            for (m=0; m<3; m++)
-            {
-              r += mat[l][m]*xx[m];
-              s += mat[l][m]*xn[m];
-            }
-            p[l] = r+se->offset3d[l];
-            n[l] = s;
-          }
-          if (se->colors[0] != COLORS_TWOSIDED)
-          {
-            cf = &se->colf[0][4*o];
-            cb = &se->colb[0][4*o];
-            glColor3fv(cf);
-            glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,cf);
-            glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,cb);
-          }
-          glNormal3fv(n);
-          glVertex3fv(p);
-        }
-      }
-      glEnd();
-    }
-    polys = 2*num_phi*(num_theta+1);
-    if (se->appearance[0] == APPEARANCE_MERIDIAN_BANDS)
-      polys /= 2;
-  }
-
-  glDisable(GL_POLYGON_OFFSET_FILL);
-  glPolygonOffset(0.0f,0.0f);
-  if (se->graticule[0])
-  {
-    glColor4f(1.0f,1.0f,1.0f,1.0f);
-    glLineWidth(2.0f);
-    glEnable(GL_LINE_SMOOTH);
-    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
-    glDisable(GL_LIGHTING);
-    glDisable(GL_LIGHT0);
-    glEnable(GL_BLEND);
-    glHint(GL_LINE_SMOOTH_HINT,GL_DONT_CARE);
-    /* Draw meridians. */
-    for (j=0; j<num_phi; j+=num_grid)
-    {
-      glBegin(GL_LINE_STRIP);
-      for (i=0; i<=num_theta; i++)
-      {
-        o = j*(num_theta+1)+i;
-        phi = phi_range*j/num_phi+phi_min;
-        theta = theta_range*i/num_theta+theta_min;
-        xx = &se->se[3*o];
-        for (l=0; l<3; l++)
-        {
-          r = 0.0f;
-          for (m=0; m<3; m++)
-            r += mat[l][m]*xx[m];
-          p[l] = r+se->offset3d[l];
-        }
-        glVertex3fv(p);
-      }
-      glEnd();
-    }
-    /* Draw parallels. */
-    for (i=num_grid; i<=num_theta-num_grid; i+=num_grid)
-    {
-      glBegin(GL_LINE_LOOP);
-      for (j=num_phi-1; j>=0; j--)
-      {
-        o = j*(num_theta+1)+i;
-        phi = phi_range*j/num_phi+phi_min;
-        theta = theta_range*i/num_theta+theta_min;
-        xx = &se->se[3*o];
-        for (l=0; l<3; l++)
-        {
-          r = 0.0f;
-          for (m=0; m<3; m++)
-            r += mat[l][m]*xx[m];
-          p[l] = r+se->offset3d[l];
-        }
-        glVertex3fv(p);
-      }
-      glEnd();
-    }
-    glLineWidth(1.0f);
-    glPolygonOffset(0.0f,0.0f);
-    glDisable(GL_LINE_SMOOTH);
-    glBlendFunc(GL_SRC_ALPHA,GL_ONE);
-    glEnable(GL_LIGHTING);
-    glEnable(GL_LIGHT0);
-    if (se->display_mode[0] != DISP_TRANSPARENT)
-      glDisable(GL_BLEND);
-  }
-
-  return polys;
-}
-
-
-#ifdef HAVE_GLSL
-
-/* Draw the Bednorz sphere eversion using OpenGL's programmable
-   functionality. */
-static int bednorz_sphere_eversion_pf(ModeInfo *mi, float phi_min,
-                                      float phi_max, float theta_min,
-                                      float theta_max, int num_phi,
-                                      int num_theta, int numb_dist,
-                                      int numb_dir, int num_grid)
-{
-  static const GLfloat light_model_ambient[]  = { 0.2, 0.2, 0.2, 1.0 };
-  static const GLfloat light_ambient[]        = { 0.0, 0.0, 0.0, 1.0 };
-  static const GLfloat light_diffuse[]        = { 1.0, 1.0, 1.0, 1.0 };
-  static const GLfloat light_specular[]       = { 1.0, 1.0, 1.0, 1.0 };
-  static const GLfloat light_position[]       = { 1.0, 1.0, 1.0, 0.0 };
-  static const GLfloat mat_specular[]         = { 1.0, 1.0, 1.0, 1.0 };
-  static const GLfloat mat_diff_front[]       = { 1.0, 0.0, 0.0, 1.0 };
-  static const GLfloat mat_diff_back[]        = { 0.0, 1.0, 0.0, 1.0 };
-  static const GLfloat mat_diff_trans_front[] = { 1.0, 0.0, 0.0, 0.7 };
-  static const GLfloat mat_diff_trans_back[]  = { 0.0, 1.0, 0.0, 0.7 };
-  static const GLfloat mat_diff_white[]       = { 1.0, 1.0, 1.0, 1.0 };
-  static const GLuint blend_indices[6] = { 0, 1, 2, 2, 3, 0 };
-  static const GLfloat blend_p[4][2] =
-    { { -1.0, -1.0 }, { 1.0, -1.0 }, { 1.0, 1.0 }, { -1.0, 1.0 } };
-  static const GLfloat blend_t[4][2] =
-    { { 0.0, 0.0 }, { 1.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 1.0 } };
-  GLfloat light_direction[3], half_vector[3], len;
-  GLfloat p_mat[16], mv_mat[16], rot_mat[16];
-  float mat[3][3];
-  int i, j, k, l, m, o, pass, num_passes, ni;
-  int numb_dist_mask, numb_dist_min, numb_dist_max;
-  int numb_dir_mask, numb_dir_min, numb_dir_max;
-  float phi, theta, phi_range, theta_range;
-  float a, b, c, d, e, tau, tau_min, tau_max, r, t;
-  float x, y, z, zmin, zmax, rmax, scale, offset_z;
-  bednorz_shape_par bsp;
-  float qu[4], r1[3][3], r2[3][3];
-  GLint draw_buf, read_buf;
-  GLsizeiptr index_offset;
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-  int polys = 0;
-
-  if (!se->use_shaders)
-    return 0;
-
-  numb_dist_mask = numb_dist-1;
-  numb_dist_min = numb_dist/4;
-  numb_dist_max = 3*numb_dist/4;
-  numb_dir_mask = numb_dir-1;
-  numb_dir_min = numb_dir/4;
-  numb_dir_max = 3*numb_dir/4;
-
-  if (!se->buffers_initialized)
-  {
-    /* The indices only need to be computed once. */
-    /* Compute the solid indices. */
-    ni = 0;
-    se->num_solid_strips = 0;
-    se->num_solid_triangles = 0;
-    for (j=0; j<num_phi; j++)
-    {
-      for (i=0; i<=num_theta; i++)
-      {
-        for (k=0; k<=1; k++)
-        {
-          l = i;
-          m = j+k;
-          o = m*(num_theta+1)+l;
-          se->solid_indices[ni++] = o;
-        }
-      }
-      se->num_solid_strips++;
-    }
-    se->num_solid_triangles = 2*(num_theta+1);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->solid_indices_buffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER,ni*sizeof(GLuint),
-                 se->solid_indices,GL_STATIC_DRAW);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-    /* Compute the meridian indices. */
-    ni = 0;
-    se->num_meridian_strips = 0;
-    se->num_meridian_triangles = 0;
-    for (j=0; j<num_phi; j++)
-    {
-      if (((j & numb_dir_mask) >= numb_dir_min) &&
-          ((j & numb_dir_mask) < numb_dir_max))
-        continue;
-      for (i=0; i<=num_theta; i++)
-      {
-        for (k=0; k<=1; k++)
-        {
-          l = i;
-          m = j+k;
-          o = m*(num_theta+1)+l;
-          se->meridian_indices[ni++] = o;
-        }
-      }
-      se->num_meridian_strips++;
-    }
-    se->num_meridian_triangles = 2*(num_theta+1);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->meridian_indices_buffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER,ni*sizeof(GLuint),
-                 se->meridian_indices,GL_STATIC_DRAW);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-    /* Compute the parallel indices. */
-    ni = 0;
-    se->num_parallel_strips = 0;
-    se->num_parallel_triangles = 0;
-    for (i=0; i<num_theta; i++)
-    {
-      if (((i & numb_dist_mask) >= numb_dist_min) &&
-          ((i & numb_dist_mask) < numb_dist_max))
-        continue;
-      for (j=num_phi; j>=0; j--)
-      {
-        for (k=0; k<=1; k++)
-        {
-          l = i+k;
-          m = j;
-          o = m*(num_theta+1)+l;
-          se->parallel_indices[ni++] = o;
-        }
-      }
-      se->num_parallel_strips++;
-    }
-    se->num_parallel_triangles = 2*(num_phi+1);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->parallel_indices_buffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER,ni*sizeof(GLuint),
-                 se->parallel_indices,GL_STATIC_DRAW);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-    /* Compute the line indices. */
-    ni = 0;
-    for (j=0; j<num_phi; j+=num_grid)
-    {
-      for (i=0; i<num_theta; i++)
-      {
-        se->line_indices[ni++] = j*(num_theta+1)+i;
-        se->line_indices[ni++] = j*(num_theta+1)+i+1;
-      }
-    }
-    for (i=num_grid; i<=num_theta-num_grid; i+=num_grid)
-    {
-      for (j=num_phi; j>0; j--)
-      {
-        o = j*(num_theta+1)+i;
-        se->line_indices[ni++] = j*(num_theta+1)+i;
-        se->line_indices[ni++] = (j-1)*(num_theta+1)+i;
-      }
-    }
-    se->num_lines = ni;
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->line_indices_buffer);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER,ni*sizeof(GLuint),
-                 se->line_indices,GL_STATIC_DRAW);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-    se->buffers_initialized = True;
-  }
-
-  tau = se->tau;
-  /* Apply easing functions to the different ranges of tau. */
-  if (fabsf(tau) <= BEDNORZ_TAU4)
-  {
-    if (fabsf(tau) <= BEDNORZ_TAU1)
-    {
-      tau_min = 0.0f;
-      tau_max = BEDNORZ_TAU1;
-    }
-    else
-    if (fabsf(tau) <= BEDNORZ_TAU2)
-    {
-      tau_min = BEDNORZ_TAU1;
-      tau_max = BEDNORZ_TAU2;
-    }
-    else if (fabsf(tau) <= BEDNORZ_TAU3)
-    {
-      tau_min = BEDNORZ_TAU2;
-      tau_max = BEDNORZ_TAU3;
-    }
-    else /* fabsf(tau) <= BEDNORZ_TAU4 */
-    {
-      tau_min = BEDNORZ_TAU3;
-      tau_max = BEDNORZ_TAU4;
-    }
-    e = 1.0f/(tau_min*tau_min-2.0f*tau_min*tau_max+tau_max*tau_max);
-    a = -2.0f*e;
-    b = 3.0f*(tau_min+tau_max)*e;
-    c = -6.0f*tau_min*tau_max*e;
-    d = tau_min*tau_max*(tau_min+tau_max)*e;
-    if (tau >= 0.0f)
-      tau = ((a*tau+b)*tau+c)*tau+d;
-    else
-      tau = ((a*tau-b)*tau+c)*tau-d;
-  }
-  /* Set up the shape parameters. */
-  bsp.n = se->g;
-  bsp.kappa = bednorz_get_kappa(bsp.n);
-  bsp.omega = BEDNORZ_OMEGA;
-  bsp.t = bednorz_get_t(tau);
-  bsp.p = bednorz_get_p(tau);
-  bsp.q = bednorz_get_q(tau);
-  bsp.xi = bednorz_get_xi(tau);
-  bsp.eta = bednorz_get_eta(tau,se->eta_min);
-  bsp.alpha = bednorz_get_alpha(tau);
-  bsp.beta = bednorz_get_beta(tau,se->beta_max);
-  bsp.gamma = bednorz_get_gamma(bsp.alpha,bsp.beta);
-  bsp.lambda = bednorz_get_lambda(tau);
-  bsp.eps = bednorz_get_eps(tau,bsp.n);
-
-  /* Compute the surface points and normals. */
-  phi_range = phi_max-phi_min;
-  theta_range = theta_max-theta_min;
-  for (j=0; j<=num_phi; j++)
-  {
-    phi = phi_range*j/num_phi+phi_min;
-    for (i=0; i<=num_theta; i++)
-    {
-      o = j*(num_theta+1)+i;
-      theta = theta_range*i/num_theta+theta_min;
-      bednorz_point_normal(phi,theta,&bsp,&se->se[3*o],&se->sen[3*o]);
-    }
-  }
-
-  /* Compute the z offset. */
-  zmin = FLT_MAX;
-  zmax = -FLT_MAX;
-  for (j=0; j<=num_phi; j++)
-  {
-    for (i=0; i<=num_theta; i++)
-    {
-      o = j*(num_theta+1)+i;
-      z = se->se[3*o+2];
-      if (z < zmin)
-        zmin = z;
-      if (z > zmax)
-        zmax = z;
-    }
-  }
-  offset_z = -0.5f*(zmin+zmax);
-
-  /* Shift the surface in the z direction and compute the scale. */
-  rmax = -FLT_MAX;
-  for (j=0; j<=num_phi; j++)
-  {
-    for (i=0; i<=num_theta; i++)
-    {
-      o = j*(num_theta+1)+i;
-      se->se[3*o+2] += offset_z;
-      x = se->se[3*o];
-      y = se->se[3*o+1];
-      z = se->se[3*o+2];
-      r = x*x+y*y+z*z;
-      if (r > rmax)
-        rmax = r;
-    }
-  }
-  scale = 0.75f/sqrtf(rmax);
-
-  glBindBuffer(GL_ARRAY_BUFFER,se->vertex_pos_buffer);
-  glBufferData(GL_ARRAY_BUFFER,3*(num_phi+1)*(num_theta+1)*sizeof(GLfloat),
-               se->se,GL_STREAM_DRAW);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-  glBindBuffer(GL_ARRAY_BUFFER,se->vertex_normal_buffer);
-  glBufferData(GL_ARRAY_BUFFER,3*(num_phi+1)*(num_theta+1)*sizeof(GLfloat),
-               se->sen,GL_STREAM_DRAW);
-  glBindBuffer(GL_ARRAY_BUFFER,0);
-
-  /* Compute the rotation that rotates the surface in 3D, including the
-     trackball rotations. */
-  rotateall(se->alpha,se->beta,se->delta,r1);
-
-  gltrackball_get_quaternion(se->trackball,qu);
-  quat_to_rotmat(qu,r2);
-
-  mult_rotmat(r2,r1,mat);
-
-  glsl_Identity(p_mat);
-  if (se->projection == DISP_PERSPECTIVE)
-  {
-    glsl_Perspective(p_mat,60.0f,se->aspect,0.1f,10.0f);
-  }
-  else
-  {
-    if (se->aspect >= 1.0)
-      glsl_Orthographic(p_mat,-se->aspect,se->aspect,-1.0f,1.0f,
-                        0.1f,10.0f);
-    else
-      glsl_Orthographic(p_mat,-1.0f,1.0f,-1.0f/se->aspect,1.0f/se->aspect,
-                        0.1f,10.0f);
-  }
-  glsl_Identity(rot_mat);
-  for (i=0; i<3; i++)
-    for (j=0; j<3; j++)
-      rot_mat[GLSL__LINCOOR(i,j,4)] = mat[i][j];
-  glsl_Identity(mv_mat);
-  glsl_Translate(mv_mat,se->offset3d[0],se->offset3d[1],se->offset3d[2]);
-  glsl_Scale(mv_mat,scale,scale,scale);
-  glsl_MultMatrix(mv_mat,rot_mat);
-
-  len = sqrtf(light_position[0]*light_position[0]+
-              light_position[1]*light_position[1]+
-              light_position[2]*light_position[2]);
-  light_direction[0] = light_position[0]/len;
-  light_direction[1] = light_position[1]/len;
-  light_direction[2] = light_position[2]/len;
-  half_vector[0] = light_direction[0];
-  half_vector[1] = light_direction[1];
-  half_vector[2] = light_direction[2]+1.0f;
-  len = sqrtf(half_vector[0]*half_vector[0]+
-              half_vector[1]*half_vector[1]+
-              half_vector[2]*half_vector[2]);
-  half_vector[0] /= len;
-  half_vector[1] /= len;
-  half_vector[2] /= len;
-
-  num_passes = se->anim_state == ANIM_TURN ? 2 : 1;
-
-  for (pass=0; pass<num_passes; pass++)
-  {
-    glUseProgram(se->poly_shader_program);
-
-    glClearColor(0.0f,0.0f,0.0f,1.0f);
-    glClearDepth(1.0f);
-    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-
-    glUniformMatrix4fv(se->poly_mv_index,1,GL_FALSE,mv_mat);
-    glUniformMatrix4fv(se->poly_proj_index,1,GL_FALSE,p_mat);
-
-    glUniform4fv(se->poly_front_ambient_index,1,mat_diff_white);
-    glUniform4fv(se->poly_front_diffuse_index,1,mat_diff_white);
-    glUniform4fv(se->poly_back_ambient_index,1,mat_diff_white);
-    glUniform4fv(se->poly_back_diffuse_index,1,mat_diff_white);
-    glVertexAttrib4f(se->poly_colorf_index,1.0f,1.0f,1.0f,1.0f);
-    glVertexAttrib4f(se->poly_colorb_index,1.0f,1.0f,1.0f,1.0f);
-
-    if (se->display_mode[pass] == DISP_SURFACE)
-    {
-      glDisable(GL_CULL_FACE);
-      glEnable(GL_DEPTH_TEST);
-      glDepthFunc(GL_LESS);
-      glDepthMask(GL_TRUE);
-      glDisable(GL_BLEND);
-      glUniform4fv(se->poly_glbl_ambient_index,1,light_model_ambient);
-      glUniform4fv(se->poly_lt_ambient_index,1,light_ambient);
-      glUniform4fv(se->poly_lt_diffuse_index,1,light_diffuse);
-      glUniform4fv(se->poly_lt_specular_index,1,light_specular);
-      glUniform3fv(se->poly_lt_direction_index,1,light_direction);
-      glUniform3fv(se->poly_lt_halfvect_index,1,half_vector);
-      glUniform4fv(se->poly_specular_index,1,mat_specular);
-      glUniform1f(se->poly_shininess_index,50.0f);
-    }
-    else /* se->display_mode[pass] == DISP_TRANSPARENT */
-    {
-      glDisable(GL_CULL_FACE);
-      glDisable(GL_DEPTH_TEST);
-      glDepthMask(GL_FALSE);
-      glEnable(GL_BLEND);
-      glBlendFunc(GL_SRC_ALPHA,GL_ONE);
-      glUniform4fv(se->poly_glbl_ambient_index,1,light_model_ambient);
-      glUniform4fv(se->poly_lt_ambient_index,1,light_ambient);
-      glUniform4fv(se->poly_lt_diffuse_index,1,light_diffuse);
-      glUniform4fv(se->poly_lt_specular_index,1,light_specular);
-      glUniform3fv(se->poly_lt_direction_index,1,light_direction);
-      glUniform3fv(se->poly_lt_halfvect_index,1,half_vector);
-      glUniform4fv(se->poly_specular_index,1,mat_specular);
-      glUniform1f(se->poly_shininess_index,50.0f);
-    }
-
-    if (se->colors[pass] == COLORS_TWOSIDED)
-    {
-      if (se->display_mode[pass] == DISP_TRANSPARENT)
-      {
-        glUniform4fv(se->poly_front_ambient_index,1,mat_diff_trans_front);
-        glUniform4fv(se->poly_front_diffuse_index,1,mat_diff_trans_front);
-        glUniform4fv(se->poly_back_ambient_index,1,mat_diff_trans_back);
-        glUniform4fv(se->poly_back_diffuse_index,1,mat_diff_trans_back);
-      }
-      else
-      {
-        glUniform4fv(se->poly_front_ambient_index,1,mat_diff_front);
-        glUniform4fv(se->poly_front_diffuse_index,1,mat_diff_front);
-        glUniform4fv(se->poly_back_ambient_index,1,mat_diff_back);
-        glUniform4fv(se->poly_back_diffuse_index,1,mat_diff_back);
-      }
-    }
-
-    glEnable(GL_POLYGON_OFFSET_FILL);
-    glPolygonOffset(1.0f,1.0f);
-
-    glEnableVertexAttribArray(se->poly_pos_index);
-    glBindBuffer(GL_ARRAY_BUFFER,se->vertex_pos_buffer);
-    glVertexAttribPointer(se->poly_pos_index,3,GL_FLOAT,GL_FALSE,0,0);
-
-    glEnableVertexAttribArray(se->poly_normal_index);
-    glBindBuffer(GL_ARRAY_BUFFER,se->vertex_normal_buffer);
-    glVertexAttribPointer(se->poly_normal_index,3,GL_FLOAT,GL_FALSE,0,0);
-
-    if (se->colors[pass] != COLORS_TWOSIDED)
-    {
-      glEnableVertexAttribArray(se->poly_colorf_index);
-      glBindBuffer(GL_ARRAY_BUFFER,se->vertex_colorf_buffer[pass]);
-      glVertexAttribPointer(se->poly_colorf_index,4,GL_FLOAT,GL_FALSE,0,0);
-
-      glEnableVertexAttribArray(se->poly_colorb_index);
-      glBindBuffer(GL_ARRAY_BUFFER,se->vertex_colorb_buffer[pass]);
-      glVertexAttribPointer(se->poly_colorb_index,4,GL_FLOAT,GL_FALSE,0,0);
-    }
-#ifdef VERTEXATTRIBARRAY_WORKAROUND
-    else /* se->colors[pass] == COLORS_TWOSIDED */
-    {
-      glEnableVertexAttribArray(se->poly_colorf_index);
-      glBindBuffer(GL_ARRAY_BUFFER,se->vertex_colorf_buffer[pass]);
-      glVertexAttribPointer(se->poly_colorf_index,4,GL_FLOAT,GL_FALSE,0,0);
-
-      glEnableVertexAttribArray(se->poly_colorb_index);
-      glBindBuffer(GL_ARRAY_BUFFER,se->vertex_colorb_buffer[pass]);
-      glVertexAttribPointer(se->poly_colorb_index,4,GL_FLOAT,GL_FALSE,0,0);
-    }
-#endif /* VERTEXATTRIBARRAY_WORKAROUND */
-
-    if (se->appearance[pass] == APPEARANCE_SOLID)
-    {
-      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->solid_indices_buffer);
-      for (i=0; i<se->num_solid_strips; i++)
-      {
-        index_offset = se->num_solid_triangles*i*sizeof(GLuint);
-        glDrawElements(GL_TRIANGLE_STRIP,se->num_solid_triangles,
-                       GL_UNSIGNED_INT,(const GLvoid *)index_offset);
-      }
-      polys += 2*num_phi*(num_theta+1);
-    }
-    else if (se->appearance[pass] == APPEARANCE_PARALLEL_BANDS)
-    {
-      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->parallel_indices_buffer);
-      for (i=0; i<se->num_parallel_strips; i++)
-      {
-        index_offset = se->num_parallel_triangles*i*sizeof(GLuint);
-        glDrawElements(GL_TRIANGLE_STRIP,se->num_parallel_triangles,
-                       GL_UNSIGNED_INT,(const GLvoid *)index_offset);
-      }
-      polys += num_theta*(num_phi+1);
-    }
-    else /* se->appearance[pass] == APPEARANCE_MERIDIAN_BANDS */
-    {
-      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->meridian_indices_buffer);
-      for (i=0; i<se->num_meridian_strips; i++)
-      {
-        index_offset = se->num_meridian_triangles*i*sizeof(GLuint);
-        glDrawElements(GL_TRIANGLE_STRIP,se->num_meridian_triangles,
-                       GL_UNSIGNED_INT,(const GLvoid *)index_offset);
-      }
-      polys += num_phi*(num_theta+1);
-    }
-
-    glDisableVertexAttribArray(se->poly_pos_index);
-    glDisableVertexAttribArray(se->poly_normal_index);
-    if (se->colors[pass] != COLORS_TWOSIDED)
-    {
-      glDisableVertexAttribArray(se->poly_colorf_index);
-      glDisableVertexAttribArray(se->poly_colorb_index);
-    }
-#ifdef VERTEXATTRIBARRAY_WORKAROUND
-    else /* se->colors[pass] != COLORS_TWOSIDED */
-    {
-      glDisableVertexAttribArray(se->poly_colorf_index);
-      glDisableVertexAttribArray(se->poly_colorb_index);
-    }
-#endif /* VERTEXATTRIBARRAY_WORKAROUND */
-    glBindBuffer(GL_ARRAY_BUFFER,0);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-    glDisable(GL_POLYGON_OFFSET_FILL);
-    glPolygonOffset(0.0f,0.0f);
-
-    glUseProgram(0);
-
-    if (se->graticule[pass])
-    {
-      glUseProgram(se->line_shader_program);
-
-      glUniformMatrix4fv(se->line_mv_index,1,GL_FALSE,mv_mat);
-      glUniformMatrix4fv(se->line_proj_index,1,GL_FALSE,p_mat);
-      glUniform4f(se->line_color_index,1.0f,1.0f,1.0f,1.0f);
-
-      glLineWidth(2.0f);
-
-      glEnableVertexAttribArray(se->line_pos_index);
-      glBindBuffer(GL_ARRAY_BUFFER,se->vertex_pos_buffer);
-      glVertexAttribPointer(se->line_pos_index,3,GL_FLOAT,GL_FALSE,0,0);
-
-      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,se->line_indices_buffer);
-
-      index_offset = 0;
-      glDrawElements(GL_LINES,se->num_lines,GL_UNSIGNED_INT,
-                     (const void *)index_offset);
-
-      glDisableVertexAttribArray(se->line_pos_index);
-      glBindBuffer(GL_ARRAY_BUFFER,0);
-      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-      glUseProgram(0);
-    }
- 
-    if (num_passes == 2)
-    {
-      /* Copy the rendered image to a texture. */
-      glGetIntegerv(GL_DRAW_BUFFER0,&draw_buf);
-      glGetIntegerv(GL_READ_BUFFER,&read_buf);
-      glReadBuffer(draw_buf);
-      glBindTexture(GL_TEXTURE_2D,se->color_textures[pass]);
-      glCopyTexSubImage2D(GL_TEXTURE_2D,0,0,0,0,0,se->WindW,se->WindH);
-      glReadBuffer(read_buf);
-    }
-  }
-
-  if (num_passes == 2)
-  {
-    t = (float)se->turn_step/(float)se->num_turn;
-    /* Apply an easing function to t. */
-    t = (3.0-2.0*t)*t*t;
-
-    glUseProgram(se->blend_shader_program);
-
-    glClearColor(0.0f,0.0f,0.0f,1.0f);
-    glClearDepth(1.0f);
-    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-
-    glDisable(GL_DEPTH_TEST);
-    glDepthMask(GL_FALSE);
-    glDisable(GL_BLEND);
-
-    glUniform1f(se->blend_t_index,t);
-
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D,se->color_textures[0]);
-    glUniform1i(se->blend_sampler0_index,0);
-
-    glActiveTexture(GL_TEXTURE1);
-    glBindTexture(GL_TEXTURE_2D,se->color_textures[1]);
-    glUniform1i(se->blend_sampler1_index,1);
-
-    glEnableVertexAttribArray(se->blend_vertex_p_index);
-    glVertexAttribPointer(se->blend_vertex_p_index,2,GL_FLOAT,GL_FALSE,
-                          2*sizeof(GLfloat),blend_p);
-
-    glEnableVertexAttribArray(se->blend_vertex_t_index);
-    glVertexAttribPointer(se->blend_vertex_t_index,2,GL_FLOAT,GL_FALSE,
-                          2*sizeof(GLfloat),blend_t);
-
-    glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_INT,blend_indices);
-
-    glActiveTexture(GL_TEXTURE0);
-
-    glUseProgram(0);
-  }
-
-  return polys;
-}
-
-
-static void init_glsl(ModeInfo *mi)
-{
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-  GLint gl_major, gl_minor, glsl_major, glsl_minor;
-  GLboolean gl_gles3;
-  int i, wt, ht;
-  const GLchar *poly_vertex_shader_source[3];
-  const GLchar *poly_fragment_shader_source[4];
-  const GLchar *line_vertex_shader_source[3];
-  const GLchar *line_fragment_shader_source[4];
-  const GLchar *blend_vertex_shader_source[3];
-  const GLchar *blend_fragment_shader_source[4];
-
-  se->solid_indices = calloc(2*NUMPH*(NUMTH+1),sizeof(float));
-  se->parallel_indices = calloc(NUMPH*(NUMTH+1),sizeof(float));
-  se->meridian_indices = calloc((NUMPH+1)*NUMTH,sizeof(float));
-  se->line_indices = calloc(4*NUMPH*NUMTH/NUMGRID,sizeof(float));
-
-  /* Determine whether to use shaders to render the sphere eversion. */
-  se->use_shaders = False;
-  se->buffers_initialized = False;
-  se->poly_shader_program = 0;
-  se->line_shader_program = 0;
-  se->blend_shader_program = 0;
-  se->max_tex_size = -1;
-    
-  if (!glsl_GetGlAndGlslVersions(&gl_major,&gl_minor,&glsl_major,&glsl_minor,
-                                 &gl_gles3))
-    return;
-  if (!gl_gles3)
-  {
-    if (gl_major < 3 ||
-        (glsl_major < 1 || (glsl_major == 1 && glsl_minor < 30)))
-    {
-      if ((gl_major < 2 || (gl_major == 2 && gl_minor < 1)) ||
-          (glsl_major < 1 || (glsl_major == 1 && glsl_minor < 20)))
-        return;
-      /* We have at least OpenGL 2.1 and at least GLSL 1.20. */
-      poly_vertex_shader_source[0] = shader_version_2_1;
-      poly_vertex_shader_source[1] = poly_vertex_shader_attribs_2_1;
-      poly_vertex_shader_source[2] = poly_vertex_shader_main;
-      poly_fragment_shader_source[0] = shader_version_2_1;
-      poly_fragment_shader_source[1] = poly_fragment_shader_attribs_2_1;
-      poly_fragment_shader_source[2] = poly_fragment_shader_main;
-      poly_fragment_shader_source[3] = poly_fragment_shader_out_2_1;
-
-      line_vertex_shader_source[0] = shader_version_2_1;
-      line_vertex_shader_source[1] = line_vertex_shader_attribs_2_1;
-      line_vertex_shader_source[2] = line_vertex_shader_main;
-      line_fragment_shader_source[0] = shader_version_2_1;
-      line_fragment_shader_source[1] = line_fragment_shader_attribs_2_1;
-      line_fragment_shader_source[2] = line_fragment_shader_main;
-      line_fragment_shader_source[3] = line_fragment_shader_out_2_1;
-
-      blend_vertex_shader_source[0] = shader_version_2_1;
-      blend_vertex_shader_source[1] = blend_vertex_shader_attribs_2_1;
-      blend_vertex_shader_source[2] = blend_vertex_shader_main;
-      blend_fragment_shader_source[0] = shader_version_2_1;
-      blend_fragment_shader_source[1] = blend_fragment_shader_attribs_2_1;
-      blend_fragment_shader_source[2] = blend_fragment_shader_main;
-      blend_fragment_shader_source[3] = blend_fragment_shader_out_2_1;
-    }
-    else
-    {
-      /* We have at least OpenGL 3.0 and at least GLSL 1.30. */
-      poly_vertex_shader_source[0] = shader_version_3_0;
-      poly_vertex_shader_source[1] = poly_vertex_shader_attribs_3_0;
-      poly_vertex_shader_source[2] = poly_vertex_shader_main;
-      poly_fragment_shader_source[0] = shader_version_3_0;
-      poly_fragment_shader_source[1] = poly_fragment_shader_attribs_3_0;
-      poly_fragment_shader_source[2] = poly_fragment_shader_main;
-      poly_fragment_shader_source[3] = poly_fragment_shader_out_3_0;
-
-      line_vertex_shader_source[0] = shader_version_3_0;
-      line_vertex_shader_source[1] = line_vertex_shader_attribs_3_0;
-      line_vertex_shader_source[2] = line_vertex_shader_main;
-      line_fragment_shader_source[0] = shader_version_3_0;
-      line_fragment_shader_source[1] = line_fragment_shader_attribs_3_0;
-      line_fragment_shader_source[2] = line_fragment_shader_main;
-      line_fragment_shader_source[3] = line_fragment_shader_out_3_0;
-
-      blend_vertex_shader_source[0] = shader_version_3_0;
-      blend_vertex_shader_source[1] = blend_vertex_shader_attribs_3_0;
-      blend_vertex_shader_source[2] = blend_vertex_shader_main;
-      blend_fragment_shader_source[0] = shader_version_3_0;
-      blend_fragment_shader_source[1] = blend_fragment_shader_attribs_3_0;
-      blend_fragment_shader_source[2] = blend_fragment_shader_main;
-      blend_fragment_shader_source[3] = blend_fragment_shader_out_3_0;
-    }
-  }
-  else /* gl_gles3 */
-  {
-    if (gl_major < 3 || glsl_major < 3)
-      return;
-    /* We have at least OpenGL ES 3.0 and at least GLSL ES 3.0. */
-    poly_vertex_shader_source[0] = shader_version_3_0_es;
-    poly_vertex_shader_source[1] = poly_vertex_shader_attribs_3_0;
-    poly_vertex_shader_source[2] = poly_vertex_shader_main;
-    poly_fragment_shader_source[0] = shader_version_3_0_es;
-    poly_fragment_shader_source[1] = poly_fragment_shader_attribs_3_0;
-    poly_fragment_shader_source[2] = poly_fragment_shader_main;
-    poly_fragment_shader_source[3] = poly_fragment_shader_out_3_0;
-
-    line_vertex_shader_source[0] = shader_version_3_0_es;
-    line_vertex_shader_source[1] = line_vertex_shader_attribs_3_0;
-    line_vertex_shader_source[2] = line_vertex_shader_main;
-    line_fragment_shader_source[0] = shader_version_3_0_es;
-    line_fragment_shader_source[1] = line_fragment_shader_attribs_3_0;
-    line_fragment_shader_source[2] = line_fragment_shader_main;
-    line_fragment_shader_source[3] = line_fragment_shader_out_3_0;
-
-    blend_vertex_shader_source[0] = shader_version_3_0_es;
-    blend_vertex_shader_source[1] = blend_vertex_shader_attribs_3_0;
-    blend_vertex_shader_source[2] = blend_vertex_shader_main;
-    blend_fragment_shader_source[0] = shader_version_3_0_es;
-    blend_fragment_shader_source[1] = blend_fragment_shader_attribs_3_0;
-    blend_fragment_shader_source[2] = blend_fragment_shader_main;
-    blend_fragment_shader_source[3] = blend_fragment_shader_out_3_0;
-  }
-
-  if (!glsl_CompileAndLinkShaders(3,poly_vertex_shader_source,
-                                  4,poly_fragment_shader_source,
-                                  &se->poly_shader_program))
-    return;
-  se->poly_pos_index = glGetAttribLocation(se->poly_shader_program,
-                                           "VertexPosition");
-  se->poly_normal_index = glGetAttribLocation(se->poly_shader_program,
-                                              "VertexNormal");
-  se->poly_colorf_index = glGetAttribLocation(se->poly_shader_program,
-                                              "VertexColorF");
-  se->poly_colorb_index = glGetAttribLocation(se->poly_shader_program,
-                                              "VertexColorB");
-  se->poly_mv_index = glGetUniformLocation(se->poly_shader_program,
-                                           "MatModelView");
-  se->poly_proj_index = glGetUniformLocation(se->poly_shader_program,
-                                             "MatProj");
-  se->poly_glbl_ambient_index = glGetUniformLocation(se->poly_shader_program,
-                                                     "LtGlblAmbient");
-  se->poly_lt_ambient_index = glGetUniformLocation(se->poly_shader_program,
-                                                   "LtAmbient");
-  se->poly_lt_diffuse_index = glGetUniformLocation(se->poly_shader_program,
-                                                   "LtDiffuse");
-  se->poly_lt_specular_index = glGetUniformLocation(se->poly_shader_program,
-                                                    "LtSpecular");
-  se->poly_lt_direction_index = glGetUniformLocation(se->poly_shader_program,
-                                                     "LtDirection");
-  se->poly_lt_halfvect_index = glGetUniformLocation(se->poly_shader_program,
-                                                    "LtHalfVector");
-  se->poly_front_ambient_index = glGetUniformLocation(se->poly_shader_program,
-                                                      "MatFrontAmbient");
-  se->poly_back_ambient_index = glGetUniformLocation(se->poly_shader_program,
-                                                     "MatBackAmbient");
-  se->poly_front_diffuse_index = glGetUniformLocation(se->poly_shader_program,
-                                                      "MatFrontDiffuse");
-  se->poly_back_diffuse_index = glGetUniformLocation(se->poly_shader_program,
-                                                     "MatBackDiffuse");
-  se->poly_specular_index = glGetUniformLocation(se->poly_shader_program,
-                                                 "MatSpecular");
-  se->poly_shininess_index = glGetUniformLocation(se->poly_shader_program,
-                                                  "MatShininess");
-  if (se->poly_pos_index == -1 ||
-      se->poly_normal_index == -1 ||
-      se->poly_colorf_index == -1 ||
-      se->poly_colorb_index == -1 ||
-      se->poly_mv_index == -1 ||
-      se->poly_proj_index == -1 ||
-      se->poly_glbl_ambient_index == -1 ||
-      se->poly_lt_ambient_index == -1 ||
-      se->poly_lt_diffuse_index == -1 ||
-      se->poly_lt_specular_index == -1 ||
-      se->poly_lt_direction_index == -1 ||
-      se->poly_lt_halfvect_index == -1 ||
-      se->poly_front_ambient_index == -1 ||
-      se->poly_back_ambient_index == -1 ||
-      se->poly_front_diffuse_index == -1 ||
-      se->poly_back_diffuse_index == -1 ||
-      se->poly_specular_index == -1 ||
-      se->poly_shininess_index == -1)
-  {
-    glDeleteProgram(se->poly_shader_program);
-    return;
-  }
-
-  if (!glsl_CompileAndLinkShaders(3,line_vertex_shader_source,
-                                  4,line_fragment_shader_source,
-                                  &se->line_shader_program))
-  {
-    glDeleteProgram(se->poly_shader_program);
-    return;
-  }
-  se->line_pos_index = glGetAttribLocation(se->line_shader_program,
-                                           "VertexPosition");
-  se->line_color_index = glGetUniformLocation(se->line_shader_program,
-                                              "LineColor");
-  se->line_mv_index = glGetUniformLocation(se->line_shader_program,
-                                           "MatModelView");
-  se->line_proj_index = glGetUniformLocation(se->line_shader_program,
-                                             "MatProj");
-  if (se->line_pos_index == -1 ||
-      se->line_color_index == -1 ||
-      se->line_mv_index == -1 ||
-      se->line_proj_index == -1)
-  {
-    glDeleteProgram(se->poly_shader_program);
-    glDeleteProgram(se->line_shader_program);
-    return;
-  }
-
-  if (!glsl_CompileAndLinkShaders(3,blend_vertex_shader_source,
-                                  4,blend_fragment_shader_source,
-                                  &se->blend_shader_program))
-  {
-    glDeleteProgram(se->poly_shader_program);
-    glDeleteProgram(se->line_shader_program);
-    return;
-  }
-  se->blend_vertex_p_index = glGetAttribLocation(se->blend_shader_program,
-                                                 "VertexP");
-  se->blend_vertex_t_index = glGetAttribLocation(se->blend_shader_program,
-                                                 "VertexT");
-  se->blend_t_index = glGetUniformLocation(se->blend_shader_program,
-                                           "T");
-  se->blend_sampler0_index = glGetUniformLocation(se->blend_shader_program,
-                                                  "TextureSampler0");
-  se->blend_sampler1_index = glGetUniformLocation(se->blend_shader_program,
-                                                  "TextureSampler1");
-  if (se->blend_vertex_p_index == -1 ||
-      se->blend_vertex_t_index == -1 ||
-      se->blend_t_index == -1 ||
-      se->blend_sampler0_index == -1 ||
-      se->blend_sampler1_index == -1)
-  {
-    glDeleteProgram(se->poly_shader_program);
-    glDeleteProgram(se->line_shader_program);
-    glDeleteProgram(se->blend_shader_program);
-    return;
-  }
-
-  glGetIntegerv(GL_MAX_TEXTURE_SIZE,&se->max_tex_size);
-  if (se->WindW <= se->max_tex_size || se->WindH <= se->max_tex_size)
-  {
-    wt = se->WindW;
-    ht = se->WindH;
-  }
-  else
-  {
-    wt = MIN(se->max_tex_size,se->WindW);
-    ht = MIN(se->max_tex_size,se->WindH);
-  }
-
-  glGenTextures(2,se->color_textures);
-  for (i=0; i<2; i++)
-  {
-    glBindTexture(GL_TEXTURE_2D,se->color_textures[i]);
-    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA8,wt,ht,0,GL_RGBA,GL_UNSIGNED_BYTE,
-                 NULL);
-    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
-  }
-
-  glGenBuffers(1,&se->vertex_pos_buffer);
-  glGenBuffers(1,&se->vertex_normal_buffer);
-  glGenBuffers(2,se->vertex_colorf_buffer);
-  glGenBuffers(2,se->vertex_colorb_buffer);
-  glGenBuffers(1,&se->solid_indices_buffer);
-  glGenBuffers(1,&se->parallel_indices_buffer);
-  glGenBuffers(1,&se->meridian_indices_buffer);
-  glGenBuffers(1,&se->line_indices_buffer);
-
-  se->use_shaders = True;
-}
-
-#endif /* HAVE_GLSL */
-
-
-static void init(ModeInfo *mi)
-{
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-
-  if (deform_speed == 0.0f)
-    deform_speed = 10.0f;
-
-  se->alpha = frand(120.0)-60.0;
-  se->beta = frand(120.0)-60.0;
-  se->delta = frand(360.0);
-
-  se->eta_min = BEDNORZ_ETA_MIN;
-  se->beta_max = BEDNORZ_BETA_MAX;
-
-  se->anim_state = ANIM_DEFORM;
-  se->tau = BEDNORZ_TAU_MAX;
-  se->defdir = -1;
-  se->turn_step = 0;
-  se->num_turn = 0;
-
-  se->offset3d[0] = 0.0f;
-  se->offset3d[1] = 0.0f;
-  se->offset3d[2] = -1.8f;
-
-  se->se = calloc(3*(NUMPH+1)*(NUMTH+1),sizeof(float));
-  se->sen = calloc(3*(NUMPH+1)*(NUMTH+1),sizeof(float));
-  se->colf[0] = calloc(4*(NUMPH+1)*(NUMTH+1),sizeof(float));
-  se->colf[1] = calloc(4*(NUMPH+1)*(NUMTH+1),sizeof(float));
-  se->colb[0] = calloc(4*(NUMPH+1)*(NUMTH+1),sizeof(float));
-  se->colb[1] = calloc(4*(NUMPH+1)*(NUMTH+1),sizeof(float));
-
-#ifdef HAVE_GLSL
-  init_glsl(mi);
-#endif /* HAVE_GLSL */
-
-  setup_surface_colors(mi,-M_PI,M_PI,-M_PI/2.0,M_PI/2.0,NUMPH,NUMTH);
-}
-
-
-/* Redisplay the deformed surface. */
-static void display_sphereeversion(ModeInfo *mi)
-{
-  float alpha, beta, delta, dot, a, t, q[4];
-  float *colt;
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-#ifdef HAVE_GLSL
-  GLuint vertex_colort_buffer;
-#endif /* HAVE_GLSL */
-
-  if (!se->button_pressed)
-  {
-    if (se->anim_state == ANIM_DEFORM)
-    {
-      se->tau += se->defdir*deform_speed*0.001;
-      if (se->tau < BEDNORZ_TAU_MIN)
-      {
-        se->tau = BEDNORZ_TAU_MIN;
-        se->defdir = -se->defdir;
-        se->anim_state = ANIM_TURN;
-      }
-      if (se->tau > BEDNORZ_TAU_MAX)
-      {
-        se->tau = BEDNORZ_TAU_MAX;
-        se->defdir = -se->defdir;
-        se->anim_state = ANIM_TURN;
-      }
-      if (se->anim_state == ANIM_TURN)
-      {
-        /* Convert the current rotation angles to a quaternion. */
-        angles_to_quat(se->alpha,se->beta,se->delta,se->qs);
-        /* Determine random target rotation angles and  convert them to the
-           target quaternion. */
-        alpha = frand(120.0)-60.0;
-        beta = frand(120.0)-60.0;
-        delta = frand(360.0);
-        angles_to_quat(alpha,beta,delta,se->qe);
-        /* Compute the angle between qs and qe. */
-        dot = (se->qs[0]*se->qe[0]+se->qs[1]*se->qe[1]+
-               se->qs[2]*se->qe[2]+se->qs[3]*se->qe[3]);
-        if (dot < 0.0f)
-        {
-          se->qe[0] = -se->qe[0];
-          se->qe[1] = -se->qe[1];
-          se->qe[2] = -se->qe[2];
-          se->qe[3] = -se->qe[3];
-          dot = -dot;
-        }
-        a = 180.0/M_PI*acos(dot);
-        se->num_turn = ceil(a/TURN_STEP);
-
-        /* Change the parameters randomly after one full eversion when a
-           turn to the new orientation starts. */
-        /* Copy the current display modes to the values of the second pass. */
-        se->display_mode[1] = se->display_mode[0];
-        se->appearance[1] = se->appearance[0];
-        se->colors[1] = se->colors[0];
-        se->graticule[1] = se->graticule[0];
-        /* Swap the front and back color buffers. */
-        colt = se->colf[1];
-        se->colf[1] = se->colf[0];
-        se->colf[0] = colt;
-        colt = se->colb[1];
-        se->colb[1] = se->colb[0];
-        se->colb[0] = colt;
-#ifdef HAVE_GLSL
-        /* Swap the OpenGL front and back color buffers. */
-        if (se->use_shaders)
-        {
-          vertex_colort_buffer = se->vertex_colorf_buffer[1];
-          se->vertex_colorf_buffer[1] = se->vertex_colorf_buffer[0];
-          se->vertex_colorf_buffer[0] = vertex_colort_buffer;
-          vertex_colort_buffer = se->vertex_colorb_buffer[1];
-          se->vertex_colorb_buffer[1] = se->vertex_colorb_buffer[0];
-          se->vertex_colorb_buffer[0] = vertex_colort_buffer;
-        }
-#endif /* HAVE_GLSL */
-        /* Randomly select new display modes for the main pass. */
-        if (se->random_display_mode)
-          se->display_mode[0] = random() % NUM_DISPLAY_MODES;
-        if (se->random_appearance)
-          se->appearance[0] = random() % NUM_APPEARANCES;
-        if (se->random_colors)
-          se->colors[0] = random() % NUM_COLORS;
-        if (se->random_graticule)
-          se->graticule[0] = random() & 1;
-        if (se->random_g)
-          se->g = random() % 4 + 2;
-        setup_surface_colors(mi,-M_PI,M_PI,-M_PI/2.0,M_PI/2.0,NUMPH,NUMTH);
-      }
-    }
-    else /* se->anim_state == ANIM_TURN */
-    {
-      t = (float)se->turn_step/(float)se->num_turn;
-      /* Apply an easing function to t. */
-      t = (3.0-2.0*t)*t*t;
-      quat_slerp(t,se->qs,se->qe,q);
-      quat_to_angles(q,&se->alpha,&se->beta,&se->delta);
-      se->turn_step++;
-      if (se->turn_step > se->num_turn)
-      {
-        se->turn_step = 0;
-        se->anim_state = ANIM_DEFORM;
-      }
-    }
-
-    if (se->anim_state == ANIM_DEFORM)
-    {
-      se->alpha += speed_x*se->speed_scale;
-      if (se->alpha >= 360.0f)
-        se->alpha -= 360.0f;
-      se->beta += speed_y*se->speed_scale;
-      if (se->beta >= 360.0f)
-        se->beta -= 360.0f;
-      se->delta += speed_z*se->speed_scale;
-      if (se->delta >= 360.0f)
-        se->delta -= 360.0f;
-    }
-  }
-
-#ifdef HAVE_GLSL
-  if (se->use_shaders)
-    mi->polygon_count = bednorz_sphere_eversion_pf(mi,-M_PI,M_PI,-M_PI/2.0,
-                                                   M_PI/2.0,NUMPH,NUMTH,
-                                                   NUMBDIST,NUMBDIR,
-                                                   NUMGRID);
-  else
-#endif /* HAVE_GLSL */
-    mi->polygon_count = bednorz_sphere_eversion_ff(mi,-M_PI,M_PI,-M_PI/2.0,
-                                                   M_PI/2.0,NUMPH,NUMTH,
-                                                   NUMBDIST,NUMBDIR,
-                                                   NUMGRID);
-}
-
-
-ENTRYPOINT void reshape_sphereeversion(ModeInfo *mi, int width, int height)
-{
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-  int y = 0;
-#ifdef HAVE_GLSL
-  int i, wt, ht;
-#endif /* HAVE_GLSL */
-
-  if (width > height * 5) {   /* tiny window: show middle */
-    height = width;
-    y = -height/2;
-  }
-
-  se->WindW = (GLint)width;
-  se->WindH = (GLint)height;
-  glViewport(0,y,width,height);
-  se->aspect = (GLfloat)width/(GLfloat)height;
-#ifdef HAVE_GLSL
-  if (se->use_shaders)
-  {
-    if (se->WindW <= se->max_tex_size || se->WindH <= se->max_tex_size)
-    {
-      wt = se->WindW;
-      ht = se->WindH;
-    }
-    else
-    {
-      wt = MIN(se->max_tex_size,se->WindW);
-      ht = MIN(se->max_tex_size,se->WindH);
-    }
-    for (i=0; i<2; i++)
-    {
-      glBindTexture(GL_TEXTURE_2D,se->color_textures[i]);
-      glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA8,wt,ht,0,GL_RGBA,GL_UNSIGNED_BYTE,
-                   NULL);
-    }
-  }
-#endif /* HAVE_GLSL */
-}
-
-
-ENTRYPOINT Bool sphereeversion_handle_event(ModeInfo *mi, XEvent *event)
-{
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-
-  if (event->xany.type == ButtonPress && event->xbutton.button == Button1)
-  {
-    se->button_pressed = True;
-    gltrackball_start(se->trackball, event->xbutton.x, event->xbutton.y,
-                      MI_WIDTH(mi), MI_HEIGHT(mi));
-    return True;
-  }
-  else if (event->xany.type == ButtonRelease &&
-           event->xbutton.button == Button1)
-  {
-    se->button_pressed = False;
-    return True;
-  }
-  else if (event->xany.type == MotionNotify && se->button_pressed)
-  {
-    gltrackball_track(se->trackball, event->xmotion.x, event->xmotion.y,
-                      MI_WIDTH(mi), MI_HEIGHT(mi));
-    return True;
-  }
-
-  return False;
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *-----------------------------------------------------------------------------
- *    Xlock hooks.
- *-----------------------------------------------------------------------------
- *-----------------------------------------------------------------------------
- */
-
-/*
- *-----------------------------------------------------------------------------
- *    Initialize sphereeversion.  Called each time the window changes.
- *-----------------------------------------------------------------------------
- */
-
-ENTRYPOINT void init_sphereeversion(ModeInfo *mi)
-{
-  sphereeversionstruct *se;
-
-  MI_INIT(mi,sphereeversion);
-  se = &sphereeversion[MI_SCREEN(mi)];
-
-  se->trackball = gltrackball_init(True);
-  se->button_pressed = False;
-
-  /* Set the surface order. */
-  if (!strcasecmp(surface_order,"2"))
-  {
-    se->g = 2;
-    se->random_g = False;
-  }
-  else if (!strcasecmp(surface_order,"3"))
-  {
-    se->g = 3;
-    se->random_g = False;
-  }
-  else if (!strcasecmp(surface_order,"4"))
-  {
-    se->g = 4;
-    se->random_g = False;
-  }
-  else if (!strcasecmp(surface_order,"5"))
-  {
-    se->g = 5;
-    se->random_g = False;
-  }
-  else
-  {
-    se->g = random() % 4 + 2;
-    se->random_g = True;
-  }
-
-  /* Set the display mode. */
-  if (!strcasecmp(mode,"surface"))
-  {
-    se->display_mode[0] = DISP_SURFACE;
-    se->random_display_mode = False;
-  }
-  else if (!strcasecmp(mode,"transparent"))
-  {
-    se->display_mode[0] = DISP_TRANSPARENT;
-    se->random_display_mode = False;
-  }
-  else
-  {
-    se->display_mode[0] = random() % NUM_DISPLAY_MODES;
-    se->random_display_mode = True;
-  }
-
-  /* Set the appearance. */
-  if (!strcasecmp(appear,"solid"))
-  {
-    se->appearance[0] = APPEARANCE_SOLID;
-    se->random_appearance = False;
-  }
-  else if (!strcasecmp(appear,"parallel-bands"))
-  {
-    se->appearance[0] = APPEARANCE_PARALLEL_BANDS;
-    se->random_appearance = False;
-  }
-  else if (!strcasecmp(appear,"meridian-bands"))
-  {
-    se->appearance[0] = APPEARANCE_MERIDIAN_BANDS;
-    se->random_appearance = False;
-  }
-  else
-  {
-    se->appearance[0] = random() % NUM_APPEARANCES;
-    se->random_appearance = True;
-  }
-
-  /* Set the color mode. */
-  if (!strcasecmp(color_mode,"two-sided"))
-  {
-    se->colors[0] = COLORS_TWOSIDED;
-    se->random_colors = False;
-  }
-  else if (!strcasecmp(color_mode,"parallel"))
-  {
-    se->colors[0] = COLORS_PARALLEL;
-    se->random_colors = False;
-  }
-  else if (!strcasecmp(color_mode,"meridian"))
-  {
-    se->colors[0] = COLORS_MERIDIAN;
-    se->random_colors = False;
-  }
-  else
-  {
-    se->colors[0] = random() % NUM_COLORS;
-    se->random_colors = True;
-  }
-
-  /* Set the graticule mode. */
-  if (!strcasecmp(graticule,"on"))
-  {
-    se->graticule[0] = True;
-    se->random_graticule = False;
-  }
-  else if (!strcasecmp(graticule,"off"))
-  {
-    se->graticule[0] = False;
-    se->random_graticule = False;
-  }
-  else
-  {
-    se->graticule[0] = random() & 1;
-    se->random_graticule = True;
-  }
-
-  /* Set the 3d projection mode. */
-  if (!strcasecmp(proj,"perspective"))
-  {
-    se->projection = DISP_PERSPECTIVE;
-  }
-  else if (!strcasecmp(proj,"orthographic"))
-  {
-    se->projection = DISP_ORTHOGRAPHIC;
-  }
-  else
-  {
-    se->projection = random() % NUM_DISP_MODES;
-  }
-
-  /* Make multiple screens rotate at slightly different rates. */
-  se->speed_scale = 0.9+frand(0.3);
-
-  if ((se->glx_context = init_GL(mi)) != NULL)
-  {
-    reshape_sphereeversion(mi,MI_WIDTH(mi),MI_HEIGHT(mi));
-    init(mi);
-  }
-  else
-  {
-    MI_CLEARWINDOW(mi);
-  }
-}
-
-/*
- *-----------------------------------------------------------------------------
- *    Called by the mainline code periodically to update the display.
- *-----------------------------------------------------------------------------
- */
-ENTRYPOINT void draw_sphereeversion(ModeInfo *mi)
-{
-  Display *display = MI_DISPLAY(mi);
-  Window window = MI_WINDOW(mi);
-  sphereeversionstruct *se;
-
-  if (sphereeversion == NULL)
-    return;
-  se = &sphereeversion[MI_SCREEN(mi)];
-
-  MI_IS_DRAWN(mi) = True;
-  if (!se->glx_context)
-    return;
-
-  glXMakeCurrent(display, window, *se->glx_context);
-
-  display_sphereeversion(mi);
-
-  if (MI_IS_FPS(mi))
-    do_fps (mi);
-
-  glFlush();
-
-  glXSwapBuffers(display,window);
-}
-
-
-/*
- *-----------------------------------------------------------------------------
- *    The display is being taken away from us.  Free up malloc'ed 
- *      memory and X resources that we've alloc'ed.
- *-----------------------------------------------------------------------------
- */
-
-
-#ifndef STANDALONE
-ENTRYPOINT void change_sphereeversion(ModeInfo *mi)
-{
-  sphereeversionstruct *ev = &sphereeversion[MI_SCREEN(mi)];
-
-  if (!ev->glx_context)
-    return;
-
-  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *ev->glx_context);
-  init(mi);
-}
-#endif /* !STANDALONE */
-
-
-ENTRYPOINT void free_sphereeversion(ModeInfo *mi)
-{
-  sphereeversionstruct *se = &sphereeversion[MI_SCREEN(mi)];
-
-  if (!se->glx_context) return;
-  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *se->glx_context);
-
-  if (se->se) free(se->se);
-  if (se->sen) free(se->sen);
-  if (se->colf[0]) free(se->colf[0]);
-  if (se->colf[1]) free(se->colf[1]);
-  if (se->colb[0]) free(se->colb[0]);
-  if (se->colb[1]) free(se->colb[1]);
-  gltrackball_free(se->trackball);
-#ifdef HAVE_GLSL
-  if (se->solid_indices) free(se->solid_indices);
-  if (se->parallel_indices) free(se->parallel_indices);
-  if (se->meridian_indices) free(se->meridian_indices);
-  if (se->line_indices) free(se->line_indices);
-  if (se->use_shaders)
-  {
-    glUseProgram(0);
-    if (se->poly_shader_program != 0)
-      glDeleteProgram(se->poly_shader_program);
-    if (se->line_shader_program != 0)
-      glDeleteProgram(se->line_shader_program);
-    if (se->blend_shader_program != 0)
-      glDeleteProgram(se->blend_shader_program);
-    glDeleteTextures(2,se->color_textures);
-    glDeleteBuffers(1,&se->vertex_pos_buffer);
-    glDeleteBuffers(1,&se->vertex_normal_buffer);
-    glDeleteBuffers(2,se->vertex_colorf_buffer);
-    glDeleteBuffers(2,se->vertex_colorb_buffer);
-    glDeleteBuffers(1,&se->solid_indices_buffer);
-    glDeleteBuffers(1,&se->parallel_indices_buffer);
-    glDeleteBuffers(1,&se->meridian_indices_buffer);
-    glDeleteBuffers(1,&se->line_indices_buffer);
-  }
-#endif /* HAVE_GLSL */
-}
-
-
-XSCREENSAVER_MODULE ("SphereEversion", sphereeversion)
-
-#endif /* USE_GL */