path: root/hacks/hypercube.c

/* xscreensaver, Copyright (c) 1992-2008 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.
 *
 * This code derived from TI Explorer Lisp code by Joe Keane, Fritz Mueller,
 * and Jamie Zawinski.
 */

#include <math.h>
#include "screenhack.h"

#define POINT_COUNT 16
#define LINE_COUNT 32

#define ANGLE_SCALE 0.001

struct line_info
{
  char li_ip;
  char li_iq;
  char li_color;
  char li_pad;
};

struct point_state
{
  short old_x, old_y;
  short new_x, new_y;
};

struct hyper_state
{
  char hs_stop;
  char hs_icon;
  char hs_resize;
  char hs_redraw;
  Display *hs_display;
  Window hs_window;
  float hs_two_observer_z;
  float hs_offset_x;
  float hs_offset_y;
  float hs_unit_scale;
  int hs_delay;
  GC hs_color_gcs[8];
  GC black_gc;
#if 0
  double hs_angle_xy;
  double hs_angle_xz;
  double hs_angle_yz;
  double hs_angle_xw;
  double hs_angle_yw;
  double hs_angle_zw;
#endif
  double hs_cos_xy, hs_sin_xy;
  double hs_cos_xz, hs_sin_xz;
  double hs_cos_yz, hs_sin_yz;
  double hs_cos_xw, hs_sin_xw;
  double hs_cos_yw, hs_sin_yw;
  double hs_cos_zw, hs_sin_zw;
  double hs_ref_ax, hs_ref_ay, hs_ref_az, hs_ref_aw;
  double hs_ref_bx, hs_ref_by, hs_ref_bz, hs_ref_bw;
  double hs_ref_cx, hs_ref_cy, hs_ref_cz, hs_ref_cw;
  double hs_ref_dx, hs_ref_dy, hs_ref_dz, hs_ref_dw;
  struct point_state hs_points[POINT_COUNT];
  int roted;
};

static const struct line_info line_table[LINE_COUNT];

static const char *hypercube_defaults[] =
{
  "*observer-z:	3.0",
  "*delay: 10000",
  "*xy: 3",
  "*xz:	5",
  "*yw:	10",
  "*yz:	0",
  "*xw:	0",
  "*zw:	0",
  ".background:	black",
  ".foreground:	white",
  "*fpsSolid:	true",
  "*color0:	magenta",
  "*color3:	#FF0093",
  "*color1:	yellow",
  "*color2:	#FF9300",
  "*color4:	green",
  "*color7:	#00FFD0",
  "*color5:	#8080FF",
  "*color6:	#00D0FF",

  0
};

static XrmOptionDescRec hypercube_options [] =
{
  { "-color0",		".color0",	XrmoptionSepArg, 0 },
  { "-color1",		".color1",	XrmoptionSepArg, 0 },
  { "-color2",		".color2",	XrmoptionSepArg, 0 },
  { "-color3",		".color3",	XrmoptionSepArg, 0 },
  { "-color4",		".color4",	XrmoptionSepArg, 0 },
  { "-color5",		".color5",	XrmoptionSepArg, 0 },
  { "-color6",		".color6",	XrmoptionSepArg, 0 },
  { "-color7",		".color7",	XrmoptionSepArg, 0 },

  { "-xw",		".xw",		XrmoptionSepArg, 0 },
  { "-xy",		".xy",		XrmoptionSepArg, 0 },
  { "-xz",		".xz",		XrmoptionSepArg, 0 },
  { "-yw",		".yw",		XrmoptionSepArg, 0 },
  { "-yz",		".yz",		XrmoptionSepArg, 0 },
  { "-zw",		".zw",		XrmoptionSepArg, 0 },

  { "-observer-z",	".observer-z",	XrmoptionSepArg, 0 },
  { "-delay",		".delay",	XrmoptionSepArg, 0 },
  { 0, 0, 0, 0 }
};


static void set_sizes (struct hyper_state *hs, int width, int height);

