wzwindow.c

Delaunay三角形的网格剖分程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "gltools/glwin.h"
#include "gltools/gleps.h"
#include "wzwindow.h"
#include "GL/glu.h"

#define WZW_NAME_DefaultSaveFile      ".wzw"

#define WZW_KEY_Refresh               GLW_F2
#define WZW_KEY_Help                  GLW_F1
#define WZW_KEY_HelpAlt               GLW_question
#define WZW_KEY_Help_Prev             GLW_Up  
#define WZW_KEY_Help_Next             GLW_Down
#define WZW_KEY_Help_End              GLW_F1
#define WZW_KEY_SetModeC              GLW_F5
#define WZW_KEY_SetModeO              GLW_F6
#define WZW_KEY_SetModeP              GLW_F7
#define WZW_KEY_SetModeL              GLW_F8

#define WZW_KEY_Print		      GLW_Print
#define WZW_KEY_PrintAlt	      GLW_D 
#define WZW_KEY_Quit		      GLW_Escape
#define WZW_KEY_QuitAlt		      GLW_Q
#define WZW_KEY_Wireframe             GLW_exclam
#define WZW_KEY_Inc_Mouse             GLW_plus
#define WZW_KEY_Dec_Mouse             GLW_minus
#define WZW_KEY_Gouraud               GLW_percent
#define WZW_KEY_FrameToggle	      GLW_numbersign
#define WZW_KEY_MoveStatus	      GLW_asciicircum
#define WZW_KEY_MoveStatus1	      GLW_ampersand
#define WZW_KEY_Background	      GLW_at

#define WZW_KEY_LoadFile              GLW_F9
#define WZW_KEY_SaveFile              GLW_F10
#define WZW_KEY_LoadLocal             GLW_F11
#define WZW_KEY_SaveLocal             GLW_F12
#define WZW_KEY_SliceX                GLW_KP_Divide
#define WZW_KEY_SliceY                GLW_KP_Multiply
#define WZW_KEY_SliceZ                GLW_KP_Subtract
#define WZW_KEY_ResetTranslation      GLW_KP_5
#define WZW_KEY_ResetRotation         GLW_KP_Add
#define WZW_KEY_ResetScaling          GLW_KP_Enter
#define WZW_KEY_ResetStatus           GLW_KP_7

#define WZW_KEY_P_MOVE_TX             GLW_KP_6
#define WZW_KEY_N_MOVE_TX             GLW_KP_4
#define WZW_KEY_P_MOVE_TY             GLW_KP_8
#define WZW_KEY_N_MOVE_TY             GLW_KP_2
#define WZW_KEY_P_MOVE_TZ             GLW_KP_1
#define WZW_KEY_N_MOVE_TZ             GLW_KP_9
#define WZW_KEY_P_MOVE_RX             GLW_Up
#define WZW_KEY_N_MOVE_RX             GLW_Down
#define WZW_KEY_P_MOVE_RY             GLW_Right
#define WZW_KEY_N_MOVE_RY             GLW_Left
#define WZW_KEY_P_MOVE_SC             GLW_KP_0
#define WZW_KEY_N_MOVE_SC             GLW_KP_Decimal

#define WZW_MODKEY_SetModeC           0
#define WZW_MODKEY_SetModeO           0
#define WZW_MODKEY_SetModeP           0
#define WZW_MODKEY_SetModeL           0
#define WZW_MASK_MoveModeC            GLW_LOCK
#define WZW_MASK_MoveModeO            GLW_SHIFT
#define WZW_MASK_MoveModeP            GLW_CONTROL
#define WZW_MASK_MoveModeL            GLW_MOD1

#define WZW_MOVES        6 

void wzPrintDocumentationEntry(char* localurl);

typedef struct wzwStatusStruct wzwStatus;

static void wzwMessage(wzWindow win, char *msg);

static void wzwStartHelpMode(wzWindow win);
static int wzwActionHelpKey(wzWindow win);
static int wzwActionSelectObject(wzWindow win);
static int wzwActionSetMode(wzWindow win);
static int wzwActionParameter(wzWindow win);
static int wzwActionValue(wzWindow win);
static int wzwActionMove(wzWindow win);

