Mesh_object_loader.cpp

Go to the documentation of this file.

#include <Mesh_object_loader.h>


Mesh_object_loader::Mesh_object_loader(){}
Mesh_object_loader::~Mesh_object_loader(){}



int Mesh_object_loader::load_obj_texture(const std::string& filename,Mesh_object* mesh) const
{


  //1. Read texture vector

#define SIZE_BUFFER 2048
  char buffer[SIZE_BUFFER]={'\0'};
  char buffer2[SIZE_BUFFER]={'\0'};
  
  FILE *fid=NULL;
  fid=fopen(filename.data(),"r");
  if(fid==NULL)
    {printf("ERROR loading %s in load_obj_texture in Mesh_object_helper\n",filename.data());exit(-1);}
  
  float X[2];
  while(fscanf(fid,"%s",buffer)!=EOF)
    {
      if(strcmp(buffer,"vt")==0)
        {
          if(fscanf(fid,"%f %f\n",X,X+1)!=2)
            {printf("Error reading texture in load_obj_texture in Mesh_object_loader\n");exit(-1);}
          mesh->add_intermediate_texture(X[0],X[1]);
        }
      else //read the whole line
        fgets(buffer,sizeof(buffer),fid);
    }


  rewind(fid);

  //2. now read the indexed texture

  std::vector <int> poly;
  int ct=0;
  int one=-1;
  while(fscanf(fid,"%s",buffer)!=EOF)
    {
      switch(buffer[0])
        {
        case 'f': //polygon faces
          poly.resize(0);
          strcpy(buffer2,"\0");
          fscanf(fid,"%s",buffer2);

          if(sscanf(buffer2,"%*d/%d/%*d",&ct)==1)
            {
              poly.push_back(ct+one);
              while(fscanf(fid,"%*d/%d/%*d",&ct)==1)
                poly.push_back(ct+one);
              mesh->add_polygon_texture(poly);
            }
          else if(sscanf(buffer2,"%*d/%d",&ct)==1)
            {
              poly.push_back(ct+one);
              while(fscanf(fid,"%d/%*d",&ct)==1)
                poly.push_back(ct+one);
              mesh->add_polygon_texture(poly);
            }
          else //read the whole line
            fgets(buffer,sizeof(buffer),fid);
          break;
        }
    }





  if(fclose(fid)!=0)
    {printf("ERROR closing %s in load_obj_texture in Mesh_object_loader\n",filename.data());exit(-1);}
  return 0;
}

int Mesh_object_loader::load_obj_texture(const char* filename,Mesh_object* mesh) const
{std::string file=filename;return load_obj_texture(file,mesh);}



int Mesh_object_loader::load_collada_texture(const std::string& filename,Mesh_object* mesh,const std::string& name,const std::string& texture_source) const
{

  TiXmlDocument doc(filename);
  if(!doc.LoadFile())
    {
      printf("ERROR opening %s\n",filename.data());
      cerr << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc() << endl;
      exit(-1);
    }
  
  //find library_geometries
  TiXmlHandle root(doc.RootElement());
  TiXmlNode *lib_geometry=NULL;lib_geometry=root.ToNode();
  if(lib_geometry==NULL)
    {printf("Error reading file %s in load_collada_texture in Connectivity\n",filename.data());exit(-1);}


  //go to library_geometries entry
  lib_geometry = lib_geometry->FirstChild("library_geometries");


  if(lib_geometry==NULL)
    {printf("Error in file %s, cannot find library_geometries in load_collada_texture in Mesh_object_loader\n",filename.data());exit(-1);}


  TiXmlNode* geometry=NULL;
  geometry=lib_geometry->FirstChild("geometry");
  if(geometry==NULL)
    {printf("Error in gile %s, cannot find geometry in load_collada_texture in Mesh_object_loader\n",filename.data());exit(-1);}

  std::string geometry_id;
  int is_find=0;
  do
    {
      if(geometry->ToElement()->Attribute("id")==NULL)
        {printf("Error in file %s, geometry does not have id \n",filename.data());exit(-1);}
      geometry_id = geometry->ToElement()->Attribute("id");
      if(geometry_id==name || name=="_ALL_")
        {
          load_collada_mesh_texture(geometry,mesh,filename,texture_source);
          if(name!="_ALL_")
            is_find=1;
        }
      geometry=geometry->NextSiblingElement("geometry");
    }while(geometry!=NULL && is_find==0);


  int N_polygon_texture=mesh->get_texture_polygon_number();
  int N_polygon=mesh->polygon_number();
  if(N_polygon!=N_polygon_texture)
    {printf("Error in load_collada_texture in Mesh_object_loader for file %s, N_polygon=%d and N_texture_polygon=%d, loading texture failed\n",filename.data(),N_polygon,N_polygon_texture);exit(-1);}


  return 0;
}