static void *
hypercube_init (Display *dpy, Window win)
{
  XGCValues gcv;
  Colormap cmap;
  unsigned long bg_pixel;
  int delay;
  float observer_z;

  struct hyper_state *hs = (struct hyper_state *) calloc (1, sizeof(*hs));
  hs->hs_display = dpy;
  hs->hs_window = win;

  observer_z = get_float_resource (dpy, "observer-z", "Float");
  if (observer_z < 1.125)
    observer_z = 1.125;
  /* hs->hs_observer_z = observer_z; */
  hs->hs_two_observer_z = 2.0 * observer_z;

  {
    XWindowAttributes wa;
    XGetWindowAttributes (dpy, win, &wa);
    cmap = wa.colormap;
    set_sizes (hs, wa.width, wa.height);
  }

  delay = get_integer_resource (dpy, "delay", "Integer");
  hs->hs_delay = delay;

  bg_pixel = get_pixel_resource (dpy, cmap, "background", "Background");

  if (mono_p)
    {
      GC black_gc;
      unsigned long fg_pixel;
      GC white_gc;

      gcv.function = GXcopy;
      gcv.foreground = bg_pixel;
      black_gc = XCreateGC (dpy, win, GCForeground|GCFunction, &gcv);
      fg_pixel = get_pixel_resource (dpy, cmap, "foreground", "Foreground");
      gcv.foreground = fg_pixel ^ bg_pixel;
      white_gc = XCreateGC (dpy, win, GCForeground|GCFunction, &gcv);
      hs->hs_color_gcs[0] = black_gc;
      hs->hs_color_gcs[1] = white_gc;
    }
  else
    {
      int col;

      gcv.function = GXcopy;

      gcv.foreground = get_pixel_resource (dpy, cmap,
                                           "background", "Background");
      hs->black_gc = XCreateGC (dpy, win, GCForeground|GCFunction, &gcv);

      for (col = 0; col < 8; col++)
	{
	  char buffer[16];
	  unsigned long fg_pixel;
	  GC color_gc;

	  sprintf (buffer, "color%d", col);
	  fg_pixel = get_pixel_resource (dpy, cmap, buffer, "Foreground");
	  gcv.foreground = fg_pixel;
	  color_gc = XCreateGC (dpy, win, GCForeground|GCFunction, &gcv);
	  hs->hs_color_gcs[col] = color_gc;
	}
    }

  hs->hs_ref_ax = 1.0, hs->hs_ref_ay = 0.0, hs->hs_ref_az = 0.0, hs->hs_ref_aw = 0.0;
  hs->hs_ref_bx = 0.0, hs->hs_ref_by = 1.0, hs->hs_ref_bz = 0.0, hs->hs_ref_bw = 0.0;
  hs->hs_ref_cx = 0.0, hs->hs_ref_cy = 0.0, hs->hs_ref_cz = 1.0, hs->hs_ref_cw = 0.0;
  hs->hs_ref_dx = 0.0, hs->hs_ref_dy = 0.0, hs->hs_ref_dz = 0.0, hs->hs_ref_dw = 1.0;

  {
  double xy;
  double xz;
  double yz;
  double xw;
  double yw;
  double zw;
  double cos_xy, sin_xy;
  double cos_xz, sin_xz;
  double cos_yz, sin_yz;
  double cos_xw, sin_xw;
  double cos_yw, sin_yw;
  double cos_zw, sin_zw;

  xy = get_float_resource (dpy, "xy", "Float") * ANGLE_SCALE;
  xz = get_float_resource (dpy, "xz", "Float") * ANGLE_SCALE;
  yz = get_float_resource (dpy, "yz", "Float") * ANGLE_SCALE;
  xw = get_float_resource (dpy, "xw", "Float") * ANGLE_SCALE;
  yw = get_float_resource (dpy, "yw", "Float") * ANGLE_SCALE;
  zw = get_float_resource (dpy, "zw", "Float") * ANGLE_SCALE;

  cos_xy = cos (xy), sin_xy = sin (xy);
  hs->hs_cos_xy = cos_xy, hs->hs_sin_xy = sin_xy;
  cos_xz = cos (xz), sin_xz = sin (xz);
  hs->hs_cos_xz = cos_xz, hs->hs_sin_xz = sin_xz;
  cos_yz = cos (yz), sin_yz = sin (yz);
  hs->hs_cos_yz = cos_yz, hs->hs_sin_yz = sin_yz;
  cos_xw = cos (xw), sin_xw = sin (xw);
  hs->hs_cos_xw = cos_xw, hs->hs_sin_xw = sin_xw;
  cos_yw = cos (yw), sin_yw = sin (yw);
  hs->hs_cos_yw = cos_yw, hs->hs_sin_yw = sin_yw;
  cos_zw = cos (zw), sin_zw = sin (zw);
  hs->hs_cos_zw = cos_zw, hs->hs_sin_zw = sin_zw;
  }

  return hs;
}


