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

   1 #if 0
   2 static const char sccsid[] = "@(#)b_lockglue.c  4.11 98/06/16 xlockmore";
   3 #endif
   4
   5 /*-
   6  * BUBBLE3D (C) 1998 Richard W.M. Jones.
   7  * b_lockglue.c: Glue to make this all work with xlockmore.
   8  */
   9
  10 #include "bubble3d.h"
  11
  12 /* XXX This lot should eventually be made configurable using the
  13  * options stuff below.
  14  */
  15 struct glb_config glb_config =
  16 {
  17         0,                      /* transparent_p */
  18 #if GLB_SLOW_GL
  19         2,                      /* subdivision_depth */
  20 #else
  21         3,                      /* subdivision_depth */
  22 #endif
  23         5,                      /* nr_nudge_axes */
  24         0.01,                   /* nudge_angle_factor */
  25         0.20,                   /* nudge_factor */
  26         0.1,                    /* rotation_factor */
  27         8,                      /* create_bubbles_every */
  28         8,                      /* max_bubbles */
  29         {0.7, 0.8, 0.9, 1.0},   /* p_bubble_group */
  30         0.5,                    /* max_size */
  31         0.1,                    /* min_size */
  32         0.03,                   /* max_speed */
  33         0.005,                  /* min_speed */
  34         1.5,                    /* scale_factor */
  35         -4,                     /* screen_bottom */
  36         4,                      /* screen_top */
  37         {0.0, 0.0, 0.7, 0.3}    /* bubble_colour */
  38 };
  39
  40 #ifdef STANDALONE
  41 # define DEFAULTS       "*delay:        10000   \n"     \
  42                         "*showFPS:      False   \n"
  43
  44 # define release_bubble3d 0
  45 # define bubble3d_handle_event xlockmore_no_events
  46 #include "xlockmore.h"
  47 #else
  48 #include "xlock.h"
  49 #include "vis.h"
  50 #endif
  51
  52 #ifdef USE_GL
  53
  54
  55 #define DEF_TRANSPARENT "True"
  56 #define DEF_BUBBLECOLOR "random"
  57
  58 static Bool transparent_p;
  59 static char *bubble_color_str;
  60
  61 #undef countof
  62 #define countof(x) (sizeof((x))/sizeof((*x)))
  63
  64 static XrmOptionDescRec opts[] = {
  65   { "-transparent",  ".transparent",   XrmoptionNoArg, "True" },
  66   { "+transparent",  ".transparent",   XrmoptionNoArg, "False" },
  67   { "-color",        ".bubblecolor",   XrmoptionSepArg, 0 },
  68 };
  69
  70 static argtype vars[] = {
  71   {&transparent_p,   "transparent", "Transparent", DEF_TRANSPARENT, t_Bool},
  72   {&bubble_color_str,        "bubblecolor", "BubbleColor", DEF_BUBBLECOLOR, t_String},
  73 };
  74
  75 ENTRYPOINT ModeSpecOpt bubble3d_opts = {countof(opts), opts, countof(vars), vars, NULL};
  76
  77 #ifdef USE_MODULES
  78 ModStruct   bubbles3d_description =
  79 {"bubbles3d",
  80  "init_bubble3d",
  81  "draw_bubble3d",
  82  NULL,
  83  "change_bubble3d",
  84  "init_bubble3d",
  85  "free_bubble3d",
  86  &bubble3d_opts,
  87  1000, 1, 2, 1, 64, 1.0, "",
  88  "Richard Jones's GL bubbles",
  89  0,
  90  NULL
  91 };
  92
  93 #endif /* USE_MODULES */
  94
  95 struct context {
  96         GLXContext *glx_context;
  97         void       *draw_context;
  98 };
  99
 100 static struct context *contexts = 0;
 101
 102 static void
 103 parse_color (ModeInfo *mi, const char *name, const char *s, GLfloat *a)
 104 {
 105   XColor c;
 106
 107   if (! XParseColor (MI_DISPLAY(mi), MI_COLORMAP(mi), s, &c))
 108     {
 109       fprintf (stderr, "%s: can't parse %s color %s", progname, name, s);
 110       exit (1);
 111     }
 112   a[0] = c.red   / 65536.0;
 113   a[1] = c.green / 65536.0;
 114   a[2] = c.blue  / 65536.0;
 115 }
 116
 117 static void
 118 init_colors(ModeInfo *mi)
 119 {
 120         if (strncasecmp(bubble_color_str, "auto", strlen("auto")) == 0) {
 121                 glb_config.bubble_colour[0] = ((float) (NRAND(100)) / 100.0);
 122                 glb_config.bubble_colour[1] = ((float) (NRAND(100)) / 100.0);
 123                 /* I keep more blue */
 124                 glb_config.bubble_colour[2] = ((float) (NRAND(50)) / 100.0) + 0.50;
 125         } else if (strncasecmp(bubble_color_str, "random", strlen("random")) == 0) {
 126             glb_config.bubble_colour[0] = -1.0;
 127         } else {
 128                 parse_color(mi, "bubble", bubble_color_str, glb_config.bubble_colour);
 129         }
 130 }
 131
 132 static void
 133 init(struct context *c)
 134 {
 135         glb_config.transparent_p = transparent_p;
 136         glb_sphere_init();
 137         c->draw_context = glb_draw_init();
 138 }
 139
 140 ENTRYPOINT void
 141 reshape_bubble3d(ModeInfo *mi, int width, int height)
 142 {
 143   double h = (GLfloat) height / (GLfloat) width;
 144   int y = 0;
 145
 146   if (width > height * 5) {   /* tiny window: show middle */
 147     height = width * 9/16;
 148     y = -height/2;
 149     h = height / (GLfloat) width;
 150   }
 151   glViewport(0, 0, width, height);
 152   glMatrixMode(GL_PROJECTION);
 153   glLoadIdentity();
 154   gluPerspective(45, 1/h, 3, 8);
 155   glMatrixMode(GL_MODELVIEW);
 156   glLoadIdentity();
 157   glTranslatef(0, 0, -5);
 158 }
 159
 160 static void
 161 do_display(struct context *c)
 162 {
 163         glb_draw_step(c->draw_context);
 164 }
 165
 166 ENTRYPOINT void
 167 init_bubble3d(ModeInfo * mi)
 168 {
 169         Display    *display = MI_DISPLAY(mi);
 170         Window      window = MI_WINDOW(mi);
 171         int         screen = MI_SCREEN(mi);
 172         struct context *c;
 173
 174         MI_INIT (mi, contexts);
 175         c = &contexts[screen];
 176         c->glx_context = init_GL(mi);
 177         init_colors(mi);
 178         if (c->glx_context != 0) {
 179                 init(c);
 180                 reshape_bubble3d(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 181                 do_display(c);
 182                 glFinish();
 183                 glXSwapBuffers(display, window);
 184         } else
 185                 MI_CLEARWINDOW(mi);
 186 }
 187
 188 ENTRYPOINT void
 189 draw_bubble3d(ModeInfo * mi)
 190 {
 191         struct context *c = &contexts[MI_SCREEN(mi)];
 192         Display    *display = MI_DISPLAY(mi);
 193         Window      window = MI_WINDOW(mi);
 194
 195         MI_IS_DRAWN(mi) = True;
 196
 197         if (!c->glx_context)
 198                 return;
 199
 200         glXMakeCurrent(display, window, *(c->glx_context));
 201
 202         glb_config.polygon_count = 0;
 203         glPushMatrix();
 204
 205 # ifdef HAVE_MOBILE     /* Keep it the same relative size when rotated. */
 206         {
 207           GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
 208           int o = (int) current_device_rotation();
 209           if (o != 0 && o != 180 && o != -180)
 210             glScalef (1/h, 1/h, 1/h);
 211           glRotatef(o, 0, 0, 1);
 212         }
 213 # endif
 214
 215         do_display(c);
 216         glPopMatrix();
 217         mi->polygon_count = glb_config.polygon_count;
 218
 219         if (mi->fps_p) do_fps (mi);
 220         glFinish();
 221         glXSwapBuffers(display, window);
 222 }
 223
 224 #ifndef STANDALONE
 225 ENTRYPOINT void
 226 change_bubble3d(ModeInfo * mi)
 227 {
 228         /* nothing */
 229 }
 230 #endif /* !STANDALONE */
 231
 232 ENTRYPOINT void
 233 free_bubble3d(ModeInfo * mi)
 234 {
 235   struct context *c = &contexts[MI_SCREEN(mi)];
 236   if (c->draw_context)
 237     glb_draw_end(c->draw_context);
 238 }
 239
 240 XSCREENSAVER_MODULE ("Bubble3D", bubble3d)
 241
 242 #endif /* USE_GL */