glrender.c

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

}
   
void iglrUndefineObject(   iglRenderer rnd, int obj)
{
  if(obj<0 || obj >= IGLR_OBJECTS)    return;
  rnd->c.defined[IGLR_MODE_O][obj] = rnd->objectDefined[obj] = 0;
}

void iglrUndefineParameter(iglRenderer rnd, int obj, int par)
{
  if(obj<0 || obj >= IGLR_OBJECTS)    return;
  if(par<0 || par >= IGLR_PARAMETERS) return;
  rnd->parDefined[obj][par] = 0;
}

void iglrSetObject(        iglRenderer rnd, int obj, void *data)
{
    if(obj<1 || obj > rnd->c.maxObjects[IGLR_MODE_O]) return;
    rnd->object[obj]         = data;
}

/*#############################@status@############################*/

static void iglrInitStatus(iglrStatus *s)
{
    int i,j,k;
    for(i=0;i<IGLR_MODI;i++){
	s->maxObjects[i] = IGLR_OBJECTS-1;
	s->current[i]    = 1;
    }
    for(i=0;i<IGLR_MODI;i++){
	for(j=0;j<IGLR_OBJECTS;j++){
	    s->defined[i][j]=0;
	    s->move[i][j]=0;
	    s->show[i][j]=1;
	    for(k=0;k<IGLR_MOVES;k++){
		s->matrix[i][j][k]=0;
	    }
	}
	s->defined[i][1]=1;
	s->move[i][1]=1;
	s->show[i][1]=1;
    }
    for(j=0;j<IGLR_OBJECTS;j++){
	s->move[IGLR_MODE_O][j]=1;
	s->show[IGLR_MODE_O][j]=0;
	s->sliceOn[j][0]    = s->sliceOn[j][1]    = s->sliceOn[j][2]    = 1;
	s->lightcolor[j][0] = s->lightcolor[j][1] = s->lightcolor[j][2] = 1.0;
	for(k=0;k<IGLR_PARAMETERS;k++){
	    s->value[j][k].s=0;
	}
    }
    s->defined[IGLR_MODE_O][1]=0;
}

static void iglrWriteStatus(iglrStatus *s, char *file)
{FILE *f = fopen(file,"w");
 if(f){
     fwrite(s,sizeof(iglrStatus),1,f);
     fclose(f);
 }
}

static void iglrReadStatus(iglrStatus *s, char *file)
{FILE *f = fopen(file,"r");
 if(f){
     fread(s,sizeof(iglrStatus),1,f);
     fclose(f);
 }
}

/*#############################@selection@############################*/

static int iglrSelectObject(iglRenderer rnd, int o)
{
    int i,j,k,m=rnd->mode;
    int l = rnd->current;
    if(o<0 || o >= IGLR_OBJECTS) return 0;
    rnd->current = rnd->c.current[m] = o;
    if(!rnd->c.defined[m][o]){
        if(m==IGLR_MODE_O) return 0;
        rnd->c.defined[m][o] = 1;
        rnd->c.show[m][o] = 1;
        for(k=0;k<IGLR_MOVES;k++){
            rnd->c.matrix[m][o][k] = rnd->c.matrix[m][l][k];
        }
        sprintf(tmp,"%s %d created",iglrModeName[rnd->mode],o);
    }else{
        sprintf(tmp,"%s %d selected",iglrModeName[rnd->mode],o);
    }
    if(l) rnd->c.move[m][l] = 0;
    rnd->c.move[m][o] = 1;
    iglrMessage(rnd,tmp);
    if(m==IGLR_MODE_O || m==IGLR_MODE_S) rnd->list_valid = 0;
    if(m==IGLR_MODE_O){
	rnd->draw=rnd->objectCallback[rnd->c.current[IGLR_MODE_O]];
	rnd->info=rnd->object[rnd->c.current[IGLR_MODE_O]];
    }
    iglrDefinePosition(rnd);
    return 1;
}

static void iglrMessage(iglRenderer rnd, char *msg)
{
    glwShowState(rnd->win,msg);
}