static unsigned long
hypercube_draw (Display *dpy, Window window, void *closure)
{
  struct hyper_state *hs = (struct hyper_state *) closure;
  int this_delay = hs->hs_delay;

#ifdef HAVE_JWXYZ	/* Don't second-guess Quartz's double-buffering */
  XClearWindow (dpy, window);
#endif

    {
      int icon;
      int resize;
      char moved[POINT_COUNT];
      int redraw;
      int stop;

      icon = hs->hs_icon;
      resize = hs->hs_resize;
      if (icon || !(hs->roted | resize))
	goto skip1;

      {
	float observer_z;
	float unit_scale;
	float offset_x;
	float offset_y;
	double az, bz, cz, dz;
	double sum_z;
	double ax, bx, cx, dx;
	double sum_x;
	double ay, by, cy, dy;
	double sum_y;
	struct point_state *ps;
	int old_x;
	int old_y;
	double mul;
	double xf;
	double yf;
	int new_x;
	int new_y;
	int mov;


#define compute(as,bs,cs,ds,i) \
  az = hs->hs_ref_az; bz = hs->hs_ref_bz; cz = hs->hs_ref_cz; dz = hs->hs_ref_dz; \
  ax = hs->hs_ref_ax; bx = hs->hs_ref_bx; cx = hs->hs_ref_cx; dx = hs->hs_ref_dx; \
  ay = hs->hs_ref_ay; by = hs->hs_ref_by; cy = hs->hs_ref_cy; dy = hs->hs_ref_dy; \
  sum_z = as az bs bz cs cz ds dz; \
  observer_z = hs->hs_two_observer_z; \
  unit_scale = hs->hs_unit_scale; \
  sum_x = as ax bs bx cs cx ds dx; \
  sum_y = as ay bs by cs cy ds dy; \
  ps = &hs->hs_points[i]; \
  mul = unit_scale / (observer_z - sum_z); \
  offset_x = hs->hs_offset_x; \
  offset_y = hs->hs_offset_y; \
  old_x = ps->new_x; \
  old_y = ps->new_y; \
  xf = sum_x * mul + offset_x; \
  yf = sum_y * mul + offset_y; \
  new_x = (int)rint(xf); \
  new_y = (int)rint(yf); \
  ps->old_x = old_x; \
  ps->old_y = old_y; \
  ps->new_x = new_x; \
  ps->new_y = new_y; \
  mov = old_x != new_x || old_y != new_y; \
  moved[i] = mov;

	compute (-, -, -, -, 0);
	compute (-, -, -, +, 1);
	compute (-, -, +, -, 2);
	compute (-, -, +, +, 3);
	compute (-, +, -, -, 4);
	compute (-, +, -, +, 5);
	compute (-, +, +, -, 6);
	compute (-, +, +, +, 7);
	compute (+, -, -, -, 8);
	compute (+, -, -, +, 9);
	compute (+, -, +, -, 10);
	compute (+, -, +, +, 11);
	compute (+, +, -, -, 12);
	compute (+, +, -, +, 13);
	compute (+, +, +, -, 14);
	compute (+, +, +, +, 15);
      }

    skip1:
      icon = hs->hs_icon;
      redraw = hs->hs_redraw;
      if (icon || !(hs->roted | redraw))
	goto skip2;

      {
	int lc;
	const struct line_info *lip;
	int mono;
	Window win;

	lc = LINE_COUNT;
	lip = &line_table[0];
	mono = mono_p;
	win = hs->hs_window;

	while (--lc >= 0)
	  {
	    int ip;
	    int iq;
	    int col;
	    struct point_state *sp;
	    struct point_state *sq;
	    int mov_p;
	    int mov_q;
	    GC erase_gc;
	    GC draw_gc;
	    int p_x;
	    int p_y;
	    int q_x;
	    int q_y;

	    ip = lip->li_ip;
	    iq = lip->li_iq;
	    col = lip->li_color;
	    lip++;
	    mov_p = moved[ip];
	    mov_q = moved[iq];
	    if (!(redraw | mov_p | mov_q))
	      continue;

	    sp = &hs->hs_points[ip];
	    sq = &hs->hs_points[iq];

	    if (mono)
	      {
		erase_gc = hs->hs_color_gcs[0];
		draw_gc = hs->hs_color_gcs[1];
	      }
	    else
	      {
		erase_gc = hs->black_gc;
		draw_gc = hs->hs_color_gcs[col];
	      }

	    if (!redraw)
	      {
		p_x = sp->old_x;
		p_y = sp->old_y;
		q_x = sq->old_x;
		q_y = sq->old_y;
		XDrawLine (dpy, win, erase_gc, p_x, p_y, q_x, q_y);
	      }

	    p_x = sp->new_x;
	    p_y = sp->new_y;
	    q_x = sq->new_x;
	    q_y = sq->new_y;
	    XDrawLine (dpy, win, draw_gc, p_x, p_y, q_x, q_y);
	  }
      }

    skip2:
      stop = hs->hs_stop;
      hs->roted = 0;
      if (stop)
	goto skip3;

      hs->roted = 1;

      {
	double cos_a;
	double sin_a;
	double old_u;
	double old_v;
	double new_u;
	double new_v;

 /* If you get error messages about the following forms, and you think you're
    using an ANSI C conforming compiler, then you're mistaken.  Possibly you're
    mixing an ANSI compiler with a non-ANSI preprocessor, or vice versa.
    Regardless, your system is broken; it's not a bug in this program.
  */
#if defined(__STDC__) || defined(__ANSI_CPP__)

#define rotate(name,dim0,dim1) \
  old_u = hs->hs_ref_##name##dim0; \
  old_v = hs->hs_ref_##name##dim1; \
  new_u = old_u * cos_a + old_v * sin_a; \
  new_v = old_v * cos_a - old_u * sin_a; \
  hs->hs_ref_##name##dim0 = new_u; \
  hs->hs_ref_##name##dim1 = new_v;

#define rotates(dim0,dim1) \
  if (hs->hs_sin_##dim0##dim1 != 0) { \
    cos_a = hs->hs_cos_##dim0##dim1; \
    sin_a = hs->hs_sin_##dim0##dim1; \
    rotate(a,dim0,dim1); \
    rotate(b,dim0,dim1); \
    rotate(c,dim0,dim1); \
    rotate(d,dim0,dim1); \
  }

#else /* !__STDC__, courtesy of Andreas Luik <luik@isa.de> */

#define rotate(name,dim0,dim1) \
  old_u = hs->hs_ref_/**/name/**/dim0; \
  old_v = hs->hs_ref_/**/name/**/dim1; \
  new_u = old_u * cos_a + old_v * sin_a; \
  new_v = old_v * cos_a - old_u * sin_a; \
  hs->hs_ref_/**/name/**/dim0 = new_u; \
  hs->hs_ref_/**/name/**/dim1 = new_v;

#define rotates(dim0,dim1) \
  if (hs->hs_sin_/**/dim0/**/dim1 != 0) { \
    cos_a = hs->hs_cos_/**/dim0/**/dim1; \
    sin_a = hs->hs_sin_/**/dim0/**/dim1; \
    rotate(a,dim0,dim1); \
    rotate(b,dim0,dim1); \
    rotate(c,dim0,dim1); \
    rotate(d,dim0,dim1); \
  }

#endif /* !__STDC__ */

	rotates (x,y);
	rotates (x,z);
	rotates (y,z);
	rotates (x,w);
	rotates (y,w);
	rotates (z,w);
      }

    skip3:
      /* stop = hs->hs_stop; */
      if (stop && this_delay < 10000)
	this_delay = 10000;
    }
  return this_delay;
}


