/* cityflow, Copyright (c) 2014-2017 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.
*/
#define DEFAULTS "*delay: 20000 \n" \
"*count: 800 \n" \
"*showFPS: False \n" \
"*wireframe: False \n" \
# define release_cube 0
#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))
#include "xlockmore.h"
#include "colors.h"
#include "gltrackball.h"
#include <ctype.h>
#ifdef USE_GL /* whole file */
#define DEF_SKEW "12"
#define DEF_WAVES "6"
#define DEF_WAVE_SPEED "25"
#define DEF_WAVE_RADIUS "256"
static int texture_size = 512;
typedef struct {
GLfloat x, y, z;
GLfloat w, h, d;
GLfloat cth, sth;
} cube;
typedef struct {
int x, y;
double xth, yth;
} wave_src;
typedef struct {
int nwaves;
int radius;
int speed;
wave_src *srcs;
int *heights;
} waves;
typedef struct {
GLXContext *glx_context;
trackball_state *trackball;
Bool button_down_p;
GLuint cube_list;
int cube_polys;
int ncubes;
cube *cubes;
waves *waves;
GLfloat min_x, max_x, min_y, max_y;
int texture_width, texture_height;
int ncolors;
XColor *colors;
} cube_configuration;
static cube_configuration *ccs = NULL;
static int wave_count;
static int wave_speed;
static int wave_radius;
static int skew;
static XrmOptionDescRec opts[] = {
{"-waves", ".waves", XrmoptionSepArg, 0 },
{"-wave-speed", ".waveSpeed", XrmoptionSepArg, 0 },
{"-wave-radius", ".waveRadius", XrmoptionSepArg, 0 },
{"-skew", ".skew", XrmoptionSepArg, 0 },
};
static argtype vars[] = {
{&wave_count, "waves", "Waves", DEF_WAVES, t_Int},
{&wave_speed, "waveSpeed", "WaveSpeed", DEF_WAVE_SPEED, t_Int},
{&wave_radius,"waveRadius","WaveRadius", DEF_WAVE_RADIUS,t_Int},
{&skew, "skew", "Skew", DEF_SKEW,t_Int},
};
ENTRYPOINT ModeSpecOpt cube_opts = {
countof(opts), opts, countof(vars), vars, NULL};
ENTRYPOINT void
reshape_cube (ModeInfo *mi, int width, int height)
{
GLfloat h = (GLfloat) height / (GLfloat) width;
int y = 0;
if (width > height * 2) { /* tiny window: show middle */
height = width;
y = -height/2;
h = height / (GLfloat) width;
}
glViewport (0, y, (GLint) width, (GLint) height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* For this one it's really important to minimize the distance between
near and far. */
gluPerspective (30, 1/h, 10, 50);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( 0.0, 0.0, 30.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
}
static void
reset_colors (ModeInfo *mi)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
make_smooth_colormap (0, 0, 0,
cc->colors, &cc->ncolors,
False, 0, False);
if (! MI_IS_WIREFRAME(mi))
glClearColor (cc->colors[0].red / 65536.0,
cc->colors[0].green / 65536.0,
cc->colors[0].blue / 65536.0,
1);
}
static void
tweak_cubes (ModeInfo *mi)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
int i;
for (i = 0; i < cc->ncubes; i++)
{
cube *cube = &cc->cubes[i];
cube->x += (frand(2)-1)*0.01;
cube->y += (frand(2)-1)*0.01;
cube->z += (frand(2)-1)*0.01;
}
}
ENTRYPOINT Bool
cube_handle_event (ModeInfo *mi, XEvent *event)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
/* Neutralize any vertical motion */
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.x = MI_WIDTH(mi) / 2;
else
event->xbutton.y = MI_HEIGHT(mi) / 2;
}
else if (event->xany.type == MotionNotify)
{
if (rotp)
event->xmotion.x = MI_WIDTH(mi) / 2;
else
event->xmotion.y = MI_HEIGHT(mi) / 2;
}
if (gltrackball_event_handler (event, cc->trackball,
MI_WIDTH (mi), MI_HEIGHT (mi),
&cc->button_down_p))
return True;
else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
{
reset_colors (mi);
tweak_cubes (mi);
gltrackball_reset (cc->trackball, 0, 0);
return True;
}
return False;
}
/* Waves.
Adapted from ../hacks/interference.c by Hannu Mallat.
*/
static void
init_wave (ModeInfo *mi)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
waves *ww;
int i;
cc->waves = ww = (waves *) calloc (sizeof(*cc->waves), 1);
ww->nwaves = wave_count;
ww->radius = wave_radius;
ww->speed = wave_speed;
ww->heights = (int *) calloc (sizeof(*ww->heights), ww->radius);
ww->srcs = (wave_src *) calloc (sizeof(*ww->srcs), ww->nwaves);
for (i = 0; i < ww->radius; i++)
{
float max = (cc->ncolors * (ww->radius - i) / (float) ww->radius);
ww->heights[i] = ((max + max * cos(i / 50.0)) / 2.0);
}
for (i = 0; i < ww->nwaves; i++)
{
ww->srcs[i].xth = frand(2.0) * M_PI;
ww->srcs[i].yth = frand(2.0) * M_PI;
}
cc->texture_width = texture_size;
cc->texture_height = texture_size;
}
static int
interference_point (cube_configuration *cc, int x, int y)
{
/* Compute the effect of the waves on a pixel. */
waves *ww = cc->waves;
int result = 0;
int i;
for (i = 0; i < ww->nwaves; i++)
{
int dx = x - ww->srcs[i].x;
int dy = y - ww->srcs[i].y;
int dist = sqrt (dx*dx + dy*dy);
result += (dist >= ww->radius ? 0 : ww->heights[dist]);
}
result *= 0.4;
if (result > 255) result = 255;
return result;
}
static void
interference (ModeInfo *mi)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
waves *ww = cc->waves;
int i;
/* Move the wave origins around
*/
for (i = 0; i < ww->nwaves; i++)
{
ww->srcs[i].xth += (ww->speed / 1000.0);
if (ww->srcs[i].xth > 2*M_PI)
ww->srcs[i].xth -= 2*M_PI;
ww->srcs[i].yth += (ww->speed / 1000.0);
if (ww->srcs[i].yth > 2*M_PI)
ww->srcs[i].yth -= 2*M_PI;
ww->srcs[i].x = (cc->texture_width/2 +
(cos (ww->srcs[i].xth) *
cc->texture_width / 2));
ww->srcs[i].y = (cc->texture_height/2 +
(cos (ww->srcs[i].yth) *
cc->texture_height / 2));
}
}
/* qsort comparator for sorting cubes by y position */
static int
cmp_cubes (const void *aa, const void *bb)
{
const cube *a = (cube *) aa;
const cube *b = (cube *) bb;
return ((int) (b->y * 10000) -
(int) (a->y * 10000));
}
ENTRYPOINT void
init_cube (ModeInfo *mi)
{
int i;
cube_configuration *cc;
MI_INIT (mi, ccs);
cc = &ccs[MI_SCREEN(mi)];
if ((cc->glx_context = init_GL(mi)) != NULL) {
reshape_cube (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
}
cc->trackball = gltrackball_init (False);
cc->ncolors = 256;
cc->colors = (XColor *) calloc(cc->ncolors, sizeof(XColor));
reset_colors (mi);
init_wave (mi);
cc->ncubes = MI_COUNT (mi);
if (cc->ncubes < 1) cc->ncubes = 1;
cc->cubes = (cube *) calloc (sizeof(cube), cc->ncubes);
for (i = 0; i < cc->ncubes; i++)
{
/* Set the size to roughly cover a 2x2 square on average. */
GLfloat scale = 1.8 / sqrt (cc->ncubes);
cube *cube = &cc->cubes[i];
double th = -(skew ? frand(skew) : 0) * M_PI / 180;
cube->x = (frand(1)-0.5);
cube->y = (frand(1)-0.5);
cube->z = frand(0.12);
cube->cth = cos(th);
cube->sth = sin(th);
cube->w = scale * (frand(1) + 0.2);
cube->d = scale * (frand(1) + 0.2);
if (cube->x < cc->min_x) cc->min_x = cube->x;
if (cube->y < cc->min_y) cc->min_y = cube->y;
if (cube->x > cc->max_x) cc->max_x = cube->x;
if (cube->y > cc->max_y) cc->max_y = cube->y;
}
/* Sorting by depth improves frame rate slightly. With 6000 polygons we get:
3.9 FPS unsorted;
3.1 FPS back to front;
4.3 FPS front to back.
*/
qsort (cc->cubes, cc->ncubes, sizeof(*cc->cubes), cmp_cubes);
}
static void
animate_cubes (ModeInfo *mi)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
int i;
for (i = 0; i < cc->ncubes; i++)
{
cube *cube = &cc->cubes[i];
GLfloat fx = (cube->x - cc->min_x) / (cc->max_x - cc->min_x);
GLfloat fy = (cube->y - cc->min_y) / (cc->max_y - cc->min_y);
int x = (int) (cc->texture_width * fx) % cc->texture_width;
int y = (int) (cc->texture_height * fy) % cc->texture_height;
unsigned char v = interference_point (cc, x, y);
cube->h = cube->z + (v / 256.0 / 2.5) + 0.1;
}
}
ENTRYPOINT void
draw_cube (ModeInfo *mi)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
int wire = MI_IS_WIREFRAME(mi);
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
int i;
if (!cc->glx_context)
return;
mi->polygon_count = 0;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *cc->glx_context);
interference (mi);
animate_cubes (mi);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
/* glEnable (GL_POLYGON_OFFSET_FILL); */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
glRotatef(current_device_rotation(), 0, 0, 1);
gltrackball_rotate (cc->trackball);
glRotatef (-180, 1, 0, 0);
{
GLfloat s = 15;
glScalef (s, s, s);
}
glRotatef (-90, 1, 0, 0);
glTranslatef (-0.18, 0, -0.18);
glRotatef (37, 1, 0, 0);
glRotatef (20, 0, 0, 1);
glScalef (2.1, 2.1, 2.1);
/* Position lights after device rotation. */
if (!wire)
{
static const GLfloat pos[4] = {0.0, 0.25, -1.0, 0.0};
static const GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0};
static const GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
}
glBegin (wire ? GL_LINES : GL_QUADS);
for (i = 0; i < cc->ncubes; i++)
{
cube *cube = &cc->cubes[i];
GLfloat cth = cube->cth;
GLfloat sth = cube->sth;
GLfloat x = cth*cube->x + sth*cube->y;
GLfloat y = -sth*cube->x + cth*cube->y;
GLfloat w = cube->w/2;
GLfloat h = cube->h/2;
GLfloat d = cube->d/2;
GLfloat bottom = 5;
GLfloat xw = cth*w, xd = sth*d;
GLfloat yw = -sth*w, yd = cth*d;
GLfloat color[4];
int c = cube->h * cc->ncolors * 0.7;
c %= cc->ncolors;
color[0] = cc->colors[c].red / 65536.0;
color[1] = cc->colors[c].green / 65536.0;
color[2] = cc->colors[c].blue / 65536.0;
color[3] = 1.0;
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
/* Putting this in a display list makes no performance difference. */
if (! wire)
{
glNormal3f (0, 0, -1); /* top */
glVertex3f (x+xw+xd, y+yw+yd, -h);
glVertex3f (x+xw-xd, y+yw-yd, -h);
glVertex3f (x-xw-xd, y-yw-yd, -h);
glVertex3f (x-xw+xd, y-yw+yd, -h);
mi->polygon_count++;
glNormal3f (sth, cth, 0); /* front */
glVertex3f (x+xw+xd, y+yw+yd, bottom);
glVertex3f (x+xw+xd, y+yw+yd, -h);
glVertex3f (x-xw+xd, y-yw+yd, -h);
glVertex3f (x-xw+xd, y-yw+yd, bottom);
mi->polygon_count++;
glNormal3f (cth, -sth, 0); /* right */
glVertex3f (x+xw-xd, y+yw-yd, -h);
glVertex3f (x+xw+xd, y+yw+yd, -h);
glVertex3f (x+xw+xd, y+yw+yd, bottom);
glVertex3f (x+xw-xd, y+yw-yd, bottom);
mi->polygon_count++;
# if 0 /* Omitting these makes no performance difference. */
glNormal3f (-cth, sth, 0); /* left */
glVertex3f (x-xw+xd, y-yw+yd, -h);
glVertex3f (x-xw-xd, y-yw-yd, -h);
glVertex3f (x-xw-xd, y-yw-yd, bottom);
glVertex3f (x-xw+xd, y-yw+yd, bottom);
mi->polygon_count++;
glNormal3f (-sth, -cth, 0); /* back */
glVertex3f (x-xw-xd, y-yw-yd, bottom);
glVertex3f (x-xw-xd, y-yw-yd, -h);
glVertex3f (x+xw-xd, y+yw-yd, -h);
glVertex3f (x+xw-xd, y+yw-yd, bottom);
mi->polygon_count++;
# endif
}
else
{
glNormal3f (0, 0, -1); /* top */
glVertex3f (x+xw+xd, y+yw+yd, -h);
glVertex3f (x+xw-xd, y+yw-yd, -h);
glVertex3f (x+xw-xd, y+yw-yd, -h);
glVertex3f (x-xw-xd, y-yw-yd, -h);
glVertex3f (x-xw-xd, y-yw-yd, -h);
glVertex3f (x-xw+xd, y-yw+yd, -h);
glVertex3f (x-xw+xd, y-yw+yd, -h);
glVertex3f (x+xw+xd, y+yw+yd, -h);
mi->polygon_count++;
}
}
glEnd();
glPolygonOffset (0, 0);
# if 0
glDisable(GL_DEPTH_TEST); /* Outline the playfield */
glColor3f(1,1,1);
glBegin(GL_LINE_LOOP);
glVertex3f (-0.5, -0.5, 0);
glVertex3f (-0.5, 0.5, 0);
glVertex3f ( 0.5, 0.5, 0);
glVertex3f ( 0.5, -0.5, 0);
glEnd();
# endif
glPopMatrix();
if (mi->fps_p) do_fps (mi);
glFinish();
glXSwapBuffers(dpy, window);
}
ENTRYPOINT void
free_cube (ModeInfo *mi)
{
cube_configuration *cc = &ccs[MI_SCREEN(mi)];
if (!cc->glx_context) return;
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *cc->glx_context);
if (cc->waves) {
free (cc->waves->srcs);
free (cc->waves->heights);
free (cc->waves);
}
if (cc->trackball) gltrackball_free (cc->trackball);
if (cc->cubes) free (cc->cubes);
if (cc->colors) free (cc->colors);
}
XSCREENSAVER_MODULE_2 ("Cityflow", cityflow, cube)
#endif /* USE_GL */
