glrender.c

有限元学习研究用源代码(老外的),供科研人员参考

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

#define IGLR_MOVES        6

void wzPrintDocumentationEntry(char* localurl);

typedef struct iglrStatusStruct iglrStatus;

static void iglrMessage(iglRenderer rnd, char *msg);

static void iglrStartHelpMode(iglRenderer rnd);
static int iglrActionHelpKey(iglRenderer rnd);
static int iglrActionSelectObject(iglRenderer rnd);
static int iglrActionSetMode(iglRenderer rnd);
static int iglrActionParameter(iglRenderer rnd);
static int iglrActionValue(iglRenderer rnd);
static int iglrActionMove(iglRenderer rnd);

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

static void iglrInit(iglRenderer rnd);
static void iglrInitStatus(iglrStatus *s);

static void iglrDefineMoveMode(iglRenderer rnd);
static void iglrMove(iglRenderer rnd, double move[IGLR_MOVES]);
static void iglrMoveReset(iglRenderer rnd, char resets[IGLR_MOVES]);
static int  iglrMoveMouse(iglRenderer rnd, int x, int y, GLenum mask);

static void iglrDefineSlicePosition( iglRenderer rnd, int p);
static void iglrDefineObjectPosition(iglRenderer rnd, int l);
static void iglrDefineLightPosition( iglRenderer rnd, int l);
static void iglrDefineCameraPosition(iglRenderer rnd);
static void iglrDefinePosition(iglRenderer rnd);

static GLenum iglrStartTextInput(iglRenderer rnd, int key, GLenum mask, int modus);
static GLenum iglrPutLetter(iglRenderer rnd, int key, GLenum mask);
static void iglrenderLoop(iglRenderer rnd);

static void iglrWriteStatus(iglrStatus *s, char *file);
static void iglrReadStatus( iglrStatus *s, char *file);

#define IGLR_MODI              4
#define IGLR_MODE_C            0
#define IGLR_MODE_O            1
#define IGLR_MODE_S            2
#define IGLR_MODE_L            3

#define IGLR_MOVE_TX      0
#define IGLR_MOVE_TY      1
#define IGLR_MOVE_TZ      2
#define IGLR_MOVE_RX      3
#define IGLR_MOVE_RY      4
#define IGLR_MOVE_SC      5

#define IGLR_KEY_Refresh               GLW_F2
#define IGLR_KEY_Help                  GLW_F1
#define IGLR_KEY_Help_Prev             GLW_Up  
#define IGLR_KEY_Help_Next             GLW_Down
#define IGLR_KEY_Help_End              GLW_Escape
#define IGLR_KEY_SetModeC              GLW_F5
#define IGLR_KEY_SetModeO              GLW_F6
#define IGLR_KEY_SetModeP              GLW_F7
#define IGLR_KEY_SetModeL              GLW_F8
#define IGLR_MODKEY_SetModeC           0
#define IGLR_MODKEY_SetModeO           0
#define IGLR_MODKEY_SetModeP           0
#define IGLR_MODKEY_SetModeL           0
#define IGLR_MASK_MoveModeC            GLW_LOCK
#define IGLR_MASK_MoveModeO            GLW_SHIFT
#define IGLR_MASK_MoveModeP            GLW_CONTROL
#define IGLR_MASK_MoveModeL            GLW_MOD1

#define IGLR_KEY_SaveLocal             GLW_F9
#define IGLR_KEY_SaveFile              GLW_F10
#define IGLR_KEY_LoadLocal             GLW_End
#define IGLR_KEY_LoadFile              GLW_Home
#define IGLR_KEY_SliceX                GLW_KP_Divide
#define IGLR_KEY_SliceY                GLW_KP_Multiply
#define IGLR_KEY_SliceZ                GLW_KP_Subtract
#define IGLR_KEY_ResetTranslation      GLW_KP_5
#define IGLR_KEY_ResetRotation         GLW_KP_Add
#define IGLR_KEY_ResetScaling          GLW_KP_Enter
#define IGLR_KEY_ResetStatus           GLW_KP_7
#define IGLR_NAME_DefaultSaveFile      ".iglrnd"

