path: root/hacks/glx/deepstars.c

/* xscreensaver, Copyright (c) 2019 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

#ifdef STANDALONE
#define DEFAULTS	"*delay:			30000   \n"	\
					"*showFPS:			False   \n" \
					"*suppressRotationAnimation: True\n" \

# define release_deepstars 0
# include "xlockmore.h"				/* from the xscreensaver distribution */
#else  /* !STANDALONE */
# include "xlock.h"					/* from the xlockmore distribution */
#endif /* !STANDALONE */

#ifdef USE_GL /* whole file */

#include "sphere.h"
#include "gltrackball.h"

#define DEF_SPEED "1.0"
#define DEF_SMEAR "1.0"
#define SMEAR_BASE 400
#define SPEED_BASE 0.02

#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))

#undef BELLRAND
#define BELLRAND(n) ((frand((n)) + frand((n)) + frand((n))) / 3)

static GLfloat speed_arg, smear_arg;

static XrmOptionDescRec opts[] = {
  {"-speed",  ".speed",  XrmoptionSepArg, 0 },
  {"-smear",  ".smear",  XrmoptionSepArg, 0 },
};

static argtype vars[] = {
  {&speed_arg, "speed" ,"Speed", DEF_SPEED, t_Float},
  {&smear_arg, "smear" ,"Smear", DEF_SMEAR, t_Float},
};

ENTRYPOINT ModeSpecOpt deepstars_opts = {countof(opts), opts, countof(vars), vars, NULL};

#ifdef USE_MODULES
ModStruct   deepstars_description =
{"deepstars", "init_deepstars", "draw_deepstars", NULL,
 "draw_deepstars", "init_deepstars", "free_deepstars", &deepstars_opts,
 1000, 1, 2, 1, 4, 1.0, "",
 "Animates texture mapped sphere (deepstars)", 0, NULL};
#endif

typedef struct {
  GLfloat *colors;
  GLuint starlist, groundlist;
  int ncolors, starcount, groundcount;
  GLXContext *glx_context;
  GLfloat z, latitude, facing;
  int smear, dsmear;
  trackball_state *trackball;
  Bool button_down_p;
} starstruct;

static starstruct *deepstarss = NULL;