int Mesh_object_loader::load_collada_mesh_texture(TiXmlNode* geometry_node,Mesh_object* mesh,const std::string& filename,const std::string& texture_source) const
{

  TiXmlNode *mesh_node=NULL;

  mesh_node=geometry_node->FirstChild("mesh");
  //need to find mesh
  if(mesh_node==NULL)
    {printf("Error in Connectivity in load_collada_mesh_connectivity for file %s\n",filename.data());exit(-1);}


  //*************************************//
  //try to load a source double 
  //*************************************//

  TiXmlNode* source_node=NULL;
  source_node=mesh_node->FirstChild("source");


  std::string name_source;
  std::vector <double> array_texture;

  int to_continue=1;

  int count=0;
  int N_texture=0;
  do
    {

      if(source_node->ToElement()->Attribute("name")==NULL)
        {printf("Error in Mesh_object_loader in load_collada_mesh_texture for file %s, no name attribute for source entry\n",filename.data());exit(-1);}
      name_source = source_node->ToElement()->Attribute("id");

      if(name_source==texture_source)
        {
          array_texture=load_collada_float_array(source_node,filename);
          to_continue=0;
          
          N_texture = array_texture.size();
          if(N_texture%2!=0)
            {printf("Error in Mesh_object_loader, in load_collada_texture, N_texture does not divide by two \n ");exit(-1);}

          for(count=0;count<N_texture/2;count++)
            mesh->add_intermediate_texture(array_texture[2*count+0],array_texture[2*count+1]);


        }
      
      source_node=source_node->NextSiblingElement("source");

    }while(source_node!=NULL && to_continue==1);
  



  //*************************************//
  //Load texture in polylists
  //*************************************//

  TiXmlNode* polylist_node=NULL;
  polylist_node=mesh_node->FirstChild("polylist");
  while(polylist_node!=NULL)
    {
      load_polylist_texture(polylist_node,mesh,filename,texture_source);
      
      polylist_node=polylist_node->NextSiblingElement("polylist");
    };

  //*************************************//
  //Load texture in triangles
  //*************************************//

  TiXmlNode* triangles_node=NULL;
  triangles_node=mesh_node->FirstChild("triangles");
  while(triangles_node!=NULL)
    {
      load_triangles_texture(triangles_node,mesh,filename,texture_source);
      
      triangles_node=triangles_node->NextSiblingElement("triangles");
    };

  return 0;
}



std::vector <double> Mesh_object_loader::load_collada_float_array(TiXmlNode *mesh_source,const std::string& filename) const
{
  TiXmlElement *float_array_node=NULL;
  float_array_node = mesh_source->FirstChild("float_array")->ToElement();
  if(float_array_node==NULL)
    {printf("Error cannot find float_array in load_collada_float_array in Point_set in file %s\n",filename.data());exit(-1);}
  
  int count=0;
  float_array_node->QueryIntAttribute("count",&count);
  if(float_array_node->FirstChild()==NULL)
    {printf("Error in load_collada_float_array in Point_set in file %s\n",filename.data());exit(-1);}
  std::string full_array = float_array_node->FirstChild()->ToText()->ValueStr();

  //fill vector array
  std::vector <double> array;
  int c=0,k1=0,k0=0;
  string X;
  for(c=0;c<count;c++)
    {
      k1= full_array.find(" ",k1+1);
      X = full_array.substr(k0,k1-k0);
      array.push_back(atof(X.data())); //add vertex
      k0=k1+1;
    }

  return array;
}