static GLenum wzwAction(glWindow w, void * info, int key, GLenum mask);
static GLenum wzwMouse(glWindow w, void * info, int x, int y, GLenum mask);

static void wzwInit(wzWindow win);
static void wzwInitStatus(wzwStatus *s);

static void wzwDefineMoveMode(wzWindow win);
static void wzwMove(wzWindow win, double move[WZW_MOVES]);
static void wzwMoveReset(wzWindow win, char resets[WZW_MOVES]);
static int  wzwMoveMouse(wzWindow win, int x, int y, GLenum mask);

static void wzwDefineSlicePosition( wzWindow win, int p);
static void wzwDefineObjectPosition(wzWindow win, int l);
static void wzwDefineLightPosition( wzWindow win, int l);
static void wzwDefineCameraPosition(wzWindow win);
static void wzwDefinePosition(wzWindow win);

static GLenum wzwStartTextInput(wzWindow win, int key, GLenum mask, int modus);
static GLenum wzwPutLetter(wzWindow win, int key, GLenum mask);
static void wzwViewLoop(wzWindow win);

static void wzwWriteStatus(wzwStatus *s, char *file);
static void wzwReadStatus( wzwStatus *s, char *file);

#define WZW_MODI              4
#define WZW_MODE_C            0
#define WZW_MODE_O            1
#define WZW_MODE_S            2
#define WZW_MODE_L            3

#define WZW_MOVE_TX      0
#define WZW_MOVE_TY      1
#define WZW_MOVE_TZ      2
#define WZW_MOVE_RX      3
#define WZW_MOVE_RY      4
#define WZW_MOVE_SC      5

#define WZW_MOUSE_X_LEFT              WZW_MOVE_RY
#define WZW_MOUSE_Y_LEFT              WZW_MOVE_RX
#define WZW_MOUSE_X_MIDDLE            WZW_MOVE_TZ
#define WZW_MOUSE_Y_MIDDLE            WZW_MOVE_SC
#define WZW_MOUSE_X_RIGHT             WZW_MOVE_TX
#define WZW_MOUSE_Y_RIGHT             WZW_MOVE_TY


/* the type wzwStatus contains all data which may be saved */

struct wzwStatusStruct{
    int      maxObjects[WZW_MODI];
    int      current[WZW_MODI];
    char     move[WZW_MODI][WZW_OBJECTS];
    char     show[WZW_MODI][WZW_OBJECTS];
    char     defined[WZW_MODI][WZW_OBJECTS];
    double   matrix[WZW_MODI][WZW_OBJECTS][WZW_MOVES];
    char     sliceOn[WZW_OBJECTS][3];
    double   lightcolor[WZW_OBJECTS][3];
    union{
	double d;
	int    i;
	char*  s;
	char   c;
    }        value[WZW_OBJECTS][WZW_PARAMETERS];
};

/* this structure contains type-dependent but fixed parameter information */

typedef union{
  struct{
    double min;
    double max;
  } Double;
  struct{
    int min;
    int max;
  } Int;
  struct{
    int values;
    char **value;
  } Enum;
  struct{
    wzwCallback call;
  } Action;
} wzwParameterData;

static double p_eps=1.0e-5;
#define SQRT_SQRT_2  1.1892071
#define SQRT_2       1.4142136
#define TENTHROOT_10 1.2589254

#define WZW_TEXT_INPUT        1
#define WZW_INTEGER_INPUT     2
#define WZW_FLOAT_INPUT       3

#define WZW_HELP_Off          0
#define WZW_HELP_Key          1

#define WZW_TYPE_Integer      1
#define WZW_TYPE_Enum         2
#define WZW_TYPE_Switch       3
#define WZW_TYPE_Double       4
#define WZW_TYPE_Action       5

#define WZW_PATTERN_PPM	"%s_%s.ppm"
#define WZW_PATTERN_EPS	"%s_%s.eps"
#define WZW_PATTERN_SAVE	"%s.wzwindow"