ENTRYPOINT void
reshape_deepstars (ModeInfo *mi, int width, int height)
{
  starstruct *gp = &deepstarss[MI_SCREEN(mi)];
  GLfloat h = (GLfloat) height / (GLfloat) width;

  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *gp->glx_context);

  glViewport(0, 0, (GLint) width, (GLint) height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glFrustum(-1.0, 1.0, -h, h, 5.0, 200.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef(0.0, 0.0, -40);

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}


ENTRYPOINT Bool
deepstars_handle_event (ModeInfo *mi, XEvent *event)
{
  starstruct *gp = &deepstarss[MI_SCREEN(mi)];

  /* Neutralize any horizontal motion, and flip Y */
  GLfloat rot = current_device_rotation();
  Bool rotp = ((rot >  45 && rot <  135) ||
               (rot < -45 && rot > -135));

  if (event->xany.type == ButtonPress ||
      event->xany.type == ButtonRelease)
    {
      if (rotp)
        {
          event->xbutton.y = MI_HEIGHT(mi) / 2;
          event->xbutton.x = MI_WIDTH(mi) - event->xbutton.x;
        }
      else
        {
          event->xbutton.x = MI_WIDTH(mi) / 2;
          event->xbutton.y = MI_HEIGHT(mi) - event->xbutton.y;
        }
    }
  else if (event->xany.type == MotionNotify)
    {
      if (rotp)
        {
          event->xmotion.y = MI_HEIGHT(mi) / 2;
          event->xmotion.x = MI_WIDTH(mi) - event->xmotion.x;
        }
      else
        {
          event->xmotion.x = MI_WIDTH(mi) / 2;
          event->xmotion.y = MI_HEIGHT(mi) - event->xmotion.y;
        }
    }

  if (gltrackball_event_handler (event, gp->trackball,
                                 MI_WIDTH (mi), MI_HEIGHT (mi),
                                 &gp->button_down_p))
    return True;
  else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
    {
      if (gp->smear <= 1)
        gp->dsmear = 1;
      else
        gp->dsmear = gp->smear = 0;
      return True;
    }

  return False;
}


ENTRYPOINT void
init_deepstars (ModeInfo * mi)
{
  starstruct *gp;
  int screen = MI_SCREEN(mi);

  int i, j, k;
  int width  = MI_WIDTH(mi);
  int height = MI_HEIGHT(mi);
  int size = (width > height ? width : height);
  int nstars = size * size / 80;
  int max_size = 3;
  GLfloat inc = 0.5;
  int sizes = max_size / inc;
  GLfloat scale = 1;

  MI_INIT (mi, deepstarss);
  gp = &deepstarss[screen];

  if ((gp->glx_context = init_GL(mi)) != NULL) {
	reshape_deepstars(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
  }

# ifdef HAVE_MOBILE
  scale *= 3;
  nstars /= 3;
# else /* !HAVE_MOBILE */
  if (MI_WIDTH(mi) > 2560) {  /* Retina displays */
    scale *= 2;
    nstars /= 2;
  }
# endif /* !HAVE_MOBILE */


  gp->trackball = gltrackball_init (True);

  gp->latitude = 10 + frand(70);
  gp->facing = 10 * (frand(1.0)-0.5);

  /* Only need a small number of distinct star colors, and we have one
     display list for each color, so we can modify the alpha. 
   */
  gp->ncolors = 16;
  gp->colors = (GLfloat *) malloc (4 * gp->ncolors * sizeof(*gp->colors));

  for (i = 0; i < gp->ncolors; i++)
    {
      GLfloat d = 0.1;
      GLfloat r = 0.15 + frand(0.3);
      GLfloat g = r + frand(d) - d;
      GLfloat b = r + frand(d) - d;
      gp->colors[i*4+0] = r;
      gp->colors[i*4+1] = g;
      gp->colors[i*4+2] = b;
      gp->colors[i*4+3] = 1;
    }

  gp->starcount = nstars / gp->ncolors;
  gp->starlist = glGenLists(gp->ncolors);
  for (i = 0; i < gp->ncolors; i++)
    {
      glNewList (gp->starlist + i, GL_COMPILE);
      for (j = 1; j <= sizes; j++)
        {
          glPointSize (inc * j * scale);
          glBegin (GL_POINTS);
          for (k = 0; k < gp->starcount / sizes; k++)
            {
              GLfloat x = frand(1)-0.5;
              GLfloat y = frand(1)-0.5;
              GLfloat z = ((random() & 1)
                           ? frand(1)-0.5
                           : (BELLRAND(1)-0.5)/20);   /* milky way */
              GLfloat d = sqrt (x*x + y*y + z*z);
              x /= d;
              y /= d;
              z /= d;
              glVertex3f (x, y, z);
            }
          glEnd();
        }
      glEndList();
    }

  glDisable (GL_BLEND);
  gp->groundlist = glGenLists(1);
  glNewList(gp->groundlist, GL_COMPILE);
  {
    GLfloat inc = 0.5;
    glColor3f (0.02, 0.02, 0.05);
    glBegin (GL_QUAD_STRIP);
    gp->groundcount = 50;
    for (i = 0; i <= gp->groundcount; i++)
      {
        glVertex3f (i / (GLfloat) gp->groundcount, 0, 0);
        glVertex3f (i / (GLfloat) gp->groundcount, inc, 0);
        inc += 0.1 * (frand(1.0) - 0.5);
      }
    glEnd();
  }
  glEndList();
}


ENTRYPOINT void
draw_deepstars (ModeInfo * mi)
{
  starstruct *gp = &deepstarss[MI_SCREEN(mi)];
  Display *dpy = MI_DISPLAY(mi);
  Window window = MI_WINDOW(mi);
  int smear_change = 800;
  int sky_scale = 60;
  int i, j;

  if (!gp->glx_context)
	return;

  glDrawBuffer(GL_BACK);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glXMakeCurrent (dpy, window, *gp->glx_context);

  mi->polygon_count = 0;

  glEnable (GL_LINE_SMOOTH);
  glEnable (GL_POINT_SMOOTH);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_CULL_FACE);

  glPushMatrix();

  gltrackball_rotate (gp->trackball);

  /* At the equator, Polaris is on the horizon. In the Arctic, overhead. */
  glRotatef (180 - gp->latitude, 1, 0, 0);
  glRotatef (gp->facing, 0, 1, 0);

  if (gp->dsmear == 0 && !(random() % smear_change))
    gp->dsmear = 1;
  else if (gp->smear == SMEAR_BASE * smear_arg && !(random() % smear_change))
    gp->dsmear = -1;

  if (! gp->button_down_p)
    gp->smear += gp->dsmear;
  if (gp->smear < 1) gp->smear = 1;
  else if (gp->smear > SMEAR_BASE * smear_arg)
    gp->smear = SMEAR_BASE * smear_arg;

  if (!gp->button_down_p)
    gp->z -= SPEED_BASE * speed_arg;

  glEnable (GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  for (i = 0; i < gp->smear; i++)
    {
      GLfloat alpha = 1 - (i / (GLfloat) gp->smear);

      glPushMatrix();

      glRotatef (gp->z - (-i * SPEED_BASE * speed_arg), 0, 0, 1);

# if 0
      if (i == 0)
        {
          glBegin(GL_LINES);
          glVertex3f(0,0,0); glVertex3f(0,0,-3);
          glVertex3f(0,-1,0); glVertex3f(0,1,0);
          glVertex3f(-1,0,0); glVertex3f(1,0,0);
          glEnd();

          glPushMatrix();
          glRotatef (90, 1, 0, 0);
          glScalef (sky_scale, sky_scale, sky_scale);
          mi->polygon_count += unit_sphere (12, 24, 1);
          glPopMatrix();
        }
# endif

      glRotatef (50, 1, 0, 0);  /* Tilt milky way */
      glScalef (sky_scale, sky_scale, sky_scale);

      for (j = 0; j < gp->ncolors; j++)
        {
          gp->colors[j*4+3] = alpha;
          glColor4fv (&gp->colors[j*4]);
          glCallList (gp->starlist + j);
          mi->polygon_count += gp->starcount;
        }
      glPopMatrix();
    }

  glPopMatrix();

  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  {
    glLoadIdentity();

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    {
      glLoadIdentity();
      glTranslatef (-1, -1, 0);
      glScalef (2, 0.7, 1);
      glCallList (gp->groundlist);
      mi->polygon_count += gp->groundcount;
    }
    glPopMatrix();
  }
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);

  if (mi->fps_p) do_fps (mi);
  glFinish();
  glXSwapBuffers(dpy, window);
}


ENTRYPOINT void
free_deepstars (ModeInfo * mi)
{
  starstruct *gp = &deepstarss[MI_SCREEN(mi)];

  if (!gp->glx_context) return;
  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *gp->glx_context);
  if (gp->colors) free (gp->colors);
  if (glIsList(gp->groundlist))  glDeleteLists(gp->groundlist, 1);
  if (glIsList(gp->starlist))    glDeleteLists(gp->starlist, gp->ncolors);
  if (gp->trackball) gltrackball_free (gp->trackball);
}


XSCREENSAVER_MODULE ("DeepStars", deepstars)

#endif