git.hungrycats.org Git - xscreensaver/blob - hacks/glx/glcells.c

   1 /* -*- Mode: C; tab-width: 2 -*- */
   2 /* glcells --- Cells growing on your screen */
   3
   4 /*-
   5  * Cells growing on your screen
   6  *
   7  * Copyright (c) 2007 by Matthias Toussaint
   8  *
   9  * Permission to use, copy, modify, and distribute this software and its
  10  * documentation for any purpose and without fee is hereby granted,
  11  * provided that the above copyright notice appear in all copies and that
  12  * both that copyright notice and this permission notice appear in
  13  * supporting documentation.
  14  *
  15  * This file is provided AS IS with no warranties of any kind.  The author
  16  * shall have no liability with respect to the infringement of copyrights,
  17  * trade secrets or any patents by this file or any part thereof.  In no
  18  * event will the author be liable for any lost revenue or profits or
  19  * other special, indirect and consequential damages.
  20  *
  21  * 2007: Written by Matthias Toussaint
  22  * 0.1 Initial version
  23  * 0.2 Bugfixes (threading) and code cleanup by Jamie Zavinsky
  24  *     Window scaling bug + performance bug in tick()
  25  */
  26
  27 #include <sys/time.h> /* gettimeofday */
  28
  29 #include "xlockmore.h"
  30 #include <math.h>
  31
  32 /**********************************
  33   DEFINES
  34  **********************************/
  35
  36 #define INDEX_OFFSET 100000
  37 #define NUM_CELL_SHAPES 10
  38
  39 #define refresh_glcells 0
  40 #define glcells_handle_event 0
  41
  42 #define DEF_DELAY     "20000"
  43 #define DEF_MAXCELLS  "800"
  44 #define DEF_RADIUS    "40"
  45 #define DEF_SEEDS     "1"
  46 #define DEF_QUALITY   "3"
  47 #define DEF_KEEPOLD   "False"
  48 #define DEF_MINFOOD   "5"
  49 #define DEF_MAXFOOD   "20"
  50 #define DEF_DIVIDEAGE "20"
  51 #define DEF_MINDIST   "1.40"
  52 #define DEF_PAUSE     "50"
  53
  54 #define DEFAULTS        "*delay:        30000            \n" \
  55                         "*showFPS:      False            \n" \
  56                         "*wireframe:    False            \n" \
  57
  58 #undef countof
  59 #define countof(x) (sizeof((x))/sizeof((*x)))
  60
  61 #define USE_VERTEX_ARRAY
  62
  63 #define TEX_SIZE 64
  64
  65 /**********************************
  66   TYPEDEFS
  67  **********************************/
  68
  69 typedef struct    /* a 3-D vector */
  70 {
  71   double x, y, z;   /* 3-D coordinates (we don't need w here) */
  72 } Vector;
  73
  74 typedef struct    /* a triangle (indexes of vertexes in some list) */
  75 {
  76   int i[3];         /* the three indexes for the triangle corners */
  77 } Triangle;
  78
  79 typedef struct
  80 {
  81   float *vertex;
  82   float *normal;
  83   unsigned *index;
  84   int num_index;
  85 } VertexArray;
  86
  87 typedef struct    /* an 3-D object without normal vectors */
  88 {
  89   Vector *vertex;       /* the vertexes */
  90   Triangle *triangle;   /* triangle list */
  91   int num_vertex;       /* number of vertexes */
  92   int num_triangle;     /* number of triangles */
  93 } Object;
  94
  95 typedef struct    /* an 3-D object with smooth normal vectors */
  96 {
  97   Vector *vertex;       /* the vertexes */
  98   Vector *normal;       /* the vertex normal vectors */
  99   Triangle *triangle;   /* triangle list */
 100   int num_vertex;       /* number of vertexes */
 101   int num_triangle;     /* number of triangles */
 102 } ObjectSmooth;
 103
 104 typedef struct    /* Cell */
 105 {
 106   double x, y;      /* position */
 107   double vx, vy;    /* movement vector */
 108   int age;          /* cells age */
 109   double min_dist;  /* minimum distance to other cells */
 110   int energy;       /* health */
 111   double rotation;  /* random rot, so they don't look all the same */
 112   double radius;    /* current size of cell */
 113   double growth;    /* current growth rate. might be <1.0 while dividing,
 114                        >1.0 when finished dividing and food is available
 115                        and 1.0 when grown up */
 116 } Cell;
 117
 118 typedef struct    /* hacks state */
 119 {
 120   GLXContext *glx_context;
 121   int width, height;    /* current size of viewport */
 122   double screen_scale;  /* we scale content with window size */
 123   int num_cells;        /* current number of cell in list */
 124   Cell *cell;           /* array of cells */
 125   int cell_polys;
 126   GLfloat color[4];     /* current cell color */
 127   double radius;        /* cell radius */
 128   int move_dist;        /* min distance from neighbours for forking */
 129   int max_cells;        /* maximum number of cells */
 130   int num_seeds;        /* number of initial seeds */
 131   int keep_old_cells;   /* draw dead cells? */
 132   int divide_age;       /* min age for division */
 133                         /* display lists for the cell stages */
 134   int cell_list[NUM_CELL_SHAPES];
 135   int nucleus_list;
 136   int minfood;          /* minimum amount of food per area unit */
 137   int maxfood;          /* maximum amount of food per area unit */
 138   int pause;            /* pause at end (all cells dead) */
 139   int pause_counter;
 140   int wire;             /* draw wireframe? */
 141   Object *sphere;       /* the raw undisturbed sphere */
 142   double *disturbance;  /* disturbance values for the vertexes */
 143   int *food;            /* our petri dish (e.g. screen) */
 144   GLubyte *texture;     /* texture data for nucleus */
 145   GLuint texture_name;  /* texture name for binding */
 146 } State;
 147
 148 /**********************************
 149   STATIC STUFF
 150  **********************************/
 151
 152 static State *sstate = NULL;
 153
 154 static XrmOptionDescRec opts[] = {
 155   { "-maxcells",   ".maxcells",   XrmoptionSepArg, 0 },
 156   { "-radius",     ".radius",     XrmoptionSepArg, 0 },
 157   { "-seeds",      ".seeds",      XrmoptionSepArg, 0 },
 158   { "-quality",    ".quality",    XrmoptionSepArg, 0 },
 159   { "-minfood",    ".minfood",    XrmoptionSepArg, 0 },
 160   { "-maxfood",    ".maxfood",    XrmoptionSepArg, 0 },
 161   { "-divideage",  ".divideage",  XrmoptionSepArg, 0 },
 162   { "-mindist",    ".mindist",    XrmoptionSepArg, 0 },
 163   { "-pause",      ".pause",      XrmoptionSepArg, 0 },
 164   { "-keepold",    ".keepold",    XrmoptionNoArg, "True" }
 165 };
 166
 167 static int  s_maxcells;
 168 static int  s_radius;
 169 static int  s_seeds;
 170 static int  s_quality;
 171 static int  s_minfood;
 172 static int  s_maxfood;
 173 static int  s_divideage;
 174 static int  s_pause;
 175 static float s_min_dist;
 176 static Bool s_keepold;
 177
 178 static argtype vars[] = {
 179   {&s_maxcells,  "maxcells",  "Max Cells",      DEF_MAXCELLS, t_Int},
 180   {&s_radius,    "radius",    "Radius",         DEF_RADIUS,   t_Int},
 181   {&s_seeds,     "seeds",     "Seeds",          DEF_SEEDS,    t_Int},
 182   {&s_quality,   "quality",   "Quality",        DEF_QUALITY,  t_Int},
 183   {&s_minfood,   "minfood",   "Min Food",       DEF_MINFOOD,  t_Int},
 184   {&s_maxfood,   "maxfood",   "Max Food",       DEF_MAXFOOD,  t_Int},
 185   {&s_pause,   "pause",     "Pause at end",   DEF_PAUSE,  t_Int},
 186   {&s_divideage, "divideage", "Age for duplication (Ticks)",       DEF_DIVIDEAGE,  t_Int},
 187   {&s_min_dist,  "mindist",   "Minimum prefered distance to other cells",       DEF_MINDIST,  t_Float},
 188   {&s_keepold,   "keepold",   "Keep old cells", DEF_KEEPOLD,  t_Bool}
 189 };
 190
 191 /**********************************
 192   PROTOTYPES
 193  **********************************/
 194
 195 /* render scene */
 196 static int render( State *st );
 197 /* create initial cells and fill petri dish with food */
 198 static void create_cells( State * );
 199 /* do one animation step */
 200 static void tick( State *st );
 201 /* draw a single cell */
 202 static void draw_cell( State *st, int shape );
 203 /* draw cells nucleus */
 204 static void draw_nucleus( State *st );
 205 /* return randum number in the interval min-max */
 206 static int random_interval( int min, int max );
 207 /* retunr random number in the interval 0-max */
 208 static int random_max( int max );
 209 /* create display list for given disturbance weighting factor */
 210 static int create_list( State *st, double fac );
 211 /* return length of vector */
 212 static double vector_length( Vector * );
 213 /* normalize vector */
 214 static void vector_normalize( Vector * );
 215 /* a += b */
 216 static void vector_add( Vector *a, Vector *b );
 217 /* a -= b */
 218 static void vector_sub( Vector *a, Vector *b );
 219 /* a *= fac */
 220 static void vector_mul( Vector *a, double fac );
 221 /* a.x = a.y = a.z = 0 */
 222 static void vector_clear( Vector *a );
 223 /* return crossproduct a*b in out */
 224 static void vector_crossprod( Vector *a, Vector *b, Vector *out );
 225 /* return 1 if vectors are equal (epsilon compare) otherwise 0 */
 226 static int vector_compare( Vector *a, Vector *b );
 227 /* compute normal vector of given triangle and return in out */
 228 static void triangle_normal( Vector *a, Vector *b, Vector *c, Vector *out );
 229 /* take an Object and create an ObjectSmooth out of it */
 230 static ObjectSmooth *create_ObjectSmooth( Object * );
 231 /* Subdivide the Object once (assuming it's supposed to be a shpere */
 232 static Object *subdivide( Object *obj );
 233 /* free an Object */
 234 static void free_Object( Object * );
 235 /* free an ObjectSmooth */
 236 static void free_ObjectSmooth( ObjectSmooth * );
 237 /* scale an Object. return pointer to the object */
 238 /*static Object *scale_Object( Object *obj, double scale );*/
 239 /* create a perfect sphere refining with divisions */
 240 static Object *create_sphere( State *st, int divisions );
 241 /* make a copy of the given Object */
 242 static Object *clone_Object( Object * );
 243 /* return 1 if cell is capable to divide */
 244 static int can_divide( State *st, Cell *cell );
 245 static VertexArray *array_from_ObjectSmooth( ObjectSmooth * );
 246 static void create_nucleus_texture( State *st );
 247
 248 ENTRYPOINT ModeSpecOpt glcells_opts = { countof(opts), opts,                                                   countof(vars), vars,
 249                                         NULL };
 250
 251
 252 /**********************************
 253   INLINE FUNCTIONS
 254  **********************************/
 255 /* create random numbers
 256 */
 257 static inline int random_interval( int min, int max )
 258 {
 259   int n = max - min;
 260   if (n == 0) n = 1;
 261   return min+(random()%n);
 262 }
 263
 264 static inline int random_max( int max )
 265 {
 266   return random()%max;
 267 }
 268
 269 /* Vector stuff
 270 */
 271
 272 /* a += b */
 273 static inline void vector_add( Vector *a, Vector *b )
 274 {
 275   a->x += b->x;
 276   a->y += b->y;
 277   a->z += b->z;
 278 }
 279
 280 /* a -= b */
 281 static inline void vector_sub( Vector *a, Vector *b )
 282 {
 283   a->x -= b->x;
 284   a->y -= b->y;
 285   a->z -= b->z;
 286 }
 287
 288 /* a *= v */
 289 static inline void vector_mul( Vector *a, double v )
 290 {
 291   a->x *= v;
 292   a->y *= v;
 293   a->z *= v;
 294 }
 295
 296 /* set to 0 */
 297 static inline void vector_clear( Vector *vec )
 298 {
 299   vec->x = vec->y = vec->z = 0;
 300 }
 301
 302 /* return vector length */
 303 static inline double vector_length( Vector *vec )
 304 {
 305   return sqrt( vec->x*vec->x + vec->y*vec->y + vec->z*vec->z );
 306 }
 307
 308 /* normalize vector */
 309 static inline void vector_normalize( Vector *vec )
 310 {
 311   double len = vector_length( vec );
 312
 313   if (len != 0.0) {
 314     vector_mul( vec, 1.0 / len );
 315   }
 316 }
 317
 318 /* crossproduct */
 319 static inline void vector_crossprod( Vector *a, Vector *b, Vector *out )
 320 {
 321   out->x = a->y*b->z - a->z*b->y;
 322   out->y = a->z*b->x - a->x*b->z;
 323   out->z = a->x*b->y - a->y*b->x;
 324 }
 325
 326 /* epsilon compare of two vectors */
 327 static inline int vector_compare( Vector *a, Vector *b )
 328 {
 329   const double epsilon = 0.0000001;
 330   Vector delta = *a;
 331
 332   vector_sub( &delta, b );
 333   if (fabs(delta.x) < epsilon &&
 334       fabs(delta.y) < epsilon &&
 335       fabs(delta.z) < epsilon) {
 336     return 1;
 337   }
 338
 339   return 0;
 340 }
 341
 342 /* check if given cell is capable of dividing
 343    needs space, must be old enough, grown up and healthy
 344 */
 345 static inline int can_divide( State *st, Cell *cell )
 346 {
 347   if (cell->min_dist > st->move_dist &&
 348       cell->age >= st->divide_age &&
 349       cell->radius > 0.99 * st->radius &&
 350       cell->energy > 0) {
 351     return 1;
 352   }
 353
 354   return 0;
 355 }
 356
 357 /**********************************
 358   FUNCTIONS
 359  **********************************/
 360
 361 /* compute normal vector of given
 362    triangle spanned by the points a, b, c
 363 */
 364 static void triangle_normal( Vector *a, Vector *b, Vector *c, Vector *out )
 365 {
 366   Vector v1 = *a;
 367   Vector v2 = *a;
 368
 369   vector_sub( &v1, b );
 370   vector_sub( &v2, c );
 371   vector_crossprod( &v1, &v2, out );
 372 }
 373
 374 /* free */
 375 static void free_Object( Object *obj )
 376 {
 377   free( obj->vertex );
 378   free( obj->triangle );
 379   free( obj );
 380 }
 381
 382 static void free_ObjectSmooth( ObjectSmooth *obj )
 383 {
 384   free( obj->vertex );
 385   free( obj->triangle );
 386   free( obj->normal );
 387   free( obj );
 388 }
 389
 390 /* scale the given Object */
 391 #if 0
 392 static Object *scale_Object( Object *obj, double scale )
 393 {
 394   int v;
 395
 396   for (v=0; v<obj->num_vertex; ++v) {
 397     vector_mul( &obj->vertex[v], scale );
 398   }
 399
 400   return obj;
 401 }
 402 #endif
 403
 404 /* create a copy of the given Object */
 405 static Object *clone_Object( Object *obj )
 406 {
 407   /* alloc */
 408   Object *ret = (Object *) malloc( sizeof( Object ) );
 409
 410   ret->vertex =
 411       (Vector *) malloc( obj->num_vertex*sizeof(Vector) );
 412   ret->triangle =
 413       (Triangle *) malloc( obj->num_triangle*sizeof(Triangle) );
 414   ret->num_vertex = obj->num_vertex;
 415   ret->num_triangle = obj->num_triangle;
 416   /* copy */
 417   memcpy( ret->vertex, obj->vertex,
 418           obj->num_vertex*sizeof(Vector) );
 419   memcpy( ret->triangle, obj->triangle,
 420           obj->num_triangle*sizeof(Triangle) );
 421
 422   return ret;
 423 }
 424
 425 static VertexArray *array_from_ObjectSmooth( ObjectSmooth *obj )
 426 {
 427   int i, j;
 428   VertexArray *array = (VertexArray *) malloc( sizeof( VertexArray ) );
 429
 430   array->vertex = (float *) malloc( 3*sizeof(float)*obj->num_vertex );
 431   array->normal = (float *) malloc( 3*sizeof(float)*obj->num_vertex );
 432   array->index = (unsigned *) malloc( 3*sizeof(unsigned)*obj->num_triangle );
 433   array->num_index = obj->num_triangle*3;
 434
 435   for (i=0, j=0; i<obj->num_vertex; ++i) {
 436     array->vertex[j]   = obj->vertex[i].x;
 437     array->normal[j++] = obj->normal[i].x;
 438     array->vertex[j]   = obj->vertex[i].y;
 439     array->normal[j++] = obj->normal[i].y;
 440     array->vertex[j]   = obj->vertex[i].z;
 441     array->normal[j++] = obj->normal[i].z;
 442   }
 443
 444   for (i=0, j=0; i<obj->num_triangle; ++i) {
 445     array->index[j++] = obj->triangle[i].i[0];
 446     array->index[j++] = obj->triangle[i].i[1];
 447     array->index[j++] = obj->triangle[i].i[2];
 448   }
 449
 450   return array;
 451 }
 452
 453 /* create a smoothed version of the given Object
 454    by computing average normal vectors for the vertexes
 455 */
 456 static ObjectSmooth *create_ObjectSmooth( Object *obj )
 457 {
 458   int t, v, i;
 459   Vector *t_normal =
 460       (Vector *) malloc( obj->num_triangle*sizeof(Vector) );
 461   ObjectSmooth *ret =
 462       (ObjectSmooth *) malloc( sizeof( ObjectSmooth ) );
 463
 464   /* fill in vertexes and triangles */
 465   ret->num_vertex = obj->num_vertex;
 466   ret->num_triangle = obj->num_triangle;
 467   ret->vertex =
 468       (Vector *) malloc( obj->num_vertex * sizeof( Vector ) );
 469   ret->normal =
 470       (Vector *) malloc( obj->num_vertex * sizeof( Vector ) );
 471   ret->triangle =
 472       (Triangle *) malloc( obj->num_triangle * sizeof( Triangle ) );
 473
 474   for (v=0; v<obj->num_vertex; ++v) {
 475     ret->vertex[v] = obj->vertex[v];
 476   }
 477
 478   for (t=0; t<obj->num_triangle; ++t) {
 479     ret->triangle[t] = obj->triangle[t];
 480   }
 481
 482   /* create normals (triangles) */
 483   for (t=0; t<ret->num_triangle; ++t) {
 484     triangle_normal( &ret->vertex[ret->triangle[t].i[0]],
 485                      &ret->vertex[ret->triangle[t].i[1]],
 486                      &ret->vertex[ret->triangle[t].i[2]],
 487                      &t_normal[t] );
 488   }
 489
 490   /* create normals (vertex) by averaging triangle
 491      normals at vertex
 492   */
 493   for (v=0; v<ret->num_vertex; ++v) {
 494     vector_clear( &ret->normal[v] );
 495     for (t=0; t<ret->num_triangle; ++t) {
 496       for (i=0; i<3; ++i) {
 497         if (ret->triangle[t].i[i] == v) {
 498           vector_add( &ret->normal[v], &t_normal[t] );
 499         }
 500       }
 501     }
 502     /* as we have only a half sphere we force the
 503        normals at the bortder to be perpendicular to z.
 504        the simple algorithm above makes an error here.
 505     */
 506     if (fabs(ret->vertex[v].z) < 0.0001) {
 507       ret->normal[v].z = 0.0;
 508     }
 509
 510     vector_normalize( &ret->normal[v] );
 511   }
 512
 513   free( t_normal );
 514
 515   return ret;
 516 }
 517
 518 /* subdivide the triangles of the object once
 519    The order of this algorithm is probably something like O(n^42) :)
 520    but I can't think of something smarter at the moment
 521 */
 522 static Object *subdivide( Object *obj )
 523 {
 524   /* create for worst case (which I dont't know) */
 525   int start, t, i, v;
 526   int index_list[1000];
 527   int index_cnt, index_found;
 528   Object *tmp = (Object *)malloc( sizeof(Object) );
 529   Object *ret = (Object *)malloc( sizeof(Object) );
 530   Object *c_ret;
 531
 532   tmp->vertex =
 533       (Vector *)malloc( 100*obj->num_vertex*sizeof( Vector ) );
 534   tmp->triangle =
 535       (Triangle *)malloc( 4*obj->num_triangle*sizeof( Triangle ) );
 536   tmp->num_vertex = 0;
 537   tmp->num_triangle = 0;
 538   ret->vertex =
 539       (Vector *)malloc( 100*obj->num_vertex*sizeof( Vector ) );
 540   ret->triangle =
 541       (Triangle *)malloc( 4*obj->num_triangle*sizeof( Triangle ) );
 542   ret->num_vertex = 0;
 543   ret->num_triangle = 0;
 544 #ifdef PRINT_STAT
 545   fprintf( stderr, "in v=%d t=%d\n",
 546            obj->num_vertex, obj->num_triangle );
 547 #endif
 548   /* for each triangle create 3 new vertexes and the 4
 549      corresponding triangles
 550   */
 551   for (t=0; t<obj->num_triangle; ++t) {
 552     /* copy the three original vertexes */
 553     for (i=0; i<3; ++i) {
 554       tmp->vertex[tmp->num_vertex++] =
 555         obj->vertex[obj->triangle[t].i[i]];
 556     }
 557
 558     /* create 3 new */
 559     tmp->vertex[tmp->num_vertex] =
 560         obj->vertex[obj->triangle[t].i[0]];
 561     vector_add( &tmp->vertex[tmp->num_vertex],
 562                  &obj->vertex[obj->triangle[t].i[1]] );
 563     vector_mul( &tmp->vertex[tmp->num_vertex++], 0.5 );
 564
 565     tmp->vertex[tmp->num_vertex] =
 566         obj->vertex[obj->triangle[t].i[1]];
 567     vector_add( &tmp->vertex[tmp->num_vertex],
 568                  &obj->vertex[obj->triangle[t].i[2]] );
 569     vector_mul( &tmp->vertex[tmp->num_vertex++], 0.5 );
 570
 571     tmp->vertex[tmp->num_vertex] =
 572         obj->vertex[obj->triangle[t].i[2]];
 573     vector_add( &tmp->vertex[tmp->num_vertex],
 574                  &obj->vertex[obj->triangle[t].i[0]] );
 575     vector_mul( &tmp->vertex[tmp->num_vertex++], 0.5 );
 576
 577     /* create triangles */
 578     start = tmp->num_vertex-6;
 579
 580     tmp->triangle[tmp->num_triangle].i[0] = start;
 581     tmp->triangle[tmp->num_triangle].i[1] = start+3;
 582     tmp->triangle[tmp->num_triangle++].i[2] = start+5;
 583
 584     tmp->triangle[tmp->num_triangle].i[0] = start+3;
 585     tmp->triangle[tmp->num_triangle].i[1] = start+1;
 586     tmp->triangle[tmp->num_triangle++].i[2] = start+4;
 587
 588     tmp->triangle[tmp->num_triangle].i[0] = start+5;
 589     tmp->triangle[tmp->num_triangle].i[1] = start+4;
 590     tmp->triangle[tmp->num_triangle++].i[2] = start+2;
 591
 592     tmp->triangle[tmp->num_triangle].i[0] = start+3;
 593     tmp->triangle[tmp->num_triangle].i[1] = start+4;
 594     tmp->triangle[tmp->num_triangle++].i[2] = start+5;
 595   }
 596
 597   /* compress object eliminating double vertexes
 598      (welcome to the not so smart section)
 599   */
 600   /* copy original triangle list */
 601   for (t=0; t<tmp->num_triangle; ++t) {
 602     ret->triangle[t] = tmp->triangle[t];
 603   }
 604   ret->num_triangle = tmp->num_triangle;
 605
 606   /* copy unique vertexes and correct triangle list */
 607   for (v=0; v<tmp->num_vertex; ++v) {
 608     /* create list of vertexes that are the same */
 609     index_cnt = 0;
 610     for (i=0; i<tmp->num_vertex; ++i) {
 611       /* check if i and v are the same
 612          first in the list is the smallest index
 613       */
 614       if (vector_compare( &tmp->vertex[v], &tmp->vertex[i] )) {
 615         index_list[index_cnt++] = i;
 616       }
 617     }
 618
 619     /* check if vertex unknown so far */
 620     index_found = 0;
 621     for (i=0; i<ret->num_vertex; ++i) {
 622       if (vector_compare( &ret->vertex[i],
 623           &tmp->vertex[index_list[0]] )) {
 624         index_found = 1;
 625         break;
 626       }
 627     }
 628
 629     if (!index_found) {
 630       ret->vertex[ret->num_vertex] = tmp->vertex[index_list[0]];
 631
 632       /* correct triangles
 633          (we add an offset to the index, so we can tell them apart)
 634       */
 635       for (t=0; t<ret->num_triangle; ++t) {
 636         for (i=0; i<index_cnt; ++i) {
 637           if (ret->triangle[t].i[0] == index_list[i]) {
 638             ret->triangle[t].i[0] = ret->num_vertex+INDEX_OFFSET;
 639           }
 640           if (ret->triangle[t].i[1] == index_list[i]) {
 641             ret->triangle[t].i[1] = ret->num_vertex+INDEX_OFFSET;
 642           }
 643           if (ret->triangle[t].i[2] == index_list[i]) {
 644             ret->triangle[t].i[2] = ret->num_vertex+INDEX_OFFSET;
 645           }
 646         }
 647       }
 648       ret->num_vertex++;
 649     }
 650   }
 651
 652   free_Object( tmp );
 653
 654   /* correct index offset */
 655   for (t=0; t<ret->num_triangle; ++t) {
 656     ret->triangle[t].i[0] -= INDEX_OFFSET;
 657     ret->triangle[t].i[1] -= INDEX_OFFSET;
 658     ret->triangle[t].i[2] -= INDEX_OFFSET;
 659   }
 660
 661   /* normalize vertexes */
 662   for (v=0; v<ret->num_vertex; ++v) {
 663     vector_normalize( &ret->vertex[v] );
 664   }
 665 #ifdef PRINT_STAT
 666   fprintf( stderr, "out v=%d t=%d\n",
 667            ret->num_vertex, ret->num_triangle );
 668 #endif
 669   /* shrink the arrays by cloning */
 670   c_ret = clone_Object( ret );
 671   free_Object( ret );
 672
 673   return c_ret;
 674 }
 675
 676 static int render( State *st )
 677 {
 678 #ifdef PRINT_STAT
 679   struct timeval tv1, tv2;
 680   int usec;
 681 #endif
 682   GLfloat LightAmbient[]= { 0.1f, 0.1f, 0.1f, 1.0f };
 683   GLfloat LightPosition[]= { -20.0f, -10.0f, -100.0f, 0.0f };
 684   int b;
 685   int num_paint = 0;
 686
 687   if (0 == st->food) return 0;
 688 #ifdef PRINT_STAT
 689   gettimeofday( &tv1, NULL );
 690 #endif
 691   /* life goes on... */
 692   tick( st );
 693 #ifdef PRINT_STAT
 694   gettimeofday( &tv2, NULL );
 695   usec = (tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec);
 696   fprintf( stderr, "tick %d\n", usec );
 697   gettimeofday( &tv1, NULL );
 698 #endif
 699   glClearColor( 0, 0, 0, 0 );
 700
 701   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 702   glDepthFunc(GL_LESS);
 703   glEnable(GL_DEPTH_TEST);
 704   glLightfv( GL_LIGHT0, GL_AMBIENT, LightAmbient );
 705   glLightfv( GL_LIGHT0, GL_DIFFUSE, st->color );
 706   glLightfv( GL_LIGHT0, GL_POSITION, LightPosition );
 707
 708   /* prepare lighting vs. wireframe */
 709   if (!st->wire) {
 710     glEnable( GL_LIGHT0 );
 711     glEnable( GL_LIGHTING );
 712     glEnable( GL_NORMALIZE );
 713     glPolygonMode( GL_FRONT, GL_FILL );
 714   } else {
 715     glPolygonMode( GL_FRONT, GL_LINE );
 716   }
 717
 718   /* draw the dead cells if choosen */
 719   if (st->keep_old_cells) {
 720     for (b=0; b<st->num_cells; ++b) {
 721       if (st->cell[b].energy <= 0) {
 722         num_paint++;
 723         glPushMatrix();
 724         glTranslatef( st->cell[b].x, st->cell[b].y, 0.0 );
 725         glRotatef( st->cell[b].rotation, 0.0, 0.0, 1.0 );
 726         glScalef( st->cell[b].radius, st->cell[b].radius, st->cell[b].radius );
 727         draw_cell( st, 9 );
 728         glPopMatrix();
 729       }
 730     }
 731   }
 732
 733   /* draw the living cells */
 734   for (b=0; b<st->num_cells; ++b) {
 735      if (st->cell[b].energy >0) {
 736       double fac = (double)st->cell[b].energy / 50.0;
 737       int shape;
 738       if (fac < 0.0) fac = 0.0;
 739       if (fac > 1.0) fac = 1.0;
 740
 741       shape = (int)(9.0*fac);
 742       num_paint++;
 743       /*glColor3f( fac, fac, fac );*/
 744
 745       glPushMatrix();
 746       glTranslatef( st->cell[b].x, st->cell[b].y, 0.0 );
 747       glRotatef( st->cell[b].rotation, 0.0, 0.0, 1.0 );
 748       glScalef( st->cell[b].radius, st->cell[b].radius, st->cell[b].radius );
 749       draw_cell( st, 9-shape );
 750       glPopMatrix();
 751     }
 752   }
 753
 754   /* draw cell nuclei */
 755   if (!st->wire)
 756   {
 757     glDisable( GL_LIGHT0 );
 758     glDisable( GL_LIGHTING );
 759
 760     glEnable( GL_BLEND );
 761     glDisable( GL_DEPTH_TEST );
 762     glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 763     glEnable( GL_TEXTURE_2D );
 764     glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
 765     glBindTexture( GL_TEXTURE_2D, st->texture_name );
 766
 767     for (b=0; b<st->num_cells; ++b) {
 768       if (st->cell[b].energy>0 || st->keep_old_cells) {
 769         glPushMatrix();
 770         glTranslatef( st->cell[b].x, st->cell[b].y, 0.0 );
 771         glScalef( st->cell[b].radius, st->cell[b].radius, st->cell[b].radius );
 772         draw_nucleus( st );
 773         glPopMatrix();
 774       }
 775     }
 776
 777     glDisable( GL_TEXTURE_2D );
 778     glDisable( GL_BLEND );
 779   }
 780
 781 #ifdef PRINT_STAT
 782   gettimeofday( &tv2, NULL );
 783   usec = (tv2.tv_sec-tv1.tv_sec)*1000000+(tv2.tv_usec-tv1.tv_usec);
 784   fprintf( stderr, "OpenGL %d\n", usec );
 785 #endif
 786   return num_paint * st->cell_polys;
 787 }
 788
 789 /* this creates the initial subdivided half-dodecaedron */
 790 static Object *create_sphere( State *st, int divisions )
 791 {
 792   int num_vertex = 9;
 793   int num_triangle = 10;
 794   int i, v, t;
 795   double a, aStep = (double)M_PI / 3.0;
 796   double e;
 797   int vi[30] = { 0, 7, 1, 1, 7, 2, 2, 8, 3, 3, 8, 4, 4, 6, 5,
 798                  5, 6, 0, 0, 6, 7, 2, 7, 8, 4, 8, 6, 6, 8, 7 };
 799   Object *obj = (Object *)malloc( sizeof( Object ) );
 800
 801   obj->vertex = (Vector *)malloc( num_vertex*sizeof( Vector ) );
 802   obj->triangle =
 803       (Triangle *)malloc( num_triangle*sizeof( Triangle ) );
 804   obj->num_vertex = num_vertex;
 805   obj->num_triangle = num_triangle;
 806
 807   /* create vertexes for dodecaedron */
 808   a = 0.0;
 809   for (v=0; v<6; ++v) {
 810     obj->vertex[v].x = sin( a );
 811     obj->vertex[v].y = -cos( a );
 812     obj->vertex[v].z = 0.0;
 813
 814     a += aStep;
 815   }
 816
 817   a = -60.0/180.0*(double)M_PI;
 818   e = 58.2825/180.0 * (double)M_PI;
 819   for (;v<9; ++v) {
 820     obj->vertex[v].x = sin( a )*cos( e );
 821     obj->vertex[v].y = -cos( a )*cos( e );
 822     obj->vertex[v].z = -sin( e );
 823
 824     a += 2.0*aStep;
 825   }
 826
 827   /* create triangles */
 828   for (t=0; t<obj->num_triangle; ++t) {
 829     obj->triangle[t].i[0] = vi[3*t];
 830     obj->triangle[t].i[1] = vi[3*t+1];
 831     obj->triangle[t].i[2] = vi[3*t+2];
 832   }
 833
 834   /* subdivide as specified */
 835   for (i=0; i<divisions; ++i) {
 836     Object *newObj = subdivide( obj );
 837     free_Object( obj );
 838     obj = newObj;
 839   }
 840
 841   st->cell_polys = obj->num_triangle;
 842
 843   return obj;
 844 }
 845
 846 static int create_list( State *st, double fac )
 847 {
 848   int v;
 849   Object *obj = clone_Object( st->sphere );
 850   ObjectSmooth *smooth;
 851 #ifdef USE_VERTEX_ARRAY
 852   VertexArray *vertex_array;
 853 #endif
 854   int list = glGenLists(1);
 855
 856   /* apply wrinckle factor */
 857   for (v=0; v<obj->num_vertex; ++v) {
 858     vector_mul( &obj->vertex[v], 1.0+fac*st->disturbance[v] );
 859   }
 860
 861   /* compute normals */
 862   smooth = create_ObjectSmooth( obj );
 863   free_Object( obj );
 864
 865   /* Create display list */
 866   glNewList( list, GL_COMPILE );
 867 #ifdef USE_VERTEX_ARRAY
 868   vertex_array = array_from_ObjectSmooth( smooth );
 869   glEnableClientState( GL_VERTEX_ARRAY );
 870   glEnableClientState( GL_NORMAL_ARRAY );
 871   glVertexPointer( 3, GL_FLOAT, 0, vertex_array->vertex );
 872   glNormalPointer( GL_FLOAT, 0, vertex_array->normal );
 873   glDrawElements( GL_TRIANGLES, vertex_array->num_index,
 874                   GL_UNSIGNED_INT, vertex_array->index );
 875   free( vertex_array );
 876 #else
 877   glBegin( GL_TRIANGLES );
 878
 879   for (t=0; t<smooth->num_triangle; ++t) {
 880     for (i=0; i<3; ++i) {
 881       glNormal3f( smooth->normal[smooth->triangle[t].i[i]].x,
 882                   smooth->normal[smooth->triangle[t].i[i]].y,
 883                   smooth->normal[smooth->triangle[t].i[i]].z );
 884       glVertex3f( smooth->vertex[smooth->triangle[t].i[i]].x,
 885                   smooth->vertex[smooth->triangle[t].i[i]].y,
 886                   smooth->vertex[smooth->triangle[t].i[i]].z );
 887     }
 888   }
 889
 890   glEnd();
 891 #endif
 892   glEndList();
 893
 894   free_ObjectSmooth( smooth );
 895
 896   return list;
 897 }
 898
 899 static void draw_cell( State *st, int shape )
 900 {
 901   if (-1 == st->cell_list[shape]) {
 902     st->cell_list[shape] = create_list( st, (double)shape/10.0 );
 903   }
 904
 905   glCallList( st->cell_list[shape] );
 906 }
 907
 908 static void create_nucleus_texture( State *st )
 909 {
 910   int x, y;
 911   int w2 = TEX_SIZE/2;
 912   float s = w2*w2/4.0;
 913
 914   st->texture = (GLubyte *) malloc( 4*TEX_SIZE*TEX_SIZE );
 915
 916   for (y=0; y<TEX_SIZE; ++y) {
 917     for (x=0; x<TEX_SIZE; ++x) {
 918       float r2 = ((x-w2)*(x-w2)+(y-w2)*(y-w2));
 919       float v = 120.0 * expf( -(r2) / s );
 920       st->texture[4*(x+y*TEX_SIZE)]   = (GLubyte)0;
 921       st->texture[4*(x+y*TEX_SIZE)+1] = (GLubyte)0;
 922       st->texture[4*(x+y*TEX_SIZE)+2] = (GLubyte)0;
 923       st->texture[4*(x+y*TEX_SIZE)+3] = (GLubyte)v;
 924     }
 925   }
 926
 927   glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
 928   glGenTextures( 1, &st->texture_name );
 929   glBindTexture( GL_TEXTURE_2D, st->texture_name );
 930
 931   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
 932   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
 933   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 934   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
 935   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0,
 936                 GL_RGBA, GL_UNSIGNED_BYTE, st->texture );
 937 }
 938
 939 static void draw_nucleus( State *st )
 940 {
 941   if (-1 == st->nucleus_list) {
 942     float z = -1.2f;
 943     float r=1.0/2.0f;
 944     st->nucleus_list = glGenLists( 1 );
 945     glNewList( st->nucleus_list, GL_COMPILE );
 946     glBegin( GL_QUADS );
 947     glTexCoord2f( 0.0f, 0.0f ); glVertex3f( -r, -r, z );
 948     glTexCoord2f( 0.0f, 1.0f ); glVertex3f( -r, r, z );
 949     glTexCoord2f( 1.0f, 1.0f ); glVertex3f( r, r, z );
 950     glTexCoord2f( 1.0f, 0.0f ); glVertex3f( r, -r, z );
 951     glEnd();
 952     glEndList();
 953   }
 954
 955   glCallList( st->nucleus_list );
 956 }
 957
 958 static void create_cells( State *st )
 959 {
 960   int border = (int)(200.0 * st->screen_scale);
 961   int i, foodcnt;
 962   int w = st->width-2*border;
 963   int h = st->height-2*border;
 964
 965   st->color[0] = 0.5 + random_max( 1000 ) * 0.0005;
 966   st->color[1] = 0.5 + random_max( 1000 ) * 0.0005;
 967   st->color[2] = 0.5 + random_max( 1000 ) * 0.0005;
 968   st->color[3] = 1.0f;
 969
 970   /* allocate if startup */
 971   if (!st->cell) {
 972     st->cell = (Cell *) malloc( st->max_cells * sizeof(Cell));
 973   }
 974
 975   /* fill the screen with random food for our little critters */
 976   foodcnt = (st->width*st->height)/16;
 977   for (i=0; i<foodcnt; ++i) {
 978     st->food[i] = random_interval( st->minfood, st->maxfood );
 979   }
 980
 981   /* create the requested seed-cells */
 982   st->num_cells = st->num_seeds;
 983
 984   for (i=0; i<st->num_cells; ++i) {
 985     st->cell[i].x        = border + random_max( w );
 986     st->cell[i].y        = border + random_max( h );
 987     st->cell[i].vx       = 0.0;
 988     st->cell[i].vy       = 0.0;
 989     st->cell[i].age      = random_max( 0x0f );
 990     st->cell[i].min_dist = 500.0;
 991     st->cell[i].energy   = random_interval( 5, 5+0x3f );
 992     st->cell[i].rotation = ((double)random()/(double)RAND_MAX)*360.0;
 993     st->cell[i].radius   = st->radius;
 994     st->cell[i].growth   = 1.0;
 995   }
 996 }
 997
 998 /* all this is rather expensive :( */
 999 static void tick( State *st )
