objfileread.cpp

机器人运动学动力学及控制的一个小程序,供有兴趣的人参考

          }
          else if(inputLine[0]=='s'){
          
          }
          else if(inputLine[0]=='u'){  
               if(strncmp("usemtl",inputLine,6)!=0)
                 continue;
               if(materials==NULL)
                 materials=readMaterials(FileName);
               if(materials)
			   {
               sscanf(&inputLine[7],"%s",materialName);  
               matPtr=materials;
               while((strcmp(materialName,matPtr->name)!=0)&&
                    (matPtr->name[0]!=0))
                 matPtr++;
               if(matPtr->name[0]==0)  
                 fprintf(stderr,"Cant't find %s\n",materialName);
			   
               model->colorList[model->colorCount].index=model->vertexCount;  
               model->colorList[model->colorCount].ra=matPtr->ra; 
               model->colorList[model->colorCount].ga=matPtr->ga;
               model->colorList[model->colorCount].ba=matPtr->ba;
               model->colorList[model->colorCount].rd=matPtr->rd;
               model->colorList[model->colorCount].gd=matPtr->gd;
               model->colorList[model->colorCount].bd=matPtr->bd; 
               model->colorList[model->colorCount].ad=matPtr->ad; 
               model->colorList[model->colorCount].rs=matPtr->rs;
               model->colorList[model->colorCount].gs=matPtr->gs;
               model->colorList[model->colorCount].bs=matPtr->bs; 
               model->colorList[model->colorCount].spec=matPtr->spec;
               model->colorCount++;
			   }
         }
        }
        model->vertexList[model->vertexCount].draw=0;
        model->colorList[model->colorCount].index=model->vertexCount+1;

        model->lineCount=0;
        for(i=0;i<model->edgeCount;i++){
//寻找该边界的颜色
          model->lineList[model->lineCount].colorIndex=0;
          for(j=0;j<=model->colorCount;j++){
             if(model->objVertexList[model->eadgeList[i][0]].vertexIndex<
                  model->colorList[j].index){
               model->lineList[model->lineCount].colorIndex=j-1;
               break;
               }
          }
          
         model->lineList[model->lineCount].draw=0; 
         model->lineList[model->lineCount].x= 
             model->objVertexList[model->eadgeList[i][0]].x;
         model->lineList[model->lineCount].y= 
             model->objVertexList[model->eadgeList[i][0]].y;
         model->lineList[model->lineCount].z= 
             model->objVertexList[model->eadgeList[i][0]].z; 
         model->lineCount++;
         
         model->lineList[model->lineCount].draw=1; 
         model->lineList[model->lineCount].x= 
             model->objVertexList[model->eadgeList[i][1]].x;
         model->lineList[model->lineCount].y= 
             model->objVertexList[model->eadgeList[i][1]].y;
         model->lineList[model->lineCount].z= 
             model->objVertexList[model->eadgeList[i][1]].z; 
         model->lineCount++;
         }         
         model->lineList[model->lineCount].draw=0; 
		 {     
     int edgeBase;

     model->lineStripCount=0;

     edgeBase=0;
     do{
       while(model->eadgeList[edgeBase][0]==-1)
           edgeBase++;
       if(edgeBase>=model->edgeCount)
           break; /*Exit here */

       i=edgeBase;

       v0=model->eadgeList[i][0];
       v1=model->eadgeList[i][1];
//寻找该边界的颜色
       model->lineStripList[model->lineStripCount].colorIndex=0;
       for(j=0;j<=model->colorCount;j++){
          if(model->objVertexList[v0].vertexIndex<=  
               model->colorList[j].index){
            model->lineStripList[model->lineStripCount].colorIndex=j-1;
            break;
            }
        }

       model->lineStripList[model->lineStripCount].draw=0; 
       model->lineStripList[model->lineStripCount].x=
           model->objVertexList[v0].x;   
       model->lineStripList[model->lineStripCount].y=
           model->objVertexList[v0].y;
       model->lineStripList[model->lineStripCount].z=
           model->objVertexList[v0].z;
       model->lineStripCount++;

       model->lineStripList[model->lineStripCount].draw=1; 
       model->lineStripList[model->lineStripCount].x=
           model->objVertexList[v1].x;   
       model->lineStripList[model->lineStripCount].y=
           model->objVertexList[v1].y;
       model->lineStripList[model->lineStripCount].z=
           model->objVertexList[v1].z;
       model->lineStripCount++;

       for(j=0;j<model->objVertexList[v0].edgesNum;j++){
            if(model->objVertexList[v0].edges[j]==edgeBase){
              model->objVertexList[v0].edges[j]=-1;
              break;
            }
       }
       for(j=0;j<model->objVertexList[v1].edgesNum;j++){
            if(model->objVertexList[v1].edges[j]==edgeBase){
              model->objVertexList[v1].edges[j]=-1;
              break;
            }
       }

      model->eadgeList[i][0]=-1;

      do{
           foundMatch=0;
           for(j=0;j<model->objVertexList[v1].edgesNum;j++){
//寻找没有使用的边界           
           if(model->objVertexList[v1].edges[j]!=-1){
               if(model->eadgeList[model->objVertexList[v1].edges[j]][0]!=-1){
                   foundMatch=1;
                   k=model->objVertexList[v1].edges[j]=-1;
                   if(model->eadgeList[k][0]==v1){
//寻找该边界的颜色
                   model->lineStripList[model->lineStripCount].colorIndex=0;
                   for(m=0;m<model->colorCount;m++){
                        if(model->objVertexList[
                              model->eadgeList[k][1]].vertexIndex<=
                                  model->colorList[m].index){
                              model->lineStripList[
                                   model->lineStripCount].colorIndex=m-1;
                              break;
                         }
                    }

                 model->lineStripList[model->lineStripCount].draw=1;
                 model->lineStripList[model->lineStripCount].x=
                      model->objVertexList[model->eadgeList[k][1]].x;
                 model->lineStripList[model->lineStripCount].y=
                      model->objVertexList[model->eadgeList[k][1]].y;
                 model->lineStripList[model->lineStripCount].z=
                      model->objVertexList[model->eadgeList[k][1]].z;
                 model->lineStripCount++;
                 v1=model->eadgeList[k][1];
                 }
             else{
//寻找该边界的颜色
                 model->lineStripList[model->lineStripCount].colorIndex=0;
                 for(m=0;m<model->colorCount;m++){
                        if(model->objVertexList[
                              model->eadgeList[k][0]].vertexIndex<=
                                  model->colorList[m].index){
                              model->lineStripList[
                                   model->lineStripCount].colorIndex=m-1;
                              break;
                         }
                    } 
                          
                 model->lineStripList[model->lineStripCount].draw=1;
                 model->lineStripList[model->lineStripCount].x=
                      model->objVertexList[model->eadgeList[k][0]].x;
                 model->lineStripList[model->lineStripCount].y=
                      model->objVertexList[model->eadgeList[k][0]].y;
                 model->lineStripList[model->lineStripCount].z=
                      model->objVertexList[model->eadgeList[k][0]].z;
                 model->lineStripCount++;
                 v1=model->eadgeList[k][0];
                 } 
                 model->eadgeList[k][0]=-1;
                 break;
                 }
              }
           }
      }while(foundMatch!=0);
     }while(edgeBase<model->edgeCount);
     model->lineStripList[model->lineStripCount].draw=0;
}
   fclose(datafile);
   free(materials);
                
}