struct wzWindowStruct
{
    wzwStatus c;
    wzwStatus old;
/* names */
    char *name;
    char *help;
    char *url;
    char *saveFilePattern;
    glWindow glwin;
/* current status variables */
    int dim;
    int showSlice;
    int helpMode;
    int helpLine;
    char **helpText;
    int key,modkey;
    GLenum mask;
    double move[WZW_MOVES];
    double moveFactor[WZW_MOVES];
    double moveMouseFactor[WZW_MOVES];
    int mode,current,moveMode[WZW_MODI];
/* text-input-mode related variables: */
    char text[256];
    GLenum textMask;
    int  textMode,textPos,textLast,textKey;
    char textOld[256];
/* parameters visible to the application */
    double boxMin[3],boxMax[3],boxDelta[3],boxFullMin[3],boxFullDelta[3];
    double rectangle[3][4];
    double line[3][2];
    double point[3],preper[3][3],prel[3],puntrans[3];
    int    printLevel;
    int    drawLevel;
    int    drawType;
    int    drawBound[WZW_DRAW_MODI];
    double slice[5];
    char   sliceOn[3];
/* object data */
    char    objectKey[WZW_OBJECTS], objectDefined[WZW_OBJECTS];
    char   *objectName[WZW_OBJECTS];
    char   *objectHelp[WZW_OBJECTS];
    char   *objectURL[WZW_OBJECTS];
    wzwCallback objectCallback[WZW_OBJECTS];
    void   *object[WZW_OBJECTS];
/* parameter data */
    wzwParameterData par[WZW_OBJECTS][WZW_PARAMETERS];
    char   parDefined[WZW_OBJECTS][WZW_PARAMETERS];
    char   parKey[WZW_OBJECTS][WZW_PARAMETERS];
    char   parType[WZW_OBJECTS][WZW_PARAMETERS];
    char   *parName[WZW_OBJECTS][WZW_PARAMETERS];
    char   *parHelp[WZW_OBJECTS][WZW_PARAMETERS];
    char   *parURL[WZW_OBJECTS][WZW_PARAMETERS];
/* camera data */
    double cameraTX,cameraTY,cameraTZ;
    double cameraRX,cameraRY,cameraSC;
/* current light data */
    double lightTX,lightTY,lightTZ;
    double lightRX,lightRY,lightSC;
/* Fuhris old data */
    int button_hold;
    int object_move;
    int wireframe;
    double vscale;
    void *info;
    void *info2;
    int    volume_init;
    double xmin0,xboxMax0;
    double ymin0,yboxMax0;
    double zmin0,zboxMax0;
    wzwCallback draw;
    wzwCallback2 draw2;
    double p_min,p_boxMax;
    char sliceDir;


    wzwKeyAction key_action_table[256];
    char * key_help_table[256];
    char * key_url_table[256];

    double asp;
    double ltx,lty,ltz;
    double SC;
    double xmin,xboxMax;
    double ymin,yboxMax;
    double zmin,zboxMax;

    int gouraud_shading;
    int dialog;
    int next_dialog;
    int frame;
    int bg_black;
    double sensitivity;


    int move_wireframe;
    int move_frame;
    int move_model;

    int show_volume;
    int lastxpos,lastypos;

    int level_surf;
    double level;

    GLuint list;
    int list_valid;
    int data_valid;
    int firstcall;

    int dump;
    int dump_w,dump_h,dump_i;
    char dump_name_stub[32];
};

static char *wzwModeName[4]={"camera","object","slices","light"};
static char  wzwModeChar[4]={'C','O','S','L'};
static char *wzwModeHelp[4]={
    "Mode C: modify observer position (camera).",
    "Mode O: modify objects, move the box in the real world.",
    "Mode S: modify intersection slices in the box.",
    "Mode L: modify light sources."
};

int wzwBackgroundIsBlack(wzWindow win)
{
  return win->bg_black;
}

void wzwPrint(wzWindow win,char *s)
{glwPrint(win->glwin,s);}

