raverhoop.c hydrostat.c discoball.c cubetwist.c cubestack.c \
splodesic.c hexstrut.c vigilance.c seccam.c esper.c \
razzledazzle.c ships.c peepers.c crumbler.c quickhull.c \
- maze3d.c handsy.c handsy_model.c gravitywell.c
+ maze3d.c handsy.c handsy_model.c gravitywell.c deepstars.c
OBJS = xscreensaver-gl-helper.o normals.o erase-gl.o fps-gl.o \
atlantis.o b_draw.o b_lockglue.o b_sphere.o bubble3d.o \
raverhoop.o hydrostat.o discoball.o cubetwist.o cubestack.o \
splodesic.o hexstrut.o vigilance.o seccam.o esper.o \
razzledazzle.o ships.o peepers.o crumbler.o quickhull.o \
- maze3d.o handsy.o handsy_model.o gravitywell.o
+ maze3d.o handsy.o handsy_model.o gravitywell.o deepstars.o
GL_EXES = cage gears moebius pipes sproingies stairs superquadrics \
morph3d rubik atlantis lament bubble3d glplanet pulsar \
splitflap dymaxionmap unicrud energystream raverhoop \
hydrostat discoball cubetwist cubestack splodesic \
hexstrut vigilance esper razzledazzle peepers crumbler \
- maze3d handsy gravitywell
+ maze3d handsy gravitywell deepstars
GLE_EXES = extrusion
SUID_EXES = sonar
SETCAP_EXES = sonar
discoball.man cubetwist.man cubestack.man splodesic.man \
hexstrut.man vigilance.man esper.man razzledazzle.man \
peepers.man crumbler.man maze3d.man handsy.man \
- gravitywell.man
+ gravitywell.man deepstars.man
MEN = @GL_MEN@
RETIRED_MEN = glforestfire.man
EXTRAS = README Makefile.in dxf2gl.pl vrml2gl.pl wfront2gl.pl \
gravitywell: gravitywell.o $(HACK_TRACK_OBJS)
$(CC_HACK) -o $@ $@.o $(HACK_TRACK_OBJS) $(HACK_LIBS)
+deepstars: deepstars.o $(HACK_TRACK_OBJS)
+ $(CC_HACK) -o $@ $@.o $(HACK_TRACK_OBJS) $(HACK_LIBS)
+
##############################################################################
#
# DO NOT DELETE: updated by make distdepend
dangerball.o: $(UTILS_SRC)/yarandom.h
dangerball.o: $(HACK_SRC)/xlockmoreI.h
dangerball.o: $(HACK_SRC)/xlockmore.h
+deepstars.o: ../../config.h
+deepstars.o: $(HACK_SRC)/fps.h
+deepstars.o: $(srcdir)/gltrackball.h
+deepstars.o: $(HACK_SRC)/recanim.h
+deepstars.o: $(HACK_SRC)/screenhackI.h
+deepstars.o: $(srcdir)/sphere.h
+deepstars.o: $(UTILS_SRC)/colors.h
+deepstars.o: $(UTILS_SRC)/erase.h
+deepstars.o: $(UTILS_SRC)/font-retry.h
+deepstars.o: $(UTILS_SRC)/grabscreen.h
+deepstars.o: $(UTILS_SRC)/hsv.h
+deepstars.o: $(UTILS_SRC)/resources.h
+deepstars.o: $(UTILS_SRC)/usleep.h
+deepstars.o: $(UTILS_SRC)/visual.h
+deepstars.o: $(UTILS_SRC)/yarandom.h
+deepstars.o: $(HACK_SRC)/xlockmoreI.h
+deepstars.o: $(HACK_SRC)/xlockmore.h
discoball.o: ../../config.h
discoball.o: $(HACK_SRC)/fps.h
discoball.o: $(srcdir)/gltrackball.h
--- /dev/null
+/* 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
projects / xscreensaver / commitdiff