FILE *COBJFileRead::fileOpen(const char *filename,const char *mode)
{
   FILE *retVal;
   retVal=fopen(filename, mode);
        if(retVal!=NULL)   return retVal;
        return NULL;
}


MaterialColor *COBJFileRead::readMaterials(char *FileName)
{
    FILE *mtlFile;            //需要读入的材质文件
    char inputLine[256];      //输入线
    MaterialColor *matPtr;    //分配空间
    int i;                    //数组索引
    int count;                //读入的数量
    GLfloat r,g,b;            //读入的颜色
    GLfloat spec;             //读入的高光值

    char MaterialName[256];
    strcpy(MaterialName,FileName);
    int index=strlen(FileName);
    strncpy(MaterialName+(index-3),"mtl",3);

    mtlFile=fileOpen(MaterialName,"r");
    if(mtlFile==NULL){
      fprintf(stderr,"Error,could not open 'Materials.mtl',exiting\n");
      return NULL;
      }

    matPtr=(MaterialColor *)malloc(100*sizeof(MaterialColor));

    i=-1;
    for(;;){
      if(fgets(inputLine,250,mtlFile)==NULL)
          break;                //文件结尾

      if(strncmp("newmtl",inputLine,6)==0){
         i++;
         sscanf(&inputLine[7],"%s",matPtr[i].name);
         }
      else if(strncmp("Ka",inputLine,2)==0){
         count=sscanf(inputLine,"Ka %f %f %f",&r,&g,&b);
         if(count!=3)
            continue;
         matPtr[i].ra=r;
         matPtr[i].ga=g;
         matPtr[i].ba=b;
         }
      else if(strncmp("Kd",inputLine,2)==0){
         count=sscanf(inputLine,"Kd %f %f %f",&r,&g,&b);
         if(count!=3)
            continue;
         matPtr[i].rd=r;
         matPtr[i].gd=g;
         matPtr[i].bd=b;
         matPtr[i].ad=1.0;
         }       
      else if(strncmp("Ks",inputLine,2)==0){
         count=sscanf(inputLine,"Ks %f %f %f",&r,&g,&b);
         if(count!=3)
            continue;
         matPtr[i].rs=r;
         matPtr[i].gs=g;
         matPtr[i].bs=b;
         }
      else if(strncmp("Ns",inputLine,2)==0){
         count=sscanf(inputLine,"Ns %f",&spec);
         if(count!=1)
            continue;
         matPtr[i].spec=spec;
         }              
       }
      i++;

      matPtr[i].name[0]=0;
      matPtr[i].ra=0.0f;
      matPtr[i].ga=0.1f;
      matPtr[i].ba=0.0f;
      matPtr[i].rd=0.2f;
      matPtr[i].gd=1.0f;
      matPtr[i].bd=0.0f;
      matPtr[i].ad=1.0f;
      matPtr[i].rs=1.0f;
      matPtr[i].gs=0.8f;
      matPtr[i].bs=0.0f;
      matPtr[i].spec=25.0f;

     return matPtr;

}