1000 {
1001   int new_num_cells, num_cells=0;
1002   int b, j;
1003   int x, y, w4=st->width/4, h4=st->height/4, offset;
1004   double min_dist;
1005   int min_index;
1006   int num_living = 0;
1007   const double check_dist = 0.75*st->move_dist;
1008   const double grow_dist = 0.75*st->radius;
1009   const double adult_radius = st->radius;
1010
1011   /* find number of cells capable of division
1012      and count living cells
1013   */
1014   for (b=0; b<st->num_cells; ++b) {
1015     if (st->cell[b].energy > 0) num_living++;
1016     if (can_divide( st, &st->cell[b] )) num_cells++;
1017   }
1018   new_num_cells = st->num_cells + num_cells;
1019
1020   /* end of simulation ? */
1021   if (0 == num_living || new_num_cells >= st->max_cells) {
1022     if (st->pause_counter > 0) st->pause_counter--;
1023     if (st->pause_counter > 0) return;
1024     create_cells( st );
1025     st->pause_counter = st->pause;
1026   } else if (num_cells) { /* any fertile candidates ? */
1027     for (b=0, j=st->num_cells; b<st->num_cells; ++b) {
1028       if (can_divide( st, &st->cell[b] )) {
1029         st->cell[b].vx      = random_interval( -50, 50 ) * 0.01;
1030         st->cell[b].vy      = random_interval( -50, 50 ) * 0.01;
1031         st->cell[b].age     = random_max( 0x0f );
1032         /* half energy for both plus some bonus for forking */
1033         st->cell[b].energy  =
1034             st->cell[b].energy/2 + random_max( 0x0f );
1035         /* forking makes me shrink */
1036         st->cell[b].growth  = 0.995;
1037
1038         /* this one initially goes into the oposite direction */
1039         st->cell[j].vx       = -st->cell[b].vx;
1040         st->cell[j].vy       = -st->cell[b].vy;
1041         /* same center */
1042         st->cell[j].x        = st->cell[b].x;
1043         st->cell[j].y        = st->cell[b].y;
1044         st->cell[j].age      = random_max( 0x0f );
1045         st->cell[j].energy   = (st->cell[b].energy);
1046         st->cell[j].rotation =
1047             ((double)random()/(double)RAND_MAX)*360.0;
1048         st->cell[j].growth   = st->cell[b].growth;
1049         st->cell[j].radius   = st->cell[b].radius;
1050         ++j;
1051       } else {
1052         st->cell[b].vx = 0.0;
1053         st->cell[b].vy = 0.0;
1054       }
1055     }
1056
1057     st->num_cells = new_num_cells;
1058   }
1059
1060   /* for each find a direction to escape */
1061   if (st->num_cells > 1) {
1062     for (b=0; b<st->num_cells; ++b) {
1063       if (st->cell[b].energy > 0) {
1064         double vx;
1065         double vy;
1066         double len;
1067
1068         /* grow or shrink */
1069         st->cell[b].radius *= st->cell[b].growth;
1070         /* find closest neighbour */
1071         min_dist = 100000.0;
1072         min_index = 0;
1073         for (j=0; j<st->num_cells; ++j) {
1074           if (j!=b) {
1075             const double dx = st->cell[b].x - st->cell[j].x;
1076             const double dy = st->cell[b].y - st->cell[j].y;
1077
1078             if (fabs(dx) < check_dist || fabs(dy) < check_dist) {
1079               const double dist = dx*dx+dy*dy;
1080               /*const double dist = sqrt( dx*dx+dy*dy );*/
1081               if (dist<min_dist) {
1082                 min_dist = dist;
1083                 min_index = j;
1084               }
1085             }
1086           }
1087         }
1088         /* escape step is away from closest normalized with distance */
1089         vx = st->cell[b].x - st->cell[min_index].x;
1090         vy = st->cell[b].y - st->cell[min_index].y;
1091         len = sqrt( vx*vx + vy*vy );
1092         if (len > 0.0001) {
1093           st->cell[b].vx = vx/len;
1094           st->cell[b].vy = vy/len;
1095         }
1096         st->cell[b].min_dist = len;
1097         /* if not adult (radius too small) */
1098         if (st->cell[b].radius < adult_radius) {
1099           /* if too small 60% stop shrinking */
1100           if (st->cell[b].radius < adult_radius * 0.6) {
1101             st->cell[b].growth = 1.0;
1102           }
1103           /* at safe distance we start growing again */
1104           if (len > grow_dist) {
1105             if (st->cell[b].energy > 30) {
1106               st->cell[b].growth = 1.005;
1107             }
1108           }
1109         } else {  /* else keep size */
1110           st->cell[b].growth = 1.0;
1111         }
1112       }
1113     }
1114   } else {
1115     st->cell[0].min_dist = 2*st->move_dist;
1116   }
1117
1118   /* now move em, snack and burn energy */
1119   for (b=0; b<st->num_cells; ++b) {
1120     /* if still alive */
1121     if (st->cell[b].energy > 0) {
1122       /* agility depends on amount of energy */
1123       double fac = (double)st->cell[b].energy / 50.0;
1124       if (fac < 0.0) fac = 0.0;
1125       if (fac > 1.0) fac = 1.0;
1126
1127       st->cell[b].x += fac*(2.0 -
1128           (4.0*(double)random() / (double)RAND_MAX) +
1129           st->cell[b].vx);
1130       st->cell[b].y += fac*(2.0 -
1131           (4.0*(double)random() / (double)RAND_MAX) +
1132           st->cell[b].vy);
1133
1134       /* get older and burn energy */
1135       if (st->cell[b].energy > 0) {
1136         st->cell[b].age++;
1137         st->cell[b].energy--;
1138       }
1139
1140       /* have a snack */
1141       x = ((int)st->cell[b].x)/4;
1142       if (x<0) x=0; if (x>=w4) x = w4-1;
1143       y = ((int)st->cell[b].y)/4;
1144       if (y<0) y=0; if (y>=h4) y = h4-1;
1145
1146       offset = x+y*w4;
1147
1148       /* don't eat if already satisfied */
1149       if (st->cell[b].energy < 100 &&
1150           st->food[offset] > 0) {
1151         st->food[offset]--;
1152         st->cell[b].energy++;
1153         /* if you are hungry, eat more */
1154         if (st->cell[b].energy < 50 &&
1155             st->food[offset] > 0) {
1156           st->food[offset]--;
1157           st->cell[b].energy++;
1158         }
1159       }
1160     }
1161   }
1162 }
1163
1164 ENTRYPOINT void
1165 reshape_glcells( ModeInfo *mi, int width, int height )
1166 {
1167   State *st  = &sstate[MI_SCREEN(mi)];
1168   st->height = height;
1169   st->width  = width;
1170   st->screen_scale = (double)width / 1600.0;
1171
1172   st->radius = s_radius;
1173   if (st->radius < 5) st->radius = 5;
1174   if (st->radius > 200) st->radius = 200;
1175   st->radius *= st->screen_scale;
1176
1177   st->move_dist = s_min_dist;
1178   if (st->move_dist < 1.0) st->move_dist = 1.0;
1179   if (st->move_dist > 3.0) st->move_dist = 3.0;
1180   st->move_dist *= st->radius;
1181
1182   glViewport (0, 0, (GLint) width, (GLint) height);
1183
1184   glMatrixMode(GL_PROJECTION);
1185   glLoadIdentity();
1186   glOrtho( 0, width, height, 0, 200, 0 );
1187   glMatrixMode(GL_MODELVIEW);
1188   glLoadIdentity();
1189
1190   if (st->food) free( st->food );
1191   st->food = (int *)malloc( ((width*height)/16)*sizeof(int) );
1192
1193   create_cells( st );
1194 }
1195
1196 ENTRYPOINT void
1197 init_glcells( ModeInfo *mi )
1198 {
1199   int i, divisions;
1200   State *st=0;
1201
1202   if (!sstate) {
1203     sstate = (State *)
1204         calloc( MI_NUM_SCREENS(mi), sizeof(State) );
1205     if (!sstate) {
1206       fprintf( stderr, "%s: out of memory\n", progname );
1207       exit(1);
1208     }
1209   }
1210   st = &sstate[MI_SCREEN(mi)];
1211
1212   st->glx_context = init_GL(mi);
1213   st->cell = 0;
1214   st->num_cells = 0;
1215   st->wire = MI_IS_WIREFRAME(mi);
1216
1217   /* get settings */
1218   st->max_cells = s_maxcells;;
1219   if (st->max_cells < 50) st->max_cells = 50;
1220   if (st->max_cells > 10000) st->max_cells = 10000;
1221
1222   st->pause = s_pause;
1223   if (st->pause < 0) st->pause = 0;
1224   if (st->pause > 400) st->pause = 400;
1225   st->pause_counter = st->pause;
1226
1227   st->radius = s_radius;
1228   if (st->radius < 5) st->radius = 5;
1229   if (st->radius > 200) st->radius = 200;
1230
1231   divisions = s_quality;
1232   if (divisions < 0) divisions = 0;
1233   if (divisions > 5) divisions = 5;
1234
1235   st->num_seeds = s_seeds;
1236   if (st->num_seeds < 1) st->num_seeds = 1;
1237   if (st->num_seeds > 16) st->num_seeds = 16;
1238
1239   st->minfood = s_minfood;
1240   if (st->minfood < 0) st->minfood = 0;
1241   if (st->minfood > 1000) st->minfood = 1000;
1242
1243   st->maxfood = s_maxfood;
1244   if (st->maxfood < 0) st->maxfood = 0;
1245   if (st->maxfood > 1000) st->maxfood = 1000;
1246
1247   if (st->maxfood < st->minfood) st->maxfood = st->minfood+1;
1248
1249   st->keep_old_cells = s_keepold;
1250
1251   st->divide_age = s_divideage;
1252   if (st->divide_age < 1) st->divide_age = 1;
1253   if (st->divide_age > 1000) st->divide_age = 1000;
1254
1255   st->move_dist = s_min_dist;
1256   if (st->move_dist < 1.0) st->move_dist = 1.0;
1257   if (st->move_dist > 3.0) st->move_dist = 3.0;
1258   st->move_dist *= st->radius;
1259
1260   for (i=0; i<NUM_CELL_SHAPES; ++i) st->cell_list[i] = -1;
1261   st->nucleus_list = -1;
1262   st->food = 0;
1263
1264   st->sphere = create_sphere( st, divisions );
1265   st->disturbance =
1266       (double *) malloc( st->sphere->num_vertex*sizeof(double) );
1267   for (i=0; i<st->sphere->num_vertex; ++i) {
1268     st->disturbance[i] =
1269         0.05-((double)random()/(double)RAND_MAX*0.1);
1270   }
1271
1272   create_nucleus_texture( st );
1273
1274   reshape_glcells (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1275 }
1276
1277 ENTRYPOINT void
1278 draw_glcells( ModeInfo *mi )
1279 {
1280   State *st = &sstate[MI_SCREEN(mi)];
1281   Display *dpy = MI_DISPLAY(mi);
1282   Window window = MI_WINDOW(mi);
1283
1284   if (!st->glx_context) return;
1285
1286   glXMakeCurrent( MI_DISPLAY(mi), MI_WINDOW(mi),
1287                   *(st->glx_context) );
1288
1289   mi->polygon_count = render( st );
1290
1291   if (mi->fps_p) do_fps (mi);
1292
1293   glFinish();
1294   glXSwapBuffers( dpy, window );
1295 }
1296
1297 ENTRYPOINT void
1298 release_glcells( ModeInfo *mi )
1299 {
1300   int i;
1301   State *st  = &sstate[MI_SCREEN(mi)];
1302
1303   /* nuke everything before exit */
1304   if (st->sphere) free_Object( st->sphere );
1305   if (st->food)   free( st->food );
1306   for (i=0; i<NUM_CELL_SHAPES; ++i) {
1307     if (st->cell_list[i] != -1) {
1308       glDeleteLists( st->cell_list[i], 1 );
1309     }
1310   }
1311   if (st->cell) free( st->cell );
1312   free( st->disturbance );
1313   glDeleteTextures( 1, &st->texture_name );
1314   free( st->texture );
1315 }
1316
1317 XSCREENSAVER_MODULE( "GLCells", glcells )