#define IGLR_KEY_P_MOVE_TX             GLW_KP_6
#define IGLR_KEY_N_MOVE_TX             GLW_KP_4
#define IGLR_KEY_P_MOVE_TY             GLW_KP_8
#define IGLR_KEY_N_MOVE_TY             GLW_KP_2
#define IGLR_KEY_P_MOVE_TZ             GLW_KP_1
#define IGLR_KEY_N_MOVE_TZ             GLW_KP_9
#define IGLR_KEY_P_MOVE_RX             GLW_Up
#define IGLR_KEY_N_MOVE_RX             GLW_Down
#define IGLR_KEY_P_MOVE_RY             GLW_Right
#define IGLR_KEY_N_MOVE_RY             GLW_Left
#define IGLR_KEY_P_MOVE_SC             GLW_KP_0
#define IGLR_KEY_N_MOVE_SC             GLW_KP_Decimal
#define IGLR_MOUSE_X_LEFT              IGLR_MOVE_RY
#define IGLR_MOUSE_Y_LEFT              IGLR_MOVE_RX
#define IGLR_MOUSE_X_MIDDLE            IGLR_MOVE_TZ
#define IGLR_MOUSE_Y_MIDDLE            IGLR_MOVE_SC
#define IGLR_MOUSE_X_RIGHT             IGLR_MOVE_TX
#define IGLR_MOUSE_Y_RIGHT             IGLR_MOVE_TY


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

struct iglrStatusStruct{
    int      maxObjects[IGLR_MODI];
    int      current[IGLR_MODI];
    char     move[IGLR_MODI][IGLR_OBJECTS];
    char     show[IGLR_MODI][IGLR_OBJECTS];
    char     defined[IGLR_MODI][IGLR_OBJECTS];
    double   matrix[IGLR_MODI][IGLR_OBJECTS][IGLR_MOVES];
    char     sliceOn[IGLR_OBJECTS][3];
    double   lightcolor[IGLR_OBJECTS][3];
    union{
	double d;
	int    i;
	char*  s;
	char   c;
    }        value[IGLR_OBJECTS][IGLR_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{
    iglrCallback call;
  } Action;
} iglrParameterData;

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

#define IGLR_TEXT_INPUT        1
#define IGLR_INTEGER_INPUT     2
#define IGLR_FLOAT_INPUT       3

#define IGLR_HELP_Off          0
#define IGLR_HELP_Key          1

#define IGLR_TYPE_Integer      1
#define IGLR_TYPE_Enum         2
#define IGLR_TYPE_Switch       3
#define IGLR_TYPE_Double       4
#define IGLR_TYPE_Action       5

struct iglRendererStruct
{
    glWindow win;
    iglrStatus c;
    iglrStatus old;
/* current status variables */
    int showSlice;
    int helpMode;
    int helpLine;
    char **helpText;
    int key,modkey;
    GLenum mask;
    double move[IGLR_MOVES];
    double moveFactor[IGLR_MOVES];
    double moveMouseFactor[IGLR_MOVES];
    int mode,current,moveMode[IGLR_MODI];
/* text-input-mode related variables: */
    char text[256];
    GLenum textMask;
    int  textMode,textPos,textLast,textKey;
    char textOld[256];
    char *saveFileName;
/* 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[IGLR_DRAW_MODI];
    double slice[5];
    char   sliceOn[3];
/* object data */
    char    objectKey[IGLR_OBJECTS], objectDefined[IGLR_OBJECTS];
    char   *objectName[IGLR_OBJECTS];
    char   *objectHelp[IGLR_OBJECTS];
    char   *objectURL[IGLR_OBJECTS];
    iglrCallback objectCallback[IGLR_OBJECTS];
    void   *object[IGLR_OBJECTS];
/* parameter data */
    iglrParameterData par[IGLR_OBJECTS][IGLR_PARAMETERS];
    char   parDefined[IGLR_OBJECTS][IGLR_PARAMETERS];
    char   parKey[IGLR_OBJECTS][IGLR_PARAMETERS];
    char   parType[IGLR_OBJECTS][IGLR_PARAMETERS];
    char   *parName[IGLR_OBJECTS][IGLR_PARAMETERS];
    char   *parHelp[IGLR_OBJECTS][IGLR_PARAMETERS];
    char   *parURL[IGLR_OBJECTS][IGLR_PARAMETERS];
/* camera data */
    double cameraTX,cameraTY,cameraTZ;
    double cameraRX,cameraRY,cameraSC;
/* current light data */
    double lightTX,lightTY,lightTZ;
    double lightRX,lightRY,lightSC;
    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;
    iglrCallback draw;
    iglrCallback2 draw2;
    double p_min,p_boxMax;
    char sliceDir;


