input.c

细胞自动机的一个源代码

#include "main.h"
static int prev3x, prev3y, prev2x, prev2y, prev1x, prev1y;
int crap2=0;

vec3d *vec3dsub(vec3d *a, vec3d *b, vec3d *c) {
  c->x = a->x - b->x;
  c->y = a->y - b->y;
  c->z = a->z - b->z;
  return(c);
}

double vec3ddot(vec3d *a, vec3d *b) {
  return((a->x*b->x) + (a->y*b->y) + (a->z*b->z));
}

int vec3dlpcoll(vec3d *s, double rad,
		vec3d *lp, vec3d *lv,
		double *a1, double *a2) {
  vec3d g, t, tp, tv;
  double a, b, c, d;

  vec3dsub(lp, s, &g);
  a = vec3ddot(lv, lv);
  b = 2.0*vec3ddot(lv, &g);
  c = vec3ddot(&g, &g) - (rad*rad);
  d = (b*b) - (4.0*a*c);
  if (d<eps) {
    return(0);
  } else {
    *a1 = -b + (sqrt(d)/(2.0*a));
    *a2 = -b - (sqrt(d)/(2.0*a));
  }
  return(1);
}

double min2d(double a, double b) {
  return(a<b?a:b);
}

vec3d *vec3dcross(vec3d *a, vec3d *b, vec3d *c) {
  c->x = (a->y*b->z) - (a->z*b->y);
  c->y = (a->z*b->x) - (a->x*b->z);
  c->z = (a->x*b->y) - (a->y*b->x);
  return(c);
}


vec3d *vec3dadd(vec3d *a, vec3d *b, vec3d *c) {
  c->x = a->x + b->x;
  c->y = a->y + b->y;
  c->z = a->z + b->z;
  return(c);
}

vec3d *vec3dnorm(vec3d *a) {
  vec3d tem;
  double len;

  len = sqrt(vec3ddot(a, a));
  a->x /= len;
  a->y /= len;
  a->z /= len;
  return(a);
}


void keyfunc(int key, int state) {
  action ac;
  float locwang=1.0;
  int i, j, k;
  float fx, fy, fz;
  trixd *td=NULL, *to=NULL;
  int ps[3] = {0, 0, 0}, pe[3] = {99, 99, 99};
  int p[2] = {50, 50};

  if (!td) {
    td = makedyntrixd(4, 1);
    to = makedyntrixd(4, 1);
  }

  for (i=0; i<(g_ca->dim); i++) {
    pe[i] = g_ca->d[i] - 1;
  }

  switch (state) {
  case KeyPress:

    switch (key) {

    case XK_F12:
      (*ca_update_func)(g_ca, 0, g_ca->fd-1);
      break;
      /*
    case XK_q:
      printf("quitting\n");
      exit(1);
      break;
    case XK_a:
      ca_print(g_ca);
      cas_addch(g_cas, 'a');
      break;
    case XK_b:
      printf("b\n");
      g_ca->ca[g_ca->cur][ca_point(g_ca, p)] = 1;
      p[0] = 50;
      p[1] = 50;
      g_ca->ca[g_ca->cur][ca_point(g_ca, p)] = 1;
      p[1] = 51;
      g_ca->ca[g_ca->cur][ca_point(g_ca, p)] = 1;
      p[1] = 52;
      g_ca->ca[g_ca->cur][ca_point(g_ca, p)] = 1;
      p[0] = 51;
      p[1] = 51;
      g_ca->ca[g_ca->cur][ca_point(g_ca, p)] = 1;
      break;
    case XK_n:
      //printf("updating\n");
      ca_2d_update(g_ca, ps, pe);
      break;
    case XK_comma:
      break;
    case XK_period:
      break;
    case XK_slash:
      break;
    case XK_k:
      break;
    case XK_l:
      break;
    case XK_d:
      ca_2d_print(g_ca);
      break;
    case XK_KP_Add:
      break;
    case XK_KP_Subtract:
      break;
    case XK_KP_Home:
      break;
    case XK_KP_Page_Up:
      break;
    case XK_KP_Up:
      break;
    case XK_KP_Begin:
      break;
    case XK_KP_Left:
      break;
    case XK_KP_Right:
      break;
    case XK_KP_Insert:
      break;
      */

    default:
      cas_addch(g_cas, key);
      break;

    }

    break;

  case KeyRelease:
    switch (key) {
    case XK_d:
      break;
    case XK_KP_Add:
      break;
    case XK_KP_Subtract:
      break;
    case XK_KP_Home:
      break;
    case XK_Up:
      worl.com.y+=1.0;
      break;
    case XK_Down:
      worl.com.y-=1.0;
      break;
    case XK_Right:
      worl.com.x+=1.0;
      break;
    case XK_Left:
      worl.com.x-=1.0;
      break;
    case XK_KP_Up:
      break;
    case XK_KP_Down:
      break;
    case XK_KP_Left:
      break;
    case XK_KP_Right:
      break;
    case XK_KP_Delete:
      break;
    case XK_KP_Insert:
      break;
    case XK_KP_Page_Up:
      break;
    case XK_KP_Begin:
      break;
    default:
      break;
    }
    break;
  }

}

void buttfunc(int x, int y, int type, int state) {
  static int bfi=0;

  if (!bfi) {
    bfi=1;
    prev3x = x;
    prev3y = y;
    prev2x = x;
    prev2y = y;
  }

  switch (type) {
  case ButtonPress:
    if (state==3) { //state&Button3Mask) {
      prev3x=x;
      prev3y=y;
    }
    if (state==2) { //&Button2Mask) {
      prev2x = x;
      prev2y = y;
    }
    if (state==1) { //left button
      prev1x = x;
      prev1y = y;

    }
    break;
  case ButtonRelease:
    if (state==3) { //&Button3Mask) {
      prev3x=x;
      prev3y=y;
    }
    if (state==2) { //&Button2Mask) {
      prev2x = x;
      prev2y = y;
    }
    if (state==1) {
      prev1x = x;
      prev1y = y;
    }
    break;
  default:
    break;
  }

  if (debug) {
    /* printf(" %x %x buttfunc\n", state); */
  }
}

/* always square window */
void configfunc(int x, int y) {

  glViewport(0, 0,
	     y, y);

  if (debug) {
    /* printf("new window %i %i (viewport %i %i)\n", x, y, y, y); */
  }

  worl.width = y;
  worl.height = y;

}

void motionfunc(int x, int y, int state) {
  static int mfi=0;
  float rotfac=0.5, zoomfac=0.1, pickrotfac=0.5;


  if (!mfi) {
    mfi=1;
    prev3x = x;
    prev3y = y;
    prev2x = x;
    prev2y = y;
  }

  if (state&Button3Mask) {
    worl.curwang += rotfac*(float)(x-prev3x);
    worl.curzang += rotfac*(float)(prev3y-y);

    prev3x=x;
    prev3y=y;
  }
  if (state&Button2Mask) {
    worl.zoom += zoomfac*(float)(prev2y-y);
    prev2x=x;
    prev2y=y;
  }
  if (state&Button1Mask) {

    prev1x = x;
    prev1y = y;
  }

  if (debug) {
    /* printf("%x motion\n", state); */
  }
}