char state[64];
char tmp[32];
void wzwShowState(wzWindow win)
{

    return;
    /*    state[0]='\0';
    if (win->dialog) sprintf(state,"user ctrl");
    else             sprintf(state,"app  ctrl");

    if (win->level_surf)
      sprintf(tmp," level=%+8.2e ",win->level);
    else
      sprintf(tmp," %c=%+8.2e ",win->sliceDir, -win->slice[4]);

      strcat(state,tmp);

    if (win->dialog)
      {
	if (win->move_model) strcat(state,"/m");
	else if (win->move_frame) strcat(state,"/f");
	else if (win->move_wireframe) strcat(state,"/w");
      }
    glwShowState(win->glwin,state);  */
}

void wzwRegisterKeyAction(wzWindow win, int key, wzwKeyAction action, 
			   char *help, char *url)
{
  win->key_action_table[key]=action;
  if (help!=NULL)
    win->key_help_table[key]=help;
  if (url!=NULL)
    win->key_url_table[key]=url;
}


static GLenum wzwKeyCallback(glWindow w, void * info, int key, GLenum mask)
{
  wzWindow win=(wzWindow)info;
  if (wzwAction(w,info,key,mask)) return GL_TRUE;
  if (win->key_action_table[key])
    return (*win->key_action_table[key])(win,mask);
  else{char tmp[100];
    sprintf(tmp,"undefined: key 0x%x, mask 0x%x",key,mask);
    glwShowState(win->glwin,tmp);
    return GL_FALSE;
  }
}

static void wzwView0(wzWindow win);
static int wzwActionPrint(wzWindow win, int mask)
{
  win->dump=1;
  wzwView0(win);
  win->dump=0;
  return GL_TRUE;
}

static int wzwActionFrameToggle(wzWindow win, int mask)
{
  win->frame=!win->frame;
  wzwShowState(win);
  return GL_TRUE;
}

static int wzwKeyAction_Background(wzWindow win, int mask)
{
  win->bg_black=!win->bg_black;
  win->list_valid = 0;
  wzwShowState(win);
  return GL_TRUE;
}

static int  wzwKeyAction_Quit(wzWindow win, int mask)
{
  win->dialog=!win->dialog;
  if (mask & GLW_SHIFT ) win->next_dialog=0;
  else                   win->next_dialog=1;
  wzwShowState(win);
  return GL_TRUE;
}


static int wzwKeyAction_object_move(wzWindow win, int mask)
{
  win->object_move=!win->object_move;
  return GL_TRUE;
}

static int wzwKeyAction_g(wzWindow win, int mask)
{
  win->gouraud_shading=!win->gouraud_shading;
  if (win->gouraud_shading)
    glShadeModel(GL_SMOOTH);
  else
    glShadeModel(GL_FLAT);
  wzwShowState(win);
  return GL_TRUE;
}

static int wzwKeyAction_move_status(wzWindow win, int mask)
{
  if(win->move_wireframe){
    win->move_wireframe=0;
    win->move_frame=1;
    win->drawLevel = WZW_DRAW_NONE;
  }else{
    win->move_wireframe=1;
    win->move_frame=0;
    win->drawLevel = WZW_DRAW_WIREFRAME;
  }
  wzwShowState(win);
  return GL_FALSE;
}

/*
static int wzwKeyAction_m(wzWindow win, int mask)
{
  win->move_wireframe=0;
  win->move_frame=0;
  win->move_model=1;
  win->drawLevel = WZW_DRAW_NORMAL;
  wzwShowState(win);
  return GL_FALSE;
}

static int wzwKeyAction_w(wzWindow win, int mask)
{

  win->move_wireframe=1;
  win->move_frame=0;
  win->move_model=0;
  win->drawLevel = WZW_DRAW_WIREFRAME;
  wzwShowState(win);
  return GL_FALSE;
}

static int wzwKeyAction_f(wzWindow win, int mask)
{
  win->move_wireframe=0;
  win->drawLevel = WZW_DRAW_NONE;
  win->move_frame=1;
  win->move_model=0;
  wzwShowState(win);