    iglrKeyAction key_action_table[256];
    char * key_help_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 *iglrModeName[4]={"camera","object","slices","light"};
static char  iglrModeChar[4]={'C','O','S','L'};
static char *iglrModeHelp[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."
};

void iglrPrint(iglRenderer rnd,char *s)
{glwPrint(rnd->win,s);}

char state[64];
char tmp[32];
void iglrShowState(iglRenderer rnd)
{

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

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

      strcat(state,tmp);

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

void iglrRegisterKeyAction(iglRenderer rnd, int key, iglrKeyAction action, char *help)
{
  rnd->key_action_table[key]=action;
  if (help!=NULL)
    rnd->key_help_table[key]=help;
}


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

static void iglrender0(iglRenderer rnd);



static int iglrKeyAction_D(iglRenderer rnd, int mask)
{
  rnd->dump=1;
  iglrender0(rnd);
  rnd->dump=0;
  return GL_TRUE;
}


static int  iglrKeyAction_state_control(iglRenderer rnd, int mask)
{
  rnd->dialog=!rnd->dialog;
  if (mask & GLW_SHIFT ) rnd->next_dialog=0;
  else                   rnd->next_dialog=1;
  iglrShowState(rnd);
  return GL_TRUE;
}


static int iglrKeyAction_object_move(iglRenderer rnd, int mask)
{
  rnd->object_move=!rnd->object_move;
  return GL_TRUE;
}

static int iglrKeyAction_g(iglRenderer rnd, int mask)
{
  rnd->gouraud_shading=!rnd->gouraud_shading;
  if (rnd->gouraud_shading)
    glShadeModel(GL_SMOOTH);
  else
    glShadeModel(GL_FLAT);
  iglrShowState(rnd);
  return GL_TRUE;
}

static int iglrKeyAction_F(iglRenderer rnd, int mask)
{
  rnd->frame=!rnd->frame;
  iglrShowState(rnd);
  return GL_TRUE;
}
static int iglrKeyAction_B(iglRenderer rnd, int mask)
{
  rnd->bg_black=!rnd->bg_black;
  iglrShowState(rnd);
  return GL_TRUE;
}

static int iglrKeyAction_m(iglRenderer rnd, int mask)
{
  rnd->move_wireframe=0;
  rnd->move_frame=0;
  rnd->move_model=1;
  rnd->drawLevel = IGLR_DRAW_NORMAL;
  iglrShowState(rnd);
  return GL_FALSE;
}

static int iglrKeyAction_w(iglRenderer rnd, int mask)
{

  rnd->move_wireframe=1;
  rnd->move_frame=0;
  rnd->move_model=0;
  rnd->drawLevel = IGLR_DRAW_WIREFRAME;
  iglrShowState(rnd);
  return GL_FALSE;
}

static int iglrKeyAction_l(iglRenderer rnd, int mask)
{
  rnd->level_surf=1;
  rnd->list_valid=0;
  iglrShowState(rnd);
  return GL_TRUE;
}

static int iglrKeyAction_f(iglRenderer rnd, int mask)
{
  rnd->move_wireframe=0;
  rnd->drawLevel = IGLR_DRAW_NONE;
  rnd->move_frame=1;
  rnd->move_model=0;
  iglrShowState(rnd);
  return GL_FALSE;
}


static int iglrKeyAction_inc_mouse(iglRenderer rnd, int mask)
{
  rnd->sensitivity*=SQRT_2;
  return GL_FALSE;
}
static int iglrKeyAction_dec_mouse(iglRenderer rnd, int mask)
{
  rnd->sensitivity/=SQRT_2;
  return GL_FALSE;
}


static int iglrKeyAction_x(iglRenderer rnd, int mask)
{
  rnd->slice[0]=1.0;
  rnd->slice[1]=0.0;