int Mesh_object_loader::load_polylist_texture(TiXmlNode* polylist_node,Mesh_object *mesh,const std::string& filename,const std::string& texture_source) const
{
  

  TiXmlNode* input_node=NULL;
  //Try to find TEXCOORD

  input_node=polylist_node->FirstChild("input");
  if(input_node==NULL)
    {printf("Error in load_polylist_connectivity of file %s, no input entry in the polylist source\n",filename.data());exit(-1);}

  int total_offset=0,vertex_offset=-1;
  std::string semantic_string;
  std::string source_string;
  std::string pointer_texture_source="#";pointer_texture_source+=texture_source;
  
  while(input_node!=NULL)
    {
      if(input_node->ToElement()->Attribute("semantic")==NULL)
        {printf("Error in load_polylist_texture for file %s, no semantic entry in input of polylist\n",filename.data());exit(-1);}
      if(input_node->ToElement()->Attribute("source")==NULL)
        {printf("Error in load_polylist_texture for file %s, no source name entry in input of polylist\n",filename.data());exit(-1);}

      semantic_string= input_node->ToElement()->Attribute("semantic");
      source_string  = input_node->ToElement()->Attribute("source");

      if(semantic_string=="TEXCOORD" && source_string==pointer_texture_source)
        {
          //get the offset of the input
          if(input_node->ToElement()->QueryIntAttribute("offset",&vertex_offset)!=TIXML_SUCCESS)
            {printf("Error in load_polylist_texture, offset vertex is wrong for file %s in Mesh_object_loader\n",filename.data());exit(-1);}
        }
      total_offset++;
      input_node=input_node->NextSiblingElement("input");
      
    };



  //load the <vcount>
  TiXmlNode* vcount_node=NULL;
  vcount_node=polylist_node->FirstChild("vcount");
  if(vcount_node==NULL)
    {printf("Error, no vcount found in polylist in file %s in Connectivity\n",filename.data());exit(-1);}
  std::vector <int> vcount_entry=load_collada_int_entry(vcount_node);

  //check polylist count
  int polylist_count=0;
  if(polylist_node->ToElement()->QueryIntAttribute("count",&polylist_count)!=TIXML_SUCCESS)
    {printf("Error in polylist in Mesh_object_loader for file %s, no count in polylist\n",filename.data());exit(-1);}
  if(polylist_count!=int(vcount_entry.size()))
    {printf("Error in file %s in Mesh_object_loader, in loading polylist: size(vcount)=%d and given size=%d\n",filename.data(),vcount_entry.size(),polylist_count);exit(-1);}



  // load the <p>
  TiXmlNode* p_node=NULL;
  p_node=polylist_node->FirstChild("p");
  if(p_node==NULL)
    {printf("Error, no <p> found in polylist in file %s in Mesh_object_loader in load_texture\n",filename.data());exit(-1);}
  std::vector <int> p_entry=load_collada_int_entry(p_node);


  std::vector <int> texture_array;
  int count=0;
  for(int k_poly=0;k_poly<polylist_count;k_poly++)
    for(int k_vertex=0;k_vertex<vcount_entry[k_poly];k_vertex++)
      for(int k_offset=0;k_offset<total_offset;k_offset++)
        {
          if(k_offset==vertex_offset)
            texture_array.push_back(p_entry[count]);
          count++;
        }

      

  
  //add the index_texture_polygon
  std::vector <int> current_polygon;
  int k_polygon=0,k_index=0;
  count=0;
  for(k_polygon=0;k_polygon<polylist_count;k_polygon++)
    {
      current_polygon.resize(0);
      for(k_index=0;k_index<vcount_entry[k_polygon];k_index++,count++)
        current_polygon.push_back(texture_array[count]);
      mesh->add_polygon_texture(current_polygon);
    }
  
  
  
  
  return 0;
}


