开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
walker.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：29k
源码类别：

GIS编程

开发平台：

Visual C++

walker.c：源码内容
  1. #include <GL/glut.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <math.h>
  5. #include <string.h>
  6. #ifdef _WIN32
  7. #include "win32_dirent.h"
  8. /* Have to #undef LoadMenu or else Microsoft VC++ won't allow us to
  9.    redefine it. */
  10. #undef LoadMenu
  11. #else
  12. #include <dirent.h>
  13. #endif
  14. #include <assert.h>
  16. #include "walker.h"
  20. #define MAX(x,y) ((x) > (y) ? (x) : (y))
  21. #define MIN(x,y) ((x) < (y) ? (x) : (y))
  23. #define CYCLE_SIZE 100
  24. #define CYCLE_STEP 1.0/CYCLE_SIZE
  25. #define OVERSAMPLE 10
  27. #define MAX_CPOINTS 34   /* 2 end point ones and 10 in the middle */
  29. #define MAX_CSETNAMELEN 25
  31. #define NUM_JOINTS 5
  33. #define CSET_EXT ".cset"
  34. #define CSET_EXTLEN 5
  36. #include "walkviewer.h"
  39. typedef enum { CMENU_QUIT, CMENU_CURVE, CMENU_HORIZ, CMENU_RESET,
  40.                CMENU_WALK, CMENU_DONEEDIT, CMENU_SAVE, CMENU_LOAD,
  41.        CMENU_MIRROR
  42.               } CurveMenuChoices;
  44. typedef enum { WIRECUBE, SOLIDCUBE, CYLINDER1, CYLINDER2 } ModelTypes;
  46. int GuyModel = SOLIDCUBE;
  48. /***************************************************************/
  49. /*************************** GLOBALS ***************************/
  50. /***************************************************************/
  52. GLuint HorizontalList, AxesList,     /* Display lists */
  53.        CurveLists, ControlPtsLists;  /* Firsts of groups of display lists */
  55. int CurveAsPoints   =  0,    /* Display curve as points? */
  56.     DrawHorizontals =  0,    /* Draw horizontal lines?   */
  57.     EditingCurve    = -1;    /* Editing what curve, -1 means none */
  59. int CurveWindow,   /* Glut window id's to two top level windows */
  60.     GuyWindow;
  62. int MirrorLegs = 0;
  64. int CurveMenu     = -1,
  65.     CurveEditMenu = -1,
  66.     StepSizeMenu  = -1,
  67.     LoadMenu      = -1,
  68.     SaveMenu      = -1;
  70. char *CSetNames[MAX_CSETNAMELEN];
  72. int CurrentCurve = -1;  /* Curve loaded, index to CSetNames */
  74. GLfloat Walk_cycle[2][NUM_JOINTS][CYCLE_SIZE];  /* array of computed angles */
  76. int Step = CYCLE_SIZE/2;  /* Position in cycle, start in middle */
  78. float fStep = CYCLE_SIZE/2;   /* floating point for non-integer steping */
  79. float IncStep = 1.0;
  81. typedef struct ControlPts {
  82.   int numpoints;
  83.   float xcoords[MAX_CPOINTS];
  84.   float angles[MAX_CPOINTS];
  85. } tControlPts;
  87. tControlPts RotCurve[NUM_JOINTS];   /* series of cntrl points for ea joint */
  89. int Walking         = 0,     /* Guy is walking? */
  90.     ViewPerspective = 1,     /* Perspective or orthographic views */
  91.     DrawAxes        = 0;     /* Draw axes for alignment */
  93. int CurveWWidth,             /* Dimensions of curve window */
  94.     CurveWHeight;  
  96. int CurveDownBtn = -1,               /* mouse stuff, for editing curves */
  97.     WasWalking,
  98.     CurvePickedPoint = -1,
  99.     CurveLastX,
  100.     CurveLastY;
  102. int CurveWindowVisible = 1;
  105.   /* prototypes */
  106. void RedisplayBoth(void);
  107. void IncrementStep(void);
  108. void CurveCPointDrag(void);
  109. void CurveHandleMenu(int value);
  110. void StopWalking(void);
  111. void CurveHandleEditMenu(int curve);
  112. void ComputeCSetAndMakeLists(void);
  113. int MakeLoadAndSaveMenus(void);
  114. void CurveMenuInit(void);
  115. void SetWindowTitles(char *csetname);
  117. /***************************************************************/
  118. /**************************** BEZIER ***************************/
  119. /***************************************************************/
  121.   /* Matrix times a vector  dest = m*v */
  122. void MultMV(float m[3][4], float v[4], float dest[3])
  123. {
  124.   int i, j;
  126.   for (i = 0; i < 3; i++) {
  127.     dest[i] = 0;
  128.     for (j = 0; j < 4; j++)
  129.       dest[i] += m[i][j] * v[j];
  130.   }
  131. }
  133.   /* Matrix multiplication, dest = m1*m2 */
  134. void MultM(float m1[3][4], float m2[4][4], float dest[3][4])
  135. {
  136.   int i, j, k;
  138.   for (i = 0; i < 3; i++)
  139.     for (j = 0; j < 4; j++) {
  140.       dest[i][j] = 0;
  141.       for (k = 0; k < 4; k++)
  142.   dest[i][j] += (m1[i][k] * m2[k][j]);
  143.     }
  144. }
  146. void ComputeCurve(int joint)
  147. {
  148.   float prod[3][4], tm[4], pos[3];
  149.   float t = 0, tinc = (float)CYCLE_STEP/OVERSAMPLE;
  150.   int ctlpoint, i;
  151.   float BBasis[4][4] = {{-1, 3, -3, 1}, {3, -6, 3, 0},
  152.                         {-3, 3,  0, 0}, {1,  0, 0, 0}};
  153.   int lastindex, newindex;
  155.   float pointset[3][4];
  156.   for (i = 0; i < 4; i++)   /* z's are always zero, only 2-d */
  157.     pointset[2][i] = 0; 
  159.   lastindex = -1;
  160.   for(ctlpoint = 0; ctlpoint < RotCurve[joint].numpoints; ctlpoint += 3) {
  161.     t = 0;
  162.     for (i = 0; i < 4; i++)
  163.       pointset[0][i] = RotCurve[joint].xcoords[ctlpoint + i];
  164.     for (i = 0; i < 4; i++)
  165.       pointset[1][i] = RotCurve[joint].angles[ctlpoint + i];
  167.     MultM(pointset, BBasis, prod);
  169.     while (t <= 1) {
  170.       tm[0] = t*t*t;
  171.       tm[1] = t*t;
  172.       tm[2] = t;
  173.       tm[3] = 1;
  174.       MultMV(prod, tm, pos);
  175.       newindex = (int)(pos[0]*(CYCLE_SIZE-1));
  176.       if ((int)(newindex > lastindex))  {  /* go at least one */
  177. Walk_cycle[0][joint][newindex] = pos[1];
  178. lastindex++;
  179.       } 
  180.       t += tinc;
  181.     }
  182.   }
  184.   for (i = 0; i < CYCLE_SIZE; i++) {      /* copy to other leg, out-o-phase */
  185.     if (MirrorLegs)
  186.       Walk_cycle[1][joint][i] =
  187.         Walk_cycle[0][joint][i];
  188.     else
  189.       Walk_cycle[1][joint][i] =
  190.         Walk_cycle[0][joint][(i+(CYCLE_SIZE/2))%CYCLE_SIZE];
  191.   }
  192. }
  194. /***************************************************************/
  195. /************************* CURVE I/O ***************************/
  196. /***************************************************************/
  198. void FlatCSet(void)
  199. {
  200.   int joint;
  202.   for (joint = 0; joint < NUM_JOINTS; joint++) {
  203.     RotCurve[joint].numpoints = 4;
  204.     RotCurve[joint].xcoords[0] = 0.0;
  205.     RotCurve[joint].angles[0]  = 0.0;
  206.     RotCurve[joint].xcoords[1] = 0.2;
  207.     RotCurve[joint].angles[1]  = 0.0;
  208.     RotCurve[joint].xcoords[2] = 0.8;
  209.     RotCurve[joint].angles[2]  = 0.0;
  210.     RotCurve[joint].xcoords[3] = 1.0;
  211.     RotCurve[joint].angles[3]  = 0.0;
  212.   }
  213. }
  215. int ReadCSetFromFile(char *filename)
  216. {
  217.   FILE *infile = fopen(filename, "r");
  218.   int numjoints, numpoints, joint, point, mirrorlegs;
  219.   float value;
  221.   if (infile == NULL)
  222.     goto abort;
  223.   
  224.   if (!fscanf(infile, " %d", &numjoints) || numjoints != NUM_JOINTS)
  225.     goto abort;
  227.   if (!fscanf(infile, " %d", &mirrorlegs) || (mirrorlegs != 0 &&
  228.                                               mirrorlegs != 1))
  229.     goto abort;
  231.   MirrorLegs = mirrorlegs;
  233.   for (joint = 0; joint < NUM_JOINTS; joint++) {
  234.     if (!fscanf(infile, " %d", &numpoints) || numpoints < 4 || 
  235.                                               numpoints > MAX_CPOINTS)
  236.       goto abort;
  237.     RotCurve[joint].numpoints = numpoints;
  238.     for (point = 0; point < numpoints; point++) {
  239.       if (!fscanf(infile, " %f", &value))
  240. goto abort;
  241.       RotCurve[joint].xcoords[point] = value;
  242.     }
  243.     for (point = 0; point < numpoints; point++) {
  244.       if (!fscanf(infile, " %f", &value))
  245. goto abort;
  246.       RotCurve[joint].angles[point] = value;
  247.     }
  248.   }
  250.   fclose(infile);
  251.   return 0;
  253.   abort:
  254.     fclose(infile);
  255.     fprintf(stderr, "Something went wrong while reading file %sn", filename);
  256.     FlatCSet();
  257.     return -1;
  258. }
  260. void WriteCSetToFile(char *filename)
  261. {
  262.   FILE *outfile = fopen(filename, "w+");
  263.   int joint, point;
  265.   if (outfile == NULL) {
  266.     fprintf(stderr, "Error: could not create file %sn", filename);
  267.     return;
  268.   }
  270.   fprintf(outfile, "%dn", NUM_JOINTS);
  272.   fprintf(outfile, "%dn", MirrorLegs);
  274.   for (joint = 0; joint < NUM_JOINTS; joint++) {
  276.     fprintf(outfile, "%dn", RotCurve[joint].numpoints);
  278.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  279.       fprintf(outfile, "%f ", RotCurve[joint].xcoords[point]);
  280.     }
  281.     fprintf(outfile, "n");
  283.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  284.       fprintf(outfile, "%f ", RotCurve[joint].angles[point]);
  285.     }
  286.     fprintf(outfile, "n");
  287.   }
  289.   fclose(outfile);
  290. }
  292. void HandleLoadMenu(int cset)
  293. {
  294.   char filename[MAX_CSETNAMELEN + CSET_EXTLEN + 1];
  296.   if (cset == -1) {
  297.     MakeLoadAndSaveMenus();
  298.     CurveMenuInit();
  299.   } else {
  300.     (void)strcpy(filename, CSetNames[cset]);
  301.     (void)strcat(filename, CSET_EXT);
  302.     if (ReadCSetFromFile(filename) == 0) {
  303.       glutSetMenu(SaveMenu);
  304.       glutChangeToMenuEntry(1, CSetNames[cset], cset);
  305.       ComputeCSetAndMakeLists();
  306.       SetWindowTitles(CSetNames[cset]);
  307.       RedisplayBoth();
  308.     }
  309.   }
  310. }
  312. void HandleSaveMenu(int cset)
  313. {
  314.   char filename[MAX_CSETNAMELEN + CSET_EXTLEN + 1];
  316.   (void)strcpy(filename, CSetNames[cset]);
  317.   (void)strcat(filename, CSET_EXT);
  318.   WriteCSetToFile(filename);
  319.   ComputeCSetAndMakeLists();
  320.   RedisplayBoth();
  321. }
  323. int MakeLoadAndSaveMenus(void)
  324. {
  325.   DIR *dirp = opendir(".");
  326.   struct dirent *direntp;
  327.   int csetnum = 0;
  328.   char *newcsetname;
  330.   if (LoadMenu != -1)
  331.     glutDestroyMenu(LoadMenu);
  332.   if (SaveMenu != -1)
  333.     glutDestroyMenu(SaveMenu);
  335.   SaveMenu = glutCreateMenu(HandleSaveMenu);
  336.   LoadMenu = glutCreateMenu(HandleLoadMenu);
  338.   if (dirp == NULL) {
  339.     fprintf(stderr, "Error opening current dir in MakeLoadAndSaveMenusn");
  340.     return(0);
  341.   }
  343.   while ((direntp = readdir(dirp)) != NULL) {
  344.     char *ext = direntp->d_name + (strlen(direntp->d_name) - CSET_EXTLEN);
  345.     if (!strcmp(ext, CSET_EXT)) {
  346.       newcsetname = malloc(strlen(direntp->d_name) - CSET_EXTLEN + 1);
  347.       strncpy(newcsetname, direntp->d_name,
  348.       strlen(direntp->d_name) - CSET_EXTLEN);
  349.       newcsetname[strlen(direntp->d_name) - CSET_EXTLEN] = 0;
  350.       CSetNames[csetnum] = newcsetname;
  351.       glutAddMenuEntry(newcsetname, csetnum++);
  352.     }
  353.   }
  354.   closedir(dirp);
  355.   glutSetMenu(LoadMenu);
  356.   glutAddMenuEntry("-> Rescan Directory <-", -1);
  357.   glutSetMenu(SaveMenu);
  358.   CSetNames[csetnum] = "NewCurve0";
  359.   glutAddMenuEntry("NewCurve0", csetnum++);
  360.   CSetNames[csetnum] = "NewCurve1";
  361.   glutAddMenuEntry("NewCurve1", csetnum++);
  362.   CSetNames[csetnum] = "NewCurve2";
  363.   glutAddMenuEntry("NewCurve2", csetnum++);
  365.   return (csetnum - 2);  /* just indicate curves in Load menu */
  366. }
  369. /***************************************************************/
  370. /********************* DISPLAY LISTS ***************************/
  371. /***************************************************************/
  374. void MakeCurveList(int joint)
  375. {
  376.   int i;
  378.   glNewList(CurveLists+joint, GL_COMPILE);
  379.   glColor3f(1, 1, 1);
  380.   for (i = 0; i < CYCLE_SIZE; i++) {
  381.     glVertex3f((GLfloat)i/CYCLE_SIZE, Walk_cycle[0][joint][i]/180, 0);
  382.   }
  383.   glEndList();
  384. }
  386. void MakeCPointList(int joint)
  387. {
  388.   int point;
  389.  
  390.   glNewList(ControlPtsLists+joint, GL_COMPILE);
  392.     glColor3f(0, 0.4, 0);
  393.     glBegin(GL_LINE_STRIP);
  394.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  395.       if (!((point-2) % 3)) {
  396.         glEnd();
  397.         glBegin(GL_LINE_STRIP);
  398.       }
  399.       glVertex3f(RotCurve[joint].xcoords[point],
  400.          (RotCurve[joint].angles[point])/180.0, 0.0);
  401.     }
  402.     glEnd();
  404.     glBegin(GL_POINTS);
  405.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  406.       if (point % 3)
  407.         glColor3f(0, 0.7, 0);
  408.       else
  409.         glColor3f(0.7, 0.0, 0);
  410.       glVertex3f(RotCurve[joint].xcoords[point],
  411.          (RotCurve[joint].angles[point])/180, 0);
  412.     }
  413.     glEnd();
  415.   glEndList();
  416. }
  418. void MakeJointLists(int joint)
  419. {
  420.   MakeCurveList(joint);
  421.   MakeCPointList(joint);
  422. }
  425. void ComputeCSetAndMakeLists(void)
  426. {
  427.   int joint;
  429.   for(joint = 0; joint < NUM_JOINTS; joint++) {
  430.     ComputeCurve(joint);
  431.     MakeJointLists(joint);
  432.   }
  433. }
  435. void MakeLists(void)
  436. {
  437.   HorizontalList = glGenLists(1);
  438.   glNewList(HorizontalList, GL_COMPILE);
  439.   {
  440.     float line1 = 25.0/180,
  441.           line2 = 35.0/180,
  442.           line3 = 45.0/180;
  443.     glColor3f(0, 0, 0.7);
  444.     glPushAttrib(GL_ENABLE_BIT);
  445.     glEnable(GL_LINE_STIPPLE);
  446.     glBegin(GL_LINES);
  447.       glVertex3f(0, 0, 0.5);
  448.       glVertex3f(1, 0, 0.5);
  449.       glVertex3f(0, line1, 0.5);  glVertex3f(1, line1, 0.5);
  450.       glVertex3f(0, -line1, 0.5); glVertex3f(1, -line1, 0.5);
  451.       glVertex3f(0, line2, 0.5);  glVertex3f(1, line2, 0.5);
  452.       glVertex3f(0, -line2, 0.5); glVertex3f(1, -line2, 0.5);
  453.       glVertex3f(0, line3, 0.5);  glVertex3f(1, line3, 0.5);
  454.       glVertex3f(0, -line3, 0.5); glVertex3f(1, -line3, 0.5);
  455.     glEnd();
  456.     glPopAttrib();
  457.   }
  458.   glEndList();
  461.   CurveLists = glGenLists(NUM_JOINTS);
  462.   assert(CurveLists != 0);
  464.   ControlPtsLists = glGenLists(NUM_JOINTS);
  465.   assert(ControlPtsLists != 0);
  467.   ComputeCSetAndMakeLists();
  468. }
  470. /***************************************************************/
  471. /********************* curve WINDOW ****************************/
  472. /***************************************************************/
  474. void CurveReshape(int w, int h)
  475. {
  476.   glViewport(0,0,w,h);
  477.   CurveWWidth = w; 
  478.   CurveWHeight = h;
  479.   glFlush();
  480. }
  482. void CurveDisplay(void)
  483. {
  484.   int joint, otherlegstep;
  486.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  488.   glPushMatrix();
  489.   glTranslatef(0, 0.5, 0);
  491.   for (joint = NUM_JOINTS-1; joint >= 0; joint--) {
  493.     if (DrawHorizontals) 
  494.       glCallList(HorizontalList);
  496.     (CurveAsPoints) ?
  497.     glBegin(GL_POINTS) :
  498.     glBegin(GL_LINE_STRIP);
  499.       glCallList(CurveLists+joint);
  500.     glEnd();
  502.     if (joint == EditingCurve) { 
  503.       glPointSize(5.0);
  504.       glCallList(ControlPtsLists+EditingCurve);
  505.       glPointSize(1.0);
  506.     }
  507.   glTranslatef(0, 1, 0);
  508.   }
  510.   glPopMatrix();
  512.   otherlegstep = (Step+50) % CYCLE_SIZE;
  513.     /* draw vertical line */
  514.   glColor3f(1, 1, 1);
  515.   glBegin(GL_LINES);
  516.     glVertex3f((GLfloat)Step/CYCLE_SIZE, 0, 0);
  517.     glVertex3f((GLfloat)Step/CYCLE_SIZE, NUM_JOINTS, 0);
  518.     if (!MirrorLegs) {
  519.       glVertex3f((GLfloat)otherlegstep/CYCLE_SIZE, 0, 0);
  520.       glVertex3f((GLfloat)otherlegstep/CYCLE_SIZE, NUM_JOINTS, 0);
  521.     }
  522.   glEnd();
  524.   glFlush();
  525.   glutSwapBuffers();
  526. }
  529. void CurveGLInit(void)
  530. {
  531.   glMatrixMode(GL_PROJECTION);
  532.   glLoadIdentity();
  533.   glOrtho(0,1,0,NUM_JOINTS,1,-1);
  535.   glMatrixMode(GL_MODELVIEW);
  536.   glLoadIdentity();
  538.   glLineStipple(1, 0x00FF);
  540.   glEnable(GL_DEPTH_TEST);
  541.   glDepthFunc(GL_LEQUAL);
  544.   glFlush();
  546. } 
  549. /* ARGSUSED2 */
  550. void CurveHandleButton(int button, int state, int x, int y)
  551. {
  552.   if (button == GLUT_RIGHT_BUTTON )
  553.     return;
  555.   if (state == GLUT_DOWN && CurveDownBtn == -1) {
  556.     if (button == GLUT_MIDDLE_BUTTON)
  557.       CurveHandleMenu(CMENU_WALK);
  558.     else
  559.       fStep = Step = (int)((float)x/glutGet(GLUT_WINDOW_WIDTH) * CYCLE_SIZE);
  560.       
  561.     CurveDownBtn = button;
  563.     WasWalking = Walking;
  564.     StopWalking();
  565.     RedisplayBoth();
  566.   } else if (button == CurveDownBtn) {
  567.     CurveDownBtn = -1;
  568.     if (WasWalking) {
  569.       Walking = 1;
  570.       agvSetAllowIdle(0);
  571.       glutIdleFunc(IncrementStep);
  572.     }
  573.   }
  574. }
  576. float CurveEditConstrain(float fx)
  577. {
  578.   if (CurvePickedPoint == 0)
  579.     fx = 0;
  580.   else if (CurvePickedPoint == RotCurve[EditingCurve].numpoints-1)
  581.     fx = 1;
  582.   else if (!(CurvePickedPoint % 3)) {  /* is a pivot */
  583.     fx = MAX(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint-1]);
  584.     fx = MIN(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint+1]);   
  585.     fx = MAX(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint-3]);
  586.     fx = MIN(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint+3]);       
  587.   } else if (!((CurvePickedPoint - 1) % 3)) {   /* is right slope */
  588.     fx = MAX(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint-1]);
  589.   } else {
  590.     fx = MIN(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint+1]);
  591.   } 
  592.   return fx;
  593. }
  595. void RemovePoint(int pt)
  596. {
  597.   int i;
  599.   for (i = pt - 1; i < RotCurve[EditingCurve].numpoints; i++) {
  600.     RotCurve[EditingCurve].xcoords[i] = RotCurve[EditingCurve].xcoords[i+3];
  601.     RotCurve[EditingCurve].angles[i]  = RotCurve[EditingCurve].angles[i+3];
  602.   }
  603.   RotCurve[EditingCurve].numpoints -= 3;
  604. }
  606. void AddPoint(float fx)
  607. {
  608.   int i, j;
  610.   if (fx < 0.05 || fx > 0.95 || RotCurve[EditingCurve].numpoints + 3 >=
  611.                                 MAX_CPOINTS)
  612.     return;
  614.   for (i = 3; i < RotCurve[EditingCurve].numpoints; i += 3) {
  615.     if (fx < RotCurve[EditingCurve].xcoords[i]) {
  616.       for (j = RotCurve[EditingCurve].numpoints + 2; j > i + 1; j--) { 
  617.         RotCurve[EditingCurve].xcoords[j] =
  618.                 RotCurve[EditingCurve].xcoords[j-3];
  619.         RotCurve[EditingCurve].angles[j] =
  620.                 RotCurve[EditingCurve].angles[j-3];
  621.       }
  622.     RotCurve[EditingCurve].xcoords[i]   = fx;
  623.     RotCurve[EditingCurve].angles[i]    =
  624.       Walk_cycle[0][EditingCurve][(int)(fx*CYCLE_SIZE)];
  625.     RotCurve[EditingCurve].xcoords[i-1] = fx - 0.05;
  626.     RotCurve[EditingCurve].angles[i-1]  =
  627.       Walk_cycle[0][EditingCurve][(int)((fx-0.05)*CYCLE_SIZE)];
  628.     RotCurve[EditingCurve].xcoords[i+1] = fx + 0.05;
  629.     RotCurve[EditingCurve].angles[i+1]  = 
  630.       Walk_cycle[0][EditingCurve][(int)((fx+0.05)*CYCLE_SIZE)];
  631.     RotCurve[EditingCurve].numpoints += 3;
  632.     break;
  633.     }
  634.   }  
  635. }
  638. void CurveEditHandleButton(int button, int state, int x, int y)
  639. {
  640.   float fx, fy;
  641.   int point;
  643.   fy = -(((float)y - ((float)CurveWHeight/NUM_JOINTS * EditingCurve)) /
  644.        ((float)CurveWHeight/NUM_JOINTS) - 0.5) * 180.0,
  645.   fx = (float)x/CurveWWidth;
  646.   
  647.   if (state == GLUT_DOWN && button == GLUT_LEFT_BUTTON &&
  648.                             CurveDownBtn == -1) {
  649.     CurvePickedPoint = -1;
  650.     
  651.     for (point = 0; point < RotCurve[EditingCurve].numpoints; point++) {
  652.       if (fabs(RotCurve[EditingCurve].xcoords[point] - fx) < 0.01 &&
  653.   fabs(RotCurve[EditingCurve].angles[point] - fy) < 4) {
  654. CurvePickedPoint = point;
  655. CurveLastX = x;
  656. CurveLastY = y;
  657. glutIdleFunc(CurveCPointDrag);
  658. break;
  659.       }
  660.     }
  661.    if (CurvePickedPoint == -1)
  662.      CurveHandleButton(button, state, x, y);
  663.     CurveDownBtn = button;
  666.   } else if (state == GLUT_DOWN && button == GLUT_MIDDLE_BUTTON &&
  667.                                    CurveDownBtn == -1) {
  669.     for (point = 3; point < RotCurve[EditingCurve].numpoints - 1; point += 3) {
  670.       if (fabs(RotCurve[EditingCurve].xcoords[point] - fx) < 0.01 &&
  671.   fabs(RotCurve[EditingCurve].angles[point] - fy) < 4) {
  672. break;
  673.       }
  674.     }
  675.     if (point >= 3 && point < RotCurve[EditingCurve].numpoints - 1)
  676.       RemovePoint(point);
  677.     else if (fabs(Walk_cycle[0][EditingCurve][(int)(fx*CYCLE_SIZE)] - fy) < 4)
  678.       AddPoint(fx);
  679.     ComputeCurve(EditingCurve);
  680.     MakeJointLists(EditingCurve);    
  681.     RedisplayBoth();
  683.   } else if (button == GLUT_LEFT_BUTTON && button == CurveDownBtn) {
  685.     y = MAX(y, 0); y = MIN(y, CurveWHeight);
  686.     x = MAX(x, 0); x = MIN(x, CurveWWidth);
  687.     fy = -(((float)y - ((float)CurveWHeight/NUM_JOINTS * EditingCurve)) /
  688.          ((float)CurveWHeight/NUM_JOINTS) - 0.5) * 180.0,
  689.     fx = (float)x/CurveWWidth;
  690.     CurveDownBtn = -1;
  691.     if (CurvePickedPoint != -1) {
  692.       fx = CurveEditConstrain(fx);
  693.       RotCurve[EditingCurve].xcoords[CurvePickedPoint] = fx;
  694.       RotCurve[EditingCurve].angles[CurvePickedPoint] = fy;        
  695.       ComputeCurve(EditingCurve);
  696.       MakeJointLists(EditingCurve);
  697.       glutIdleFunc(NULL);
  698.       RedisplayBoth();
  699.     }
  700.   }
  701. }  
  704. void CurveHandleMotion(int x, int y)
  705. {
  706.   if (CurvePickedPoint == -1) { 
  707.     
  708.     if (CurveDownBtn == GLUT_LEFT_BUTTON || CurveDownBtn ==
  709.                                             GLUT_MIDDLE_BUTTON) {
  710.       Step = (int)((float)x/glutGet(GLUT_WINDOW_WIDTH) * CYCLE_SIZE)
  711. % CYCLE_SIZE;
  712.       if (Step < 0)
  713. Step = CYCLE_SIZE + Step;
  714.       fStep = Step;
  716.     RedisplayBoth();
  717.     }
  718.   } else {
  719.     y = MAX(y, 0); y = MIN(y, CurveWHeight);
  720.     x = MAX(x, 0); x = MIN(x, CurveWWidth);
  721.     CurveLastX = x;
  722.     CurveLastY = y;
  723.   }
  724. }
  726. void CurveCPointDrag(void)
  727. {
  728.   float fx, fy;
  730.   if (CurveDownBtn == GLUT_LEFT_BUTTON && CurvePickedPoint != -1) {
  731.     fy = -(((float)CurveLastY -
  732.            ((float)CurveWHeight/NUM_JOINTS * EditingCurve)) /
  733.           ((float)CurveWHeight/NUM_JOINTS) - 0.5) * 180.0,
  734.     fx = (float)CurveLastX/CurveWWidth;
  736.     fx = CurveEditConstrain(fx);
  737.     RotCurve[EditingCurve].xcoords[CurvePickedPoint] = fx;
  738.     RotCurve[EditingCurve].angles[CurvePickedPoint] = fy;        
  739.     ComputeCurve(EditingCurve);
  740.     MakeJointLists(EditingCurve);
  741.     RedisplayBoth();
  742.   }
  743. }
  745. /* ARGSUSED1 */
  746. void CurveHandleKeys(unsigned char key, int x, int y)
  747. {
  748.   if (key > '0' && key < '9')
  749.     CurveHandleEditMenu((key-'0')-1);
  750.   else if (key == 'd')
  751.     CurveHandleMenu(CMENU_DONEEDIT);
  752.   else {
  753.     switch(key) {
  754.       case 'f':
  755.       case ' ': Step++;
  756.                 StopWalking(); break;
  757.       case 'F': Step += 5;
  758.                 StopWalking(); break;
  759.       case 'b': Step--;
  760.                 StopWalking(); break;
  761.       case 'B': Step -= 5; 
  762.                 StopWalking(); break;
  763.     }
  764.     Step %= CYCLE_SIZE;
  765.     if (Step < 0)
  766.       Step = CYCLE_SIZE + Step;
  767.     fStep = Step;
  768.     RedisplayBoth();
  769.   }
  770. }
  772. void CurveHandleEditMenu(int curve)
  773. {
  774.   if (curve >= NUM_JOINTS)
  775.     return;
  776.   if (EditingCurve == -1) {
  777.     WasWalking = Walking;
  778.     Walking = 0;
  779.     agvSetAllowIdle(0);   /* don't allow spinning, just slows us down */
  780.     glutIdleFunc(NULL);
  781.     glutMouseFunc(CurveEditHandleButton);
  782.   }
  783.   EditingCurve = curve;
  784.   glutPostRedisplay();
  785. }
  787. void CurveHandleSZMenu(int size)
  788. {
  789.   IncStep = (float)size/100;
  790. }
  792. void CurveHandleMenu(int value)
  793. {
  794.   switch (value) {
  795.     case CMENU_QUIT:
  796.       exit(0);
  797.       break;
  798.     case CMENU_CURVE:
  799.       CurveAsPoints = !CurveAsPoints;
  800.       glutPostRedisplay();
  801.       break;
  802.     case CMENU_HORIZ:
  803.       DrawHorizontals = !DrawHorizontals;
  804.       glutPostRedisplay();
  805.       break;
  806.     case CMENU_WALK:
  807.       if (EditingCurve != -1)
  808. break;
  809.       Walking = !Walking;
  810.       if (Walking) {
  811.         agvSetAllowIdle(0);
  812. glutIdleFunc(IncrementStep);
  813.       } else {
  814.         agvSetAllowIdle(1);
  815.       }
  816.       break;
  817.     case CMENU_DONEEDIT:
  818.       glutMouseFunc(CurveHandleButton);
  819.       EditingCurve = -1;
  820.       CurvePickedPoint = -1;
  821.       Walking = WasWalking;
  822.       if (Walking)
  823. glutIdleFunc(IncrementStep);
  824.       else
  825.         agvSetAllowIdle(1);
  826.       glutPostRedisplay();
  827.       break;
  828.     case CMENU_RESET:
  829.       FlatCSet();
  830.       ComputeCSetAndMakeLists();
  831.       glutPostRedisplay();
  832.       break;
  833.     case CMENU_MIRROR:
  834.       MirrorLegs = !MirrorLegs;
  835.       ComputeCSetAndMakeLists();
  836.       glutPostRedisplay();      
  837.     }
  838. }
  840. void CurveMenuInit(void)
  841. {
  842.   int i;
  843.   char label[3];
  845.   if (CurveEditMenu != -1) {
  846.     glutDestroyMenu(CurveEditMenu);
  847.     glutDestroyMenu(CurveMenu);
  848.     glutDestroyMenu(StepSizeMenu);
  849.   }
  851.   CurveEditMenu = glutCreateMenu(CurveHandleEditMenu);
  852.   for (i = 0; i < NUM_JOINTS; i++) {
  853.     sprintf(label, " %d ", i+1);
  854.     glutAddMenuEntry(label, i);
  855.   }
  856.   StepSizeMenu = glutCreateMenu(CurveHandleSZMenu);
  857.   glutAddMenuEntry("0.25", 25);
  858.   glutAddMenuEntry("0.5",  50);
  859.   glutAddMenuEntry("1.0", 100);
  860.   glutAddMenuEntry("2.0", 200);
  861.   glutAddMenuEntry("3.0", 300);
  862.   glutAddMenuEntry("5.0", 500);
  863.   CurveMenu = glutCreateMenu(CurveHandleMenu);
  864.   glutAddSubMenu("Load Curve Set", LoadMenu);
  865.   glutAddSubMenu("Save As Curve Set", SaveMenu);
  866.   glutAddSubMenu("Edit Curve", CurveEditMenu);
  867.   glutAddMenuEntry("Done Editing", CMENU_DONEEDIT);
  868.   glutAddMenuEntry("Flatten Curve Set", CMENU_RESET);
  869.   glutAddMenuEntry("Toggle mirrored", CMENU_MIRROR);
  870.   glutAddSubMenu("Step size", StepSizeMenu);
  871.   glutAddMenuEntry("Toggle dotted", CMENU_CURVE);
  872.   glutAddMenuEntry("Toggle horizontals", CMENU_HORIZ);
  873.   glutAddMenuEntry("Toggle walking", CMENU_WALK);
  874.   glutAddMenuEntry("Quit", CMENU_QUIT);
  875.   glutSetWindow(CurveWindow);
  876.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  877. }
  879. void CurveVisible(int v)
  880. {
  881.   if (v == GLUT_VISIBLE)
  882.     CurveWindowVisible = 1;
  883.   else 
  884.     CurveWindowVisible = 0;
  885. }
  887. /***************************************************************/
  888. /*********************** GUY WINDOW ****************************/
  889. /***************************************************************/
  891. void GuyDisplay(void)
  892. {
  893.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  894.   glFlush();
  896.   glLoadIdentity();
  898.   agvViewTransform();
  900.   if (DrawAxes)
  901.     glCallList(AxesList);
  903.   switch(GuyModel) {
  904.     case WIRECUBE:   DrawTheGuy_WC();  break;
  905.     case SOLIDCUBE:  DrawTheGuy_SC();  break;
  906.     case CYLINDER1:  DrawTheGuy_SL();  break;
  907.     case CYLINDER2:  DrawTheGuy_SL2(); break;
  908.   }
  910.   glutSwapBuffers();
  911.   glFlush();
  912. }
  914. void GuyReshape(int w, int h)
  915. {
  916.   glViewport(0,0,w,h);
  917.   glMatrixMode(GL_PROJECTION);
  918.   glLoadIdentity();
  919.   if (ViewPerspective)
  920.     gluPerspective(60.0, (GLdouble)w/h, 0.01, 100);
  921.   else
  922.     glOrtho(-1.2, 1.2, -1.2, 1.2, 0.1, 100);
  923.   glMatrixMode(GL_MODELVIEW);
  924.   glFlush();
  925. }
  928. void GuyGLInit(void)
  929. {
  930.   GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
  931.   GLfloat light_position[] = { 0.3, 0.5, 0.8, 0.0 };
  932.   GLfloat lm_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
  933.   
  934.   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  935.   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  936.   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lm_ambient);
  937.   
  938.   glEnable(GL_LIGHTING);
  939.   glEnable(GL_LIGHT0);
  940.   glDepthFunc(GL_LESS);
  941.   glEnable(GL_DEPTH_TEST);
  942.   glEnable(GL_NORMALIZE);
  943.   glShadeModel(GL_SMOOTH);
  944.   /* Cylinder stuff */
  945.   StoreTheGuy_SL();
  946.   StoreTheGuy_SL2();
  947. }
  949. void GuyHandleKeys(unsigned char key, int x, int y)
  950. {
  951.   switch(key) {
  952.     case 'f':
  953.     case ' ': Step++;
  954.               StopWalking(); break;
  955.     case 'F': Step += 5;
  956.               StopWalking(); break;
  957.     case 'b': Step--;
  958.               StopWalking(); break;
  959.     case 'B': Step -= 5; 
  960.               StopWalking(); break;
  961.   }
  962.   Step %= CYCLE_SIZE;
  963.   if (Step < 0)
  964.     Step = CYCLE_SIZE + Step;
  965.   agvHandleKeys(key, x, y);
  966.   RedisplayBoth();
  967. }
  969. typedef enum { GMENU_QUIT, GMENU_CURVE, GMENU_HORIZ,
  970.                GMENU_AXES, GMENU_PERSP } GuyMenuChoices;
  973. void GuyModelHandleMenu(int model)
  974. {
  975.   GuyModel = model;
  976.   if (model == WIRECUBE)
  977.     glDisable(GL_LIGHTING);
  978.   else
  979.     glEnable(GL_LIGHTING);
  980.   glutPostRedisplay();
  981. }
  983. void GuyHandleMenu(int value)
  984. {
  985.   switch (value) {
  986.     case GMENU_QUIT:
  987.       exit(0);
  988.       break;
  989.     case GMENU_AXES:
  990.       DrawAxes = !DrawAxes;
  991.       glutPostRedisplay();
  992.       break;
  993.     case GMENU_PERSP:
  994.       ViewPerspective = !ViewPerspective;
  995.       GuyReshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
  996.       glutPostRedisplay();
  997.       break;
  998.   }
  999. }
  1001. void GuyMenuInit(void)
  1002. {
  1003.   int sub2, sub1 = glutCreateMenu(agvSwitchMoveMode);
  1004.   glutAddMenuEntry("Flying move",  FLYING);
  1005.   glutAddMenuEntry("Polar move",   POLAR);
  1006.   sub2 = glutCreateMenu(GuyModelHandleMenu);
  1007.   glutAddMenuEntry("Wire cubes",  WIRECUBE);
  1008.   glutAddMenuEntry("Solid cubes", SOLIDCUBE);
  1009.   glutAddMenuEntry("Cylinder 1",  CYLINDER1);
  1010.   glutAddMenuEntry("Cylinder 2",  CYLINDER2);
  1011.   glutCreateMenu(GuyHandleMenu);
  1012.   glutAddSubMenu("Viewing", sub1);
  1013.   glutAddSubMenu("Model", sub2);
  1014.   glutAddMenuEntry("Toggle Axes",    GMENU_AXES);
  1015.   glutAddMenuEntry("Toggle Perspective View", GMENU_PERSP);
  1016.   glutAddMenuEntry("Quit",           GMENU_QUIT);
  1017.   glutSetWindow(GuyWindow);
  1018.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  1019. }
  1021. /***************************************************************/
  1022. /********************* BOTH WINDOWS ****************************/
  1023. /***************************************************************/
  1025. void RedisplayBoth(void)
  1026. {
  1027.   glutPostWindowRedisplay(GuyWindow);
  1028.   if (CurveWindowVisible) {
  1029.     glutPostWindowRedisplay(CurveWindow);
  1030.   }
  1031. }
  1033. void IncrementStep(void)
  1034. {
  1035.   fStep = fmod(fStep + IncStep, CYCLE_SIZE);
  1036.   Step = (int)fStep;
  1037.   if (agvMoving)
  1038.     agvMove();
  1039.   RedisplayBoth();
  1040. }
  1042. void StopWalking(void)
  1043. {
  1044.   if (Walking) {
  1045.     Walking = 0;
  1046.     agvSetAllowIdle(1);
  1047.   }
  1048. }
  1050. void SetWindowTitles(char *csetname)
  1051. {
  1052.   char windowtitle[MAX_CSETNAMELEN + 20];
  1054.   strcpy(windowtitle, "Rotation Curves: ");
  1055.   strcat(windowtitle, csetname);
  1056.   glutSetWindow(CurveWindow);
  1057.   glutSetWindowTitle(windowtitle);
  1059.   strcpy(windowtitle, "The Guy: ");
  1060.   strcat(windowtitle, csetname);
  1061.   glutSetWindow(GuyWindow);
  1062.   glutSetWindowTitle(windowtitle);
  1063. }
  1065. /***************************************************************/
  1066. /***************************** MAIN ****************************/
  1067. /***************************************************************/
  1069. int main(int argc, char** argv)
  1070. {
  1071.   glutInit(&argc, argv);
  1073.   glutInitWindowSize(512, 512);
  1074.   glutInitWindowPosition(700, 250);
  1075.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  1076.   GuyWindow = glutCreateWindow("The Guy:");
  1077.   agvInit(!Walking);
  1078.   AxesList = glGenLists(1);
  1079.   agvMakeAxesList(AxesList);
  1080.   GuyGLInit();
  1081.   GuyMenuInit();
  1082.   glutDisplayFunc(GuyDisplay);
  1083.   glutReshapeFunc(GuyReshape);
  1084.   glutKeyboardFunc(GuyHandleKeys);
  1086.   glutInitWindowSize(512, 1024);
  1087.   glutInitWindowPosition(100, 0);
  1088.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  1089.   CurveWindow = glutCreateWindow("Rotation Curves:");
  1090.   CurveGLInit();
  1091.   glutDisplayFunc(CurveDisplay);
  1092.   glutReshapeFunc(CurveReshape);
  1093.   glutMouseFunc(CurveHandleButton);
  1094.   glutMotionFunc(CurveHandleMotion);
  1095.   glutKeyboardFunc(CurveHandleKeys);
  1096.   glutVisibilityFunc(CurveVisible);
  1098.   FlatCSet();
  1099.   MakeLists();
  1101.   if (MakeLoadAndSaveMenus() > 0)  /* read first curve if there was one */
  1102.     HandleLoadMenu(0);
  1104.   CurveMenuInit();
  1106.   glutMainLoop();
  1107.   return 0;             /* ANSI C requires main to return int. */
  1108. }