static int iglrActionParameter(iglRenderer rnd)
{
  char temp[256];
  int obj,par,val;
  obj = iglrGetObject(rnd);
  for(par=0;par<IGLR_PARAMETERS;par++){
    if(rnd->parDefined[obj][par])
      if(rnd->key == rnd->parKey[obj][par]){
	if(rnd->parType[obj][par] == IGLR_TYPE_Switch){
	  if(rnd->c.value[obj][par].i){
	    rnd->c.value[obj][par].i = 0;
	    sprintf(temp,"%s off",rnd->parName[obj][par]);
	  }else{
	    rnd->c.value[obj][par].i = 1;
	    sprintf(temp,"%s on",rnd->parName[obj][par]);
	  }
	  rnd->list_valid=0;
	}else if(rnd->parType[obj][par] == IGLR_TYPE_Enum){
	  val= rnd->c.value[obj][par].i + 1;
	  if(val>=rnd->par[obj][par].Enum.values) val=0;
	  rnd->c.value[obj][par].i=val;
	  rnd->list_valid=0;
	  sprintf(temp,"%s set to %s",rnd->parName[obj][par],rnd->par[obj][par].Enum.value[val]);
	}else if(rnd->parType[obj][par] == IGLR_TYPE_Integer){
	  iglrStartTextInput(rnd,rnd->key,rnd->mask,IGLR_INTEGER_INPUT);
	  sprintf(temp,"type new %s value",rnd->parName[obj][par]);
	}else if(rnd->parType[obj][par] == IGLR_TYPE_Double){
	  iglrStartTextInput(rnd,rnd->key,rnd->mask,IGLR_FLOAT_INPUT);
	  sprintf(temp,"type new %s value",rnd->parName[obj][par]);
	}else if(rnd->parType[obj][par] == IGLR_TYPE_Action){
	  (*rnd->par[obj][par].Action.call)(rnd,rnd->info);
	  rnd->list_valid=0;
	  sprintf(temp,"%s",rnd->parName[obj][par]);
	}else{
	  sprintf(temp,"key %s was pressed",rnd->parName[obj][par]);
	}
	glwShowState(rnd->win,temp);
	return 1;
      }
  }
  return 0;
}

static int iglrActionValue(iglRenderer rnd)
{
  char temp[256];
  int obj,par,ival,rc;
  float fval; double dval;
  obj = iglrGetObject(rnd);
  for(par=0;par<IGLR_PARAMETERS;par++){
    if(rnd->parDefined[obj][par])
      if(rnd->key == rnd->parKey[obj][par]){
	if(rnd->parType[obj][par] == IGLR_TYPE_Integer){
	  rc=sscanf(rnd->text,"%d",&ival);
	  if(rc!=1) ival=0;
	  if(ival<rnd->par[obj][par].Int.min) ival = rnd->par[obj][par].Int.min;
	  if(ival>rnd->par[obj][par].Int.max) ival = rnd->par[obj][par].Int.max;
	  sprintf(temp,"%d",ival);
	  rnd->c.value[obj][par].i=ival;
	}else if(rnd->parType[obj][par] == IGLR_TYPE_Double){
	  rc=sscanf(rnd->text,"%f",&fval);
	  if(rc!=1) fval=0;
	  dval=fval;
	  if(dval<rnd->par[obj][par].Double.min) dval = rnd->par[obj][par].Double.min;
	  if(dval>rnd->par[obj][par].Double.max) dval = rnd->par[obj][par].Double.max;
	  sprintf(temp,"%lf",dval);
	  rnd->c.value[obj][par].d=dval;
	}
	iglrSetTitle(rnd,rnd->parName[obj][par]);
	glwShowState(rnd->win,temp);
	break;
      }
  }
  rnd->list_valid=0;
  return 1;
}

static int iglrActionMisc(iglRenderer rnd)
{
    char resets[6]={0,0,0,0,0,0};
    int pl;
    switch(rnd->key){
    case IGLR_KEY_Help:
	goto help;
    case IGLR_KEY_SaveFile:
      iglrWriteStatus(&(rnd->c),rnd->saveFileName);
      return GL_TRUE;
    case IGLR_KEY_LoadFile:
      iglrReadStatus(&(rnd->c),rnd->saveFileName);
      goto status;
    case IGLR_KEY_ResetStatus:
      iglrInitStatus(&(rnd->c));
      goto status;
    case IGLR_KEY_SaveLocal:
      rnd->old = rnd->c;
      return GL_TRUE;
    case IGLR_KEY_LoadLocal:
      rnd->c = rnd->old;
      goto status;
    case IGLR_KEY_SliceX:
	pl = 0; goto sliceswitch;
    case IGLR_KEY_SliceY:
	pl = 1; goto sliceswitch;
    case IGLR_KEY_SliceZ:
	pl = 2; goto sliceswitch;
    case IGLR_KEY_ResetTranslation:
      resets[IGLR_MOVE_TX] = resets[IGLR_MOVE_TY] =  resets[IGLR_MOVE_TZ] = 1;
      goto reset;
    case IGLR_KEY_ResetRotation:
      resets[IGLR_MOVE_RX] = resets[IGLR_MOVE_RY] = 1;
      goto reset;
    case IGLR_KEY_ResetScaling:
      resets[IGLR_MOVE_SC] = 1;
      goto reset;
    case IGLR_KEY_Refresh:
      goto status;
    default: return GL_FALSE;
    }
reset:
    iglrMoveReset(rnd,resets);
    return GL_TRUE;
status:
    rnd->list_valid = 0;
    iglrDefinePosition(rnd);
    return GL_TRUE;
sliceswitch:
    rnd->c.sliceOn[rnd->c.current[IGLR_MODE_S]][pl]
	=  rnd->sliceOn[pl] = 1 - rnd->sliceOn[pl];
    if(rnd->sliceOn[pl]) iglrMessage(rnd, "slice now on");
    else                 iglrMessage(rnd, "slice now off");
    rnd->list_valid = 0;
    return GL_TRUE;
help:
    rnd->helpMode = IGLR_HELP_Key;
    iglrStartHelpMode(rnd);
    return GL_TRUE;
}