static Bool
hypercube_event (Display *dpy, Window window, void *closure, XEvent *e)
{
  struct hyper_state *hs = (struct hyper_state *) closure;
  if (e->type == ButtonPress && e->xbutton.button == 2)
    {
      hs->hs_stop = !hs->hs_stop;
      return True;
    }
  return False;
}

static void
hypercube_reshape (Display *dpy, Window window, void *closure,
                   unsigned int w, unsigned int h)
{
  struct hyper_state *hs = (struct hyper_state *) closure;
  set_sizes (hs, w, h);
  XClearWindow (dpy, window);
}


static void
set_sizes (struct hyper_state *hs, int width, int height)
{
  double observer_z;
  int min_dim;
  double var;
  double offset_x;
  double offset_y;
  double unit_scale;

  observer_z = 0.5 * hs->hs_two_observer_z;
  min_dim = width < height ? width : height;
  var = sqrt(observer_z * observer_z - 1.0);
  offset_x = 0.5 * (double)(width - 1);
  offset_y = 0.5 * (double)(height - 1);
  unit_scale = 0.4 * min_dim * var;
  hs->hs_offset_x = (float)offset_x;
  hs->hs_offset_y = (float)offset_y;
  hs->hs_unit_scale = (float)unit_scale;
}


/* data */

static const struct line_info line_table[LINE_COUNT] =
{
    { 0, 1, 0, },
    { 0, 2, 0, },
    { 1, 3, 0, },
    { 2, 3, 0, },
    { 4, 5, 1, },
    { 4, 6, 1, },
    { 5, 7, 1, },
    { 6, 7, 1, },
    { 0, 4, 4, },
    { 0, 8, 4, },
    { 4, 12, 4, },
    { 8, 12, 4, },
    { 1, 5, 5, },
    { 1, 9, 5, },
    { 5, 13, 5, },
    { 9, 13, 5, },
    { 2, 6, 6, },
    { 2, 10, 6, },
    { 6, 14, 6, },
    { 10, 14, 6, },
    { 3, 7, 7, },
    { 3, 11, 7, },
    { 7, 15, 7, },
    { 11, 15, 7, },
    { 8, 9, 2, },
    { 8, 10, 2, },
    { 9, 11, 2, },
    { 10, 11, 2, },
    { 12, 13, 3, },
    { 12, 14, 3, },
    { 13, 15, 3, },
    { 14, 15, 3, },
};

static void
hypercube_free (Display *dpy, Window window, void *closure)
{
}

XSCREENSAVER_MODULE ("HyperCube", hypercube)