std::vector <int> Mesh_object_loader::load_collada_int_entry(TiXmlNode* vcount_node) const
{
  std::vector <int> vcount_entry;
  if(vcount_node==NULL)
    {printf("Error in load_collada_vcount_entry in Connectivity, pointer is null\n");exit(-1);}
  if(vcount_node->FirstChild()==NULL)
    {printf("Error no child in load_collada_vcount_entry in Connectivity\n");exit(-1);}
  //convert entry to text
  std::string full_string = vcount_node->FirstChild()->ToText()->ValueStr();

  //fill the entry
  int k1=0,k0=0;
  string X;
  do
    {
      k1= full_string.find(" ",k1+1);
      X = full_string.substr(k0,k1-k0);
      vcount_entry.push_back(atoi(X.data())); //add index
      k0=k1+1;
    }while(k1>0);

  return vcount_entry;
} 






int Mesh_object_loader::load_triangles_texture(TiXmlNode* triangles_node,Mesh_object *mesh,const std::string& filename,const std::string& texture_source) const
{
  

  TiXmlNode* input_node=NULL;
  //Try to find TEXCOORD

  input_node=triangles_node->FirstChild("input");
  if(input_node==NULL)
    {printf("Error in load_triangles_connectivity of file %s, no input entry in the polylist source\n",filename.data());exit(-1);}

  int total_offset=0,vertex_offset=-1;
  std::string semantic_string;
  std::string source_string;
  std::string pointer_texture_source="#";pointer_texture_source+=texture_source;
  
  while(input_node!=NULL)
    {
      if(input_node->ToElement()->Attribute("semantic")==NULL)
        {printf("Error in load_triangles_texture for file %s, no semantic entry in input of triangles\n",filename.data());exit(-1);}
      if(input_node->ToElement()->Attribute("source")==NULL)
        {printf("Error in load_triangles_texture for file %s, no source name entry in input of triangles\n",filename.data());exit(-1);}

      semantic_string= input_node->ToElement()->Attribute("semantic");
      source_string  = input_node->ToElement()->Attribute("source");

      if(semantic_string=="TEXCOORD" && source_string==pointer_texture_source)
        {
          //get the offset of the input
          if(input_node->ToElement()->QueryIntAttribute("offset",&vertex_offset)!=TIXML_SUCCESS)
            {printf("Error in load_triangles_texture, offset vertex is wrong for file %s in Mesh_object_loader\n",filename.data());exit(-1);}
        }
      total_offset++;
      input_node=input_node->NextSiblingElement("input");
      
    };






  // load the <p>
  TiXmlNode* p_node=NULL;
  p_node=triangles_node->FirstChild("p");
  if(p_node==NULL)
    {printf("Error, no <p> found in polylist triangles in file %s in Mesh_object_loader in load_texture\n",filename.data());exit(-1);}
  std::vector <int> p_entry=load_collada_int_entry(p_node);


  int triangle_count=0;
  if(triangles_node->ToElement()->QueryIntAttribute("count",&triangle_count)!=TIXML_SUCCESS)
    {printf("Error in load_triangles_texture in Mesh_object_loader for file %s, no count in triangles\n",filename.data());exit(-1);}


  std::vector <int> texture_array;
  int count=0;
  for(int k_poly=0;k_poly<triangle_count;k_poly++)
    for(int k_vertex=0;k_vertex<3;k_vertex++)
      for(int k_offset=0;k_offset<total_offset;k_offset++)
        {
          if(k_offset==vertex_offset)
            texture_array.push_back(p_entry[count]);
          count++;
        }

      

  if(3*triangle_count!=int(texture_array.size()))
    {printf("Error in file %s in load_triangles_texture in Mesh_object_loader, size(texture_array)=%d and given size=3x%d=%d\n",filename.data(),texture_array.size(),triangle_count,3*triangle_count);exit(-1);}


  
  //add the index_texture_polygo
  std::vector <int> current_polygon;
  int k_polygon=0,k_index=0;
  count=0;
  for(k_polygon=0;k_polygon<triangle_count;k_polygon++)
    {
      current_polygon.resize(0);
      for(k_index=0;k_index<3;k_index++,count++)
        current_polygon.push_back(texture_array[count]);
      mesh->add_polygon_texture(current_polygon);
    }
  
  
  
  
  return 0;
}