static int iglrActionSelectObject(iglRenderer rnd)
{
    int obj;
    char tmp[256];
    switch(rnd->key){
    case GLW_1: obj = 1; break;
    case GLW_2: obj = 2; break;
    case GLW_3: obj = 3; break;
    case GLW_4: obj = 4; break;
    case GLW_5: obj = 5; break;
    case GLW_6: obj = 6; break;
    case GLW_7: obj = 7; break;
    case GLW_8: obj = 8; break;
    case GLW_9: obj = 9; break;
    case GLW_0: obj = 0; break;
    default: return GL_FALSE;
    }
    if(iglrSelectObject(rnd,obj))    return GL_TRUE;
    return GL_FALSE;
}

/*#############################@help@############################*/

static int   iglrBaseHelpLines = 11;
static char* iglrBaseHelpText[]={
    "Key Help Mode: Up Down: more; Esc: quit; other: help for key;",
    "help keys: F1: key help;",
    "rotation: left mouse button or Up Down Left Right",
    "xy-shift: right mouse button or KP_8 KP_2 KP_4 KP_6",
    "z-shift: middle mouse button or KP_1 KP_9",
    "zoom: middle mouse button or KP_0 KP_Decimal",
    "modi for movement: F5,F6,F7,F8: move camera|object|slices|light",
    "reset keys: KP_5, KP_7, KP_Add, KP_Enter;",
    "save/load keys: F9/End for session, F10/Home permanent;",
    "switch slices: KP_Divide: yz; KP_Multiply: zx; KP_Minus: xy",
    "1..9: select camera|object|slices|light (depends on current mode)",
    "end of help",
    "",
    "Key Help Mode left;"};
static int   iglrBaseHelpEndLine = 13;

static void iglrStartHelpMode(iglRenderer rnd)
{
    iglrSetTitle(rnd,"");
    rnd->helpText = iglrBaseHelpText;
    rnd->helpLine = 0;
    glwShowState(rnd->win, rnd->helpText[rnd->helpLine]);
}

static int iglrActionHelpKey(iglRenderer rnd)
{
    char *c,temp[256];
    int obj,par;
    switch(rnd->key){
    case IGLR_KEY_Help_Prev:
	if(rnd->helpLine > 0) rnd->helpLine--;
	glwShowState(rnd->win, rnd->helpText[rnd->helpLine]);
	return 1;
    case IGLR_KEY_Help_Next:
	if(rnd->helpText[rnd->helpLine][0]){
	    rnd->helpLine++;
	}else{
	  rnd->helpMode = IGLR_HELP_Off;
	}
	glwShowState(rnd->win, rnd->helpText[rnd->helpLine]);
	return 1;
    case IGLR_KEY_Help_End:
	glwShowState(rnd->win, rnd->helpText[iglrBaseHelpEndLine]);
	rnd->helpMode = IGLR_HELP_Off;
	return 1;
    }
    switch(rnd->key){
    case IGLR_KEY_SetModeC:
	c = "camera mode - mouse modifies camera position"; break;
    case IGLR_KEY_SetModeO:
	c = "object mode - mouse modifies box in the objects"; break;
    case IGLR_KEY_SetModeP:
	c = "slice mode - mouse modifies intersection slices"; break;
    case IGLR_KEY_SetModeL:
	c = "light mode - mouse modifies light position"; break;
    case IGLR_KEY_LoadLocal:
	c = "session load: loads previously saved session state"; break;
    case IGLR_KEY_SaveLocal:
	c = "session save: saves the state for this session"; break;
    case IGLR_KEY_SaveFile:
	c = "global save: saves the state into state file"; break;
    case IGLR_KEY_LoadFile:
	c = "global load: loads the state from state file"; break;
    case IGLR_KEY_ResetTranslation:
	c = "resets the translation of the current %s"; break;
    case IGLR_KEY_ResetRotation:
	c = "resets the rotation of the current %s"; break;
    case IGLR_KEY_ResetScaling:
	c = "resets the scaling of the current %s"; break;
    case IGLR_KEY_P_MOVE_TX:
	c = "translation of the current %s in positive x-direction"; break;
    case IGLR_KEY_N_MOVE_TX:
	c = "translation of the current %s in negative x-direction"; break;
    case IGLR_KEY_P_MOVE_TY:
	c = "translation of the current %s in positive y-direction"; break;
    case IGLR_KEY_N_MOVE_TY:
	c = "translation of the current %s in negative y-direction"; break;
    case IGLR_KEY_P_MOVE_TZ:
	c = "translation of the current %s in positive z-direction"; break;
    case IGLR_KEY_N_MOVE_TZ:
	c = "translation of the current %s in negative z-direction"; break;
    case IGLR_KEY_P_MOVE_RX:
	c = "positive rotation of the current %s in the yz-slice"; break;
    case IGLR_KEY_N_MOVE_RX:
	c = "negative rotation of the current %s in the yz-slice"; break;
    case IGLR_KEY_P_MOVE_RY:
	c = "positive rotation of the current %s in the zx-slice"; break;
    case IGLR_KEY_N_MOVE_RY:
	c = "negative rotation of the current %s in the zx-slice"; break;
    case IGLR_KEY_P_MOVE_SC:
	c = "zoom in for the current %s"; break;
    case IGLR_KEY_N_MOVE_SC:
	c = "zoom out for the current %s"; break;
    case IGLR_KEY_SliceX:
	c = "switches the yz-slice on/off"; break;
    case IGLR_KEY_SliceY:
	c = "switches the zx-slice on/off"; break;
    case IGLR_KEY_SliceZ:
	c = "switches the xy-slice on/off"; break;
    case GLW_1:	c = "selects the %s 1 as current %s (if defined)"; break;
    case GLW_2:	c = "selects the %s 2 as current %s (if defined)"; break;
    case GLW_3:	c = "selects the %s 3 as current %s (if defined)"; break;
    case GLW_4:	c = "selects the %s 4 as current %s (if defined)"; break;
    case GLW_5:	c = "selects the %s 5 as current %s (if defined)"; break;
    case GLW_6:	c = "selects the %s 6 as current %s (if defined)"; break;
    case GLW_7:	c = "selects the %s 7 as current %s (if defined)"; break;
    case GLW_8:	c = "selects the %s 8 as current %s (if defined)"; break;
    case GLW_9:	c = "selects the %s 9 as current %s (if defined)"; break;
    default: c = "no key help defined for this key"; break;
    }
    obj = iglrGetObject(rnd);
    for(par=0;par<IGLR_PARAMETERS;par++){
      if(rnd->parDefined[obj][par])
	if(rnd->key == rnd->parKey[obj][par]){
	  c = rnd->parHelp[obj][par];
	  wzPrintDocumentationEntry(rnd->parURL[obj][par]);
	}
    }
    sprintf(temp,c,iglrModeName[rnd->mode],iglrModeName[rnd->mode]);
    glwShowState(rnd->win, temp);
    return 1;
}
/*#############################@move@############################*/

static void iglrMove(iglRenderer rnd, double move[IGLR_MOVES])
{
    int i,j,k;
    iglrStatus *s = &rnd->c;
    iglrDefineMoveMode(rnd);
    for(i=0;i<IGLR_MODI;i++){
	if(! rnd->moveMode[i]) continue;
	for(j=0;j<IGLR_OBJECTS;j++){
	    if(! s->move[i][j]) continue;
	    for(k=0;k<IGLR_MOVES;k++){
		s->matrix[i][j][k] += move[k];
	    }
	}
    }
    iglrDefinePosition(rnd);
}

static void iglrMoveReset(iglRenderer rnd, char resets[IGLR_MOVES])
{
    int i,j,k;
    iglrStatus *s = &rnd->c;
    iglrDefineMoveMode(rnd);
    for(i=0;i<IGLR_MODI;i++){
	if(! rnd->moveMode[i]) continue;
	for(j=0;j<IGLR_OBJECTS;j++){
	    if(! s->move[i][j]) continue;
	    for(k=0;k<IGLR_MOVES;k++){
		if(resets[k]) s->matrix[i][j][k] = 0;
	    }
	}
    }
    for(i=0;i<3;i++){
        rnd->puntrans[i] = rnd->point[i];
    }
    iglrDefinePosition(rnd);
}

static void iglrDefinePosition(iglRenderer rnd)
{
    iglrDefineObjectPosition(rnd,rnd->c.current[IGLR_MODE_O]);
    iglrDefineSlicePosition(rnd,rnd->c.current[IGLR_MODE_S]);
    iglrDefineCameraPosition(rnd);
    iglrDefineLightPosition(rnd,rnd->c.current[IGLR_MODE_L]);
}

/*########################@object@############################*/
static