File_parser.cpp

Go to the documentation of this file.

#include <File_parser.h>
#define PI 3.14159
#define SIZE_BUFFER 1024
#define DEBUG 1

File_parser::File_parser()
{
}

File_parser::~File_parser()
{
}





int File_parser::load_collada_skeleton(const char* filename,const char* skeleton_name,Skeleton *skeleton) const
{
  skeleton->reccursive_destroy();

#ifdef DEBUG
  printf("\n[Load skeleton %s ...]\n",filename);
#endif


  TiXmlDocument doc(filename);
  if(!doc.LoadFile())
    {
      printf("ERROR opening %s\n",filename);
      cerr << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc() << endl;
      exit(-1);
    }
  
  TiXmlHandle visual_scenes(doc.RootElement());
  visual_scenes = visual_scenes.FirstChild("library_visual_scenes").FirstChild("visual_scene");
  if(visual_scenes.ToNode()==NULL)
    {printf("ERROR cannot find visual_scenes for skeleton in file %s\n",filename);exit(-1);}


#ifdef DEBUG
  printf("[find skeleton visual scene id[%s] named %s]\n",visual_scenes.ToElement()->Attribute("id"),visual_scenes.ToElement()->Attribute("name"));
#endif


  std::string name;
  TiXmlHandle node(visual_scenes);
  node = node.FirstChild("node");
  TiXmlElement *look_for_skeleton_name=NULL;
  look_for_skeleton_name = node.ToElement();
  if(look_for_skeleton_name->Attribute("name")!=NULL)
    name = look_for_skeleton_name->Attribute("name");


  while( (look_for_skeleton_name!=NULL) && (name!=skeleton_name) )
    {
      look_for_skeleton_name = look_for_skeleton_name->NextSiblingElement();
      if( (look_for_skeleton_name!=NULL) && look_for_skeleton_name->Attribute("name")!=NULL)
        name = look_for_skeleton_name->Attribute("name");
    }


  if(look_for_skeleton_name==NULL)
    {printf("Error cannot find %s in file %s\n",skeleton_name,filename);exit(-1);}
#ifdef DEBUG
  printf("[Find skeleton %s]\n",skeleton_name);
#endif

  name = look_for_skeleton_name->Attribute("id");


  Joint *current = skeleton->get_root();
  if(current==NULL)
    {printf("ERROR root_node is null in loading new skeleton\n"),exit(-1);}

  current->set_name(name);
  if(look_for_skeleton_name->Attribute("sid")==NULL)
    {current->set_weight_name("_N0_WEIGHT_");}
  else
    {current->set_weight_name(look_for_skeleton_name->Attribute("sid"));}


  TiXmlHandle starting_node(look_for_skeleton_name);
  reccursive_skeleton_collada_reading_node(starting_node,current);


  skeleton->read_skeleton();
  skeleton->precalculate_matrix();
  skeleton->init_time_animation();

#ifdef DEBUG
  printf("[SKELETON %s LOADED]\n\n",filename);
#endif

  return 0;
}

int File_parser::reccursive_skeleton_collada_reading_node(TiXmlHandle &current_node,Joint *current) const
{

  int k0=0,k1=0,count=0;
  std::string X;

  TiXmlHandle child(current_node);
  TiXmlElement *e_child=NULL;
  

  e_child = child.FirstChild().ToElement();

  if(e_child==NULL)
    {printf("ERROR no child to node named %s\n",current->get_name());exit(-1);}

  while(e_child!=NULL)
    {
      if(e_child->ValueStr()=="rotate")
        {
          if((e_child->Attribute("sid"))==NULL)
            {printf("Error no attribute sid in child rotate in node %s\n",current->get_name());exit(-1);}
          std::string rotation;
          rotation = e_child->Attribute("sid");
          
          std::string rotation_data_str;
          std::vector <double> rotation_data;
          
          if(e_child->FirstChild()==NULL)
            {printf("ERROR no data in rotation for node %s\n",current->get_name());exit(-1);}
          
          rotation_data_str = e_child->FirstChild()->ValueStr();
          
          count=0;k0=0;k1=0;
          rotation_data.resize(0);
          for(count=0;count<4;count++)
            {
              k1=rotation_data_str.find(" ",k1+1);
              X = rotation_data_str.substr(k0,k1-k0);
              rotation_data.push_back(atof(X.data()));
              k0=k1+1;
            }
          
          //rotate
          current->add_rotation(rotation_data[0],rotation_data[1],rotation_data[2],rotation_data[3]*PI/180);
          
        }
      else if(e_child->ValueStr()=="translate")
        {

          std::string translation_data_str;
          std::vector <double> translation_data;
          
          if(e_child->FirstChild()==NULL)
            {printf("ERROR no data in translation for node %s\n",current->get_name());exit(-1);}
          
          translation_data_str = e_child->FirstChild()->ValueStr();
          
          count=0;k0=0;k1=0;
          translation_data.resize(0);
          for(count=0;count<3;count++)
            {
              k1=translation_data_str.find(" ",k1+1);
              X = translation_data_str.substr(k0,k1-k0);
              translation_data.push_back(atof(X.data()));
              k0=k1+1;
            }

          //translate
          current->add_position(translation_data[0],translation_data[1],translation_data[2]);

        }
      else if(e_child->ValueStr()=="scale")
        {

          std::string scale_data_str;
          std::vector <double> scale_data;
          
          if(e_child->FirstChild()==NULL)
            {printf("ERROR no data in translation for node %s\n",current->get_name());exit(-1);}
          
          scale_data_str = e_child->FirstChild()->ValueStr();
          
          count=0;k0=0;k1=0;
          scale_data.resize(0);
          for(count=0;count<3;count++)
            {
              k1=scale_data_str.find(" ",k1+1);
              X = scale_data_str.substr(k0,k1-k0);
              scale_data.push_back(atof(X.data()));
              k0=k1+1;
            }

          //scale
          current->scale(scale_data[0],scale_data[1],scale_data[2]);


        }
      else if(e_child->ValueStr()=="matrix")
        {
          std::string matrix_data_str;
          std::vector <double> matrix_data;
          
          if(e_child->FirstChild()==NULL)
            {printf("ERROR no data in translation for node %s\n",current->get_name());exit(-1);}
          
          matrix_data_str = e_child->FirstChild()->ValueStr();
          
          count=0;k0=0;k1=0;
          matrix_data.resize(0);
          for(count=0;count<16;count++)
            {
              k1=matrix_data_str.find(" ",k1+1);
              X = matrix_data_str.substr(k0,k1-k0);
              matrix_data.push_back(atof(X.data()));
              k0=k1+1;
            }

          //scale
          Matrix M;
          M.set_value(matrix_data[0],matrix_data[1],matrix_data[2],matrix_data[3],matrix_data[4],matrix_data[5],matrix_data[6],matrix_data[7],matrix_data[8],matrix_data[9],matrix_data[10],matrix_data[11],matrix_data[12],matrix_data[13],matrix_data[14],matrix_data[15]);
          current->set_matrix(M);

        }
      else if(e_child->ValueStr()=="node")
        {
          current->add_son();
          if(e_child->Attribute("id")==NULL)
            {printf("Error no name for child of node %s\n",current->get_name());exit(-1);}
          current->get_son(0)->set_name(e_child->Attribute("id"));
          if(e_child->Attribute("sid")==NULL)
            {current->get_son(0)->set_weight_name("_NO_WEIGHT_");}
          else
            {current->get_son(0)->set_weight_name(e_child->Attribute("sid"));}
#ifdef DEBUG
          //printf("[find skeleton node <%s>]\n",current->get_name());
#endif

          TiXmlHandle new_child(e_child);
          reccursive_skeleton_collada_reading_node(new_child,current->get_son(0));
        }
      
      
      e_child = e_child->NextSiblingElement();
    }
  
  return 0;
}

int File_parser::save_skeleton_sk(const char* filename,Skeleton &skeleton) const
{

  //just in case
  skeleton.read_skeleton();
  skeleton.precalculate_matrix();


    //save obj format
  FILE *fid=NULL;
  
  char name_skeleton[SIZE_BUFFER];
  strcpy(name_skeleton,filename);
  strcat(name_skeleton,".sk");
  fid = fopen(name_skeleton,"w");


  if(fid==NULL)
    {
      cout<<"ERROR opening file "<<name_skeleton<<endl;
      return -1;
    }
  
  fprintf(fid,"# skinning model %s\n",name_skeleton);
  fprintf(fid,"# skeleton model\n");
  fprintf(fid,"# N_joint= %d \n",skeleton.get_N_joint());

  fprintf(fid,"#\n# Visual Hierarchy [level] name (id_number) <father: id_father> [number_of_son s: id_sons ...]\n#\n");

  int count=0;
  int k_joint=0;
  Joint *current=NULL;
  for(k_joint=0;k_joint<skeleton.get_N_joint();k_joint++)
    {
      current = skeleton.get_joint(k_joint);
      fprintf(fid,"# ");
      for(count=0;count<current->get_level();count++)
        fprintf(fid,"  ");
      //fprintf(fid,"<%s> (%d)\n ",current->get_name(),current->get_access_number());
      fprintf(fid," [%d] <%s> (%d)  \t\t\t <f:%d> [%d s: ",current->get_level(),current->get_name(),current->get_access_number(),current->get_father()->get_access_number(),current->get_N_son());
      for(count=0;count<current->get_N_son();count++)
        fprintf(fid,"%d ",current->get_son(current->get_N_son()-count-1)->get_access_number());
      fprintf(fid,"]\n");
    }
  fprintf(fid,"#\n");

  if(fclose(fid)!=0)
    {
      cout<<"WARNING ERROR closing file"<<name_skeleton<<endl;
      exit(-1);
    }
  return 0;

}


int File_parser::load_collada_animation(const char* filename,Skeleton *skeleton) const 
{



#ifdef DEBUG
  printf("\n[Load animation skeleton %s ...]\n",filename);
#endif

  TiXmlDocument doc(filename);
  if(!doc.LoadFile())
    {
      printf("ERROR opening %s\n",filename);
      cerr << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc() << endl;
      exit(-1);
    }
  
  TiXmlHandle library_animations(doc.RootElement());
  library_animations = library_animations.FirstChild("library_animations");
  if(library_animations.ToNode()==NULL)
    {printf("ERROR cannot find library_animations for skeleton in file %s\n",filename);exit(-1);}
  
  TiXmlHandle animation(library_animations);
  animation = animation.FirstChild("animation");
  
  TiXmlElement *anim_element=NULL;

  TiXmlElement *anim_input=NULL;
  TiXmlElement *anim_output=NULL;
  std::string anim_description;
  string::size_type location;

  std::string anim_name;


  std::string anim_body_part;
  std::string anim_action;

  
  std::string anim_input_str;
  std::vector <double> anim_input_data;
  std::string anim_output_str;
  std::vector <double> anim_output_data;
  std::string X;

  int k0=0;
  int num_joint=0;

  int k1=0;
  int vector_count=0;
  int count;

  anim_element = animation.ToElement();
  if(anim_element==NULL)
    {printf("Error cannot find animation in library_animation\n");exit(-1);}


  int stride_accessor=0;
  std::string accessor_type;

  while(anim_element!=NULL)
    {
      if(anim_element->Attribute("id")==NULL)
        {printf("Error cannot find animation id in animation\n");exit(-1);}
      anim_name = anim_element->Attribute("id");
      
      //separates name.action
      k0 = anim_name.rfind(".");
      if(k0==-1)//try name_action
        k0 = anim_name.rfind("_");
      if(k0==-1)
        k0 = anim_name.rfind("-");
      if(k0==-1)
        {printf("ERROR cannot find separator for action type in %s\n",anim_name.data());exit(-1);}
      


      anim_body_part = anim_name.substr(0,k0);
      anim_action = anim_name.substr(k0+1,anim_name.length()-k0-1);

//       //try to find name-node
//       int k3=0;
//       k3 = anim_body_part.rfind("-node");
//       if(k3!=-1)
//      anim_body_part = anim_name.substr(0,k3);

      //get access number of the name
      num_joint = skeleton->get_access_number_of_joint_named(anim_body_part);
      //if(num_joint>0)
        {


#ifdef DEBUG
      printf("find [%s](%d) with action [%s]\n",anim_body_part.data(),num_joint,anim_action.data());
#endif 

      //find input
      //**********************//

      anim_input = anim_element->FirstChild("source")->ToElement();
      if(anim_input == NULL)
        {printf("Error no source child in animation with id[%s]\n",anim_name.data());exit(-1);}

 
      do
        {
          if(anim_input->Attribute("id")==NULL)
            {printf("Error no id in source for animation id[%s]\n",anim_name.data());exit(-1);}
          anim_description = anim_input->Attribute("id");
          location = anim_description.find("-input");
          if(location==string::npos)//not fing input
            anim_input = anim_input->NextSiblingElement();
        }while(anim_input!=NULL && location==string::npos);
        
        if(anim_input==NULL)
          {printf("ERROR cannot find input array for anim [%s]\n",anim_name.data());exit(-1);}

        if(anim_input->FirstChild("float_array") == NULL)
          {printf("Error no float_array in anim %s\n",anim_name.data());exit(-1);}
        if(anim_input->FirstChild("float_array")->ToElement()->Attribute("count")==NULL)
          {printf("Error no coutn attribute in float_array for anim %s\n",anim_name.data());exit(-1);}
        anim_input->FirstChild("float_array")->ToElement()->QueryIntAttribute("count",&vector_count);
        if(anim_input->FirstChild("float_array")->FirstChild() == NULL)
          {printf("Error no float_array data in anim %s\n",anim_name.data());exit(-1);}
        anim_input_str = anim_input->FirstChild("float_array")->FirstChild()->ValueStr();
        
        //set size
        skeleton->set_size_time(num_joint,vector_count);
        

        count=0;
        k0=0;
        k1=0;
        anim_input_data.resize(0);
        for(count=0;count<vector_count;count++)
          {
            k1=anim_input_str.find(" ",k1+1);
            X = anim_input_str.substr(k0,k1-k0);
            anim_input_data.push_back(atof(X.data()));

            //set time
            skeleton->set_time(num_joint,count,anim_input_data[count]);
            k0=k1+1;
          }




        //get output
        //**********************//
        
        anim_output = anim_element->FirstChild("source")->ToElement();
        if(anim_output == NULL)
          {printf("Error no source child in animation with id[%s]\n",anim_name.data());exit(-1);}


        do
          {
            if(anim_output->Attribute("id")==NULL)
              {printf("Error no id in source for animation id[%s]\n",anim_name.data());exit(-1);}
            anim_description = anim_output->Attribute("id");
            location = anim_description.find("-output");
            if(location==string::npos)//not fing input
              anim_output = anim_output->NextSiblingElement();
          }while(anim_output!=NULL && location==string::npos);
        
        if(anim_output==NULL)
          {printf("ERROR cannot find output array for anim [%s]\n",anim_name.data());exit(-1);}
        
        if(anim_output->FirstChild("float_array") == NULL)
          {printf("Error no float_array in anim %s\n",anim_name.data());exit(-1);}
        if(anim_output->FirstChild("float_array")->ToElement()->Attribute("count")==NULL)
          {printf("Error no coutn attribute in float_array for anim %s\n",anim_name.data());exit(-1);}
        anim_output->FirstChild("float_array")->ToElement()->QueryIntAttribute("count",&vector_count);
        if(anim_output->FirstChild("float_array")->FirstChild() == NULL)
          {printf("Error no float_array data in anim %s\n",anim_name.data());exit(-1);}
        anim_output_str = anim_output->FirstChild("float_array")->FirstChild()->ValueStr();
        
        if(anim_output->FirstChild("technique_common")==NULL)
          {printf("Error no technique_common found\n");exit(-1);}
        if(anim_output->FirstChild("technique_common")->FirstChild("accessor")==NULL)
          {printf("Error no accessor found\n");exit(-1);}
        if(anim_output->FirstChild("technique_common")->FirstChild("accessor")->ToElement()->Attribute("stride")==NULL)
          {printf("Error no stride found in accessor %s\n",anim_name.data());exit(-1);}
        
        anim_output->FirstChild("technique_common")->FirstChild("accessor")->ToElement()->QueryIntAttribute("stride",&stride_accessor);



        if(stride_accessor==1 && anim_action=="translate")
          {
            //look for what
            if(anim_output->FirstChild("technique_common")->FirstChild("accessor")->FirstChild("param")==NULL)
              {printf("ERROR cannot find param in accessor of animation %s\n",anim_name.data());exit(-1);}
            if(anim_output->FirstChild("technique_common")->FirstChild("accessor")->FirstChild("param")->ToElement()->Attribute("name")==NULL)
              {printf("ERROR cannot find name in param of accessor of animation %s\n",anim_name.data());exit(-1);}
            accessor_type = anim_output->FirstChild("technique_common")->FirstChild("accessor")->FirstChild("param")->ToElement()->Attribute("name");

            if(accessor_type=="X")
              {
                count=0;k0=0;k1=0;anim_output_data.resize(0);
                for(count=0;count<vector_count;count++)
                  {
                    k1=anim_output_str.find(" ",k1+1);
                    X = anim_output_str.substr(k0,k1-k0);
                    anim_output_data.push_back(atof(X.data()));
                    anim_output_data.push_back(0.0);
                    anim_output_data.push_back(0.0);
                    k0=k1+1;
                  }
              }
            else if(accessor_type=="Y")
              {
                count=0;k0=0;k1=0;anim_output_data.resize(0);
                for(count=0;count<vector_count;count++)
                  {
                    k1=anim_output_str.find(" ",k1+1);
                    X = anim_output_str.substr(k0,k1-k0);
                    anim_output_data.push_back(0.0);
                    anim_output_data.push_back(atof(X.data()));
                    anim_output_data.push_back(0.0);
                    k0=k1+1;
                  }
              }
            else if(accessor_type=="Z")
              {
                count=0;k0=0;k1=0;anim_output_data.resize(0);
                for(count=0;count<vector_count;count++)
                  {
                    k1=anim_output_str.find(" ",k1+1);
                    X = anim_output_str.substr(k0,k1-k0);
                    anim_output_data.push_back(0.0);
                    anim_output_data.push_back(0.0);
                    anim_output_data.push_back(atof(X.data()));
                    k0=k1+1;
                  }
              }
            else
              {printf("ERROR unknown accessor_type [%s] for anim %s\n",accessor_type.data(),anim_name.data());exit(-1);}


          }
        else//stride==3 for translate or rotateX/Y/Z or transform
          {
            count=0;
            k0=0;
            k1=0;
            anim_output_data.resize(0);
            for(count=0;count<vector_count;count++)
              {
                k1=anim_output_str.find(" ",k1+1);
                X = anim_output_str.substr(k0,k1-k0);
                anim_output_data.push_back(atof(X.data()));
                k0=k1+1;
              }
          }

        double c=1;

        if(anim_action=="rotateX")
          {
            for(count=0;count<vector_count;count++)
              skeleton->set_angle(num_joint,count,0,anim_output_data[count]*c);
          }
        else if(anim_action=="rotateY")
          {
            for(count=0;count<vector_count;count++)
              skeleton->set_angle(num_joint,count,1,anim_output_data[count]*c);
          }
        else if(anim_action=="rotateZ")
          {
            for(count=0;count<vector_count;count++)
              skeleton->set_angle(num_joint,count,2,anim_output_data[count]*c);
          }
        else if(anim_action=="translate")
          {
            if( (vector_count%3) !=0)
              {printf("something strange in size vector of translation for joint n.[%d] \n",num_joint);exit(-1);}

            for(count=0;count<vector_count/3;count++)
              skeleton->set_translate(num_joint,count,anim_output_data[3*count+0],anim_output_data[3*count+1],anim_output_data[3*count+2]);
          }
        else if(anim_action=="transform")
          {
            if( (vector_count%16) !=0)
              {printf("something strange in size matrix for joint n.[%d] \n",num_joint);exit(-1);}
            for(count=0;count<vector_count/16;count++)
              for(int k=0;k<16;k++)
                {
                  //printf("%d,%d,%d\n",num_joint,count,k);
                  skeleton->set_anim_matrix(num_joint,count,k,anim_output_data[16*count+k]);
                }
          }

        }

        anim_element = anim_element->NextSiblingElement();
    }


#ifdef DEBUG
  printf("[find library_animations]\n");
#endif




  printf("[ANIMATION SKELETON %s LOADED]\n\n",filename);

  

  return 0;
}

int File_parser::load_collada_skining_attribute(const char* filename, Skinned *skinned) const
{

  Skeleton *skeleton = skinned->get_skeleton();
  Mesh_object *mesh = skinned->get_mesh();


#ifdef DEBUG
  printf("\n[Load skinning attribute %s ...]\n",filename);
#endif

  TiXmlDocument doc(filename);
  if(!doc.LoadFile())
    {
      printf("ERROR opening %s\n",filename);
      cerr << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc() << endl;
      exit(-1);
    }
  
  TiXmlHandle library_animations(doc.RootElement());
  library_animations = library_animations.FirstChild("library_controllers");
  if(library_animations.ToNode()==NULL)
    {printf("ERROR cannot find library_controllers in file %s\n",filename);exit(-1);}
  
  TiXmlHandle skin(library_animations);
  skin = library_animations.FirstChild("controller").FirstChild("skin");
  if(skin.ToNode()==NULL)
    {printf("ERROR cannot find skin source in file %s\n",filename);exit(-1);}
  

  //NAME
  //****************************//


  TiXmlHandle name(skin);
  //try first IDREF
  name = skin.FirstChild("source").FirstChild("IDREF_array");  
  if(name.ToNode()==NULL)//if null try Name_array (new collada)
    {
      name = skin.FirstChild("source").FirstChild("Name_array");
      if(name.ToNode()==NULL)
        {printf("Error cannot find Name_array in source in library_controllers for skinning information in file %s\n",filename);exit(-1);}
    }
  if(name.FirstChild().ToNode()==NULL)
    {printf("Error cannot find name list in library_controllers for skinning information in file %s\n",filename);exit(-1);}

  if(name.ToElement()->Attribute("count")==NULL)
    {printf("Error cannot access to count attribute in name_list of skinning in file %s\n",filename);exit(-1);}

  int N_name_list=0;
  name.ToElement()->QueryIntAttribute("count",&N_name_list);

#ifdef DEBUG
  printf("[Find list of %d names]\n",N_name_list);
#endif

  std::string name_list_str;
  std::vector <std::string> name_list;
  
  name_list_str = name.FirstChild().ToText()->ValueStr();
  
  std::string X;
  int count=0;
  int k0=0;
  int k1=0;
  name_list.resize(0);
  for(count=0;count<N_name_list;count++)
    {
      k1 = name_list_str.find(" ",k1+1);
      X  = name_list_str.substr(k0,k1-k0);

//       //throw away -node
//       if((int)X.rfind("-node")!=-1)
//      X = X.substr(0,X.rfind("-node"));

      name_list.push_back(X);
      k0=k1+1;
    }

  

  //BIND POSE
  //****************************//
  TiXmlHandle bind(skin);
  int N;
  std::string look_for_bind;

  bind = skin.FirstChild("source");
  TiXmlElement *look_for_bind_element=NULL;
  look_for_bind_element = bind.ToElement();
  do
    {
      if(look_for_bind_element==NULL)
        {printf("Error can't find source for bind pose in file %s\n",filename);exit(-1);}

      look_for_bind=look_for_bind_element->Attribute("id");
      N = look_for_bind.rfind("-bind_poses");
      if(N<0)
        look_for_bind_element = look_for_bind_element->NextSiblingElement("source");
    }while(look_for_bind_element!=NULL && N<0);


  
  if(look_for_bind_element==NULL)
    {printf("Error can't find source for bind pose in file %s\n",filename);exit(-1);}

  TiXmlHandle bind_array(look_for_bind_element);  

  bind_array = bind_array.FirstChild("float_array");
  if(bind_array.ToNode()==NULL)
    {printf("Error cannot find float_array in source for bind_pose in file %s\n",filename);exit(-1);}

  int count_bind_pose=0;
  if(bind_array.ToElement()->Attribute("count")==NULL)
    {printf("Error cannot find count Attribute in float_array for bind pose in file %s\n",filename);exit(-1);}
  bind_array.ToElement()->QueryIntAttribute("count",&count_bind_pose);
  if(count_bind_pose%16!=0)
    {printf("Something strange in count_bind_pose in file %s\n",filename);exit(-1);}

  std::string bind_pose_str;
  std::vector <double> bind_pose_data;

  if(bind_array.FirstChild().ToNode()==NULL)
    {printf("Error no data in bind_array in file %s\n",filename);exit(-1);}
  bind_pose_str = bind_array.FirstChild().ToText()->ValueStr();

  
  
  count=0;k0=0;k1=0;
  int joint_number;
  Matrix M;
  for(count=0;count<count_bind_pose/16;count++)
    {
      joint_number = skeleton->get_access_number_of_joint_named(name_list[count]);
      //if(
         for(int count_21=0;count_21<4;count_21++)
           for(int count_22=0;count_22<4;count_22++)
             {
               k1=bind_pose_str.find(" ",k1+1);
               X = bind_pose_str.substr(k0,k1-k0);
               M.set_value(atof(X.data()),count_22,count_21);
               k0=k1+1;
             }
         skeleton->get_joint(joint_number)->set_bind_pose(M);
         // )
    }
  
      
  
  //SKINNING WEIGHT
  //****************************//

  TiXmlHandle weight(skin);
  std::string look_for_weight;

  weight = weight.FirstChild("source");
  TiXmlElement *look_for_weight_element=NULL;
  look_for_weight_element = weight.ToElement();
  do
    {
      if(look_for_weight_element==NULL)
        {printf("Error can't find source for skinning weights in file %s\n",filename);exit(-1);}

      look_for_weight = look_for_weight_element->Attribute("id");
      N = look_for_weight.rfind("-skin-weights");
      if(N<0)
        look_for_weight_element = look_for_weight_element->NextSiblingElement("source");
    }while(look_for_weight_element!=NULL && N<0);




  if(look_for_weight_element==NULL)
    {printf("Error can't find source for weight element in file %s\n",filename);exit(-1);}

  TiXmlHandle weight_array(look_for_weight_element);  

  weight_array = weight_array.FirstChild("float_array");
  if(weight_array.ToNode()==NULL)
    {printf("Error cannot find float_array in source for weight_array in file %s\n",filename);exit(-1);}

  int count_weight=0;
  if(weight_array.ToElement()->Attribute("count")==NULL)
    {printf("Error cannot find count Attribute in float_array for weight array in file %s\n",filename);exit(-1);}
  weight_array.ToElement()->QueryIntAttribute("count",&count_weight);

  std::string weight_str;

  if(weight_array.FirstChild().ToNode()==NULL)
    {printf("Error no data in weight_array in file %s\n",filename);exit(-1);}
  weight_str = weight_array.FirstChild().ToText()->ValueStr();



#ifdef DEBUG
  printf("[Find %d skinning weights]\n",count_weight);
#endif



  count=0;k0=0;k1=0;
  for(count=0;count<count_weight;count++)
    {
      k1=weight_str.find(" ",k1+1);
      X = weight_str.substr(k0,k1-k0);
      skinned->add_weight(atof(X.data()));
      k0=k1+1;
    }


  //Joint and weight list
  //****************************//

  TiXmlElement *vertex_weight=NULL;
  vertex_weight = skin.FirstChild("vertex_weights").ToElement();
  if(vertex_weight==NULL)
    {printf("Error cannot find vertex_weights in skin in library_controllers\n");exit(-1);}
  
  if(vertex_weight->Attribute("count")==NULL)
    {printf("Error cannot find attribute count in vertex_weights in library_controllers\n");exit(-1);}
  int N_vertex_weight=0;
  vertex_weight->QueryIntAttribute("count",&N_vertex_weight);
  
  if(N_vertex_weight!=skinned->get_mesh()->get_vertex_number())
    {printf("Error something strange in size of <vcount> of vertex_weight size[%d] in library_controllers for skinning link\n",N_vertex_weight);exit(-1);}

  TiXmlNode *vcount_size_vertex=NULL;
  vcount_size_vertex = vertex_weight->FirstChild("vcount");
  if(vcount_size_vertex==NULL)
    {printf("Error cannot find vcount in vertex_weights in library_controllers\n");exit(-1);}
  if(vcount_size_vertex->FirstChild()==NULL)
    {printf("Error no child in vcount for skinning dependencies\n");exit(-1);}

  std::string vcount_str;
  std::vector <int> dependencies_number;
  dependencies_number.resize(0);

  vcount_str = vcount_size_vertex->FirstChild()->ToText()->ValueStr();
  skinned->set_size_index_weight(mesh->get_vertex_number());

  count=0;k0=0;k1=0;
  for(count=0;count<N_vertex_weight;count++)
    {
      k1=vcount_str.find(" ",k1+1);
      X = vcount_str.substr(k0,k1-k0);
      dependencies_number.push_back(atoi(X.data()));
      //      skinned->set_size_index_weight(count,atoi(X.data()));
      k0=k1+1;
    }



  //INDEX
  //********************//



  TiXmlNode *vector_index_joint=NULL;
  vector_index_joint = vertex_weight->FirstChild("v");
  if(vector_index_joint==NULL)
    {printf("Error cannot find <v> vector of joint and weights index in skinning parameters\n");exit(-1);}

  std::string vector_index_str;
  std::vector <int> vector_index_joint_data;
  std::vector <int> vector_index_weight_data;

  if(vector_index_joint->FirstChild()==NULL)
    {printf("Error vector_index_joint has no child in skinning parameters in file %s\n",filename);exit(-1);}
  vector_index_str = vector_index_joint->FirstChild()->ToText()->ValueStr();


  //set size of index
  skinned->set_size_index_weight(mesh->get_vertex_number());
  skinned->set_size_index_joint(mesh->get_vertex_number());


  count=0;k0=0;k1=0;
  int k_size=0;
  int joint_number_pointed=0;
  for(count=0;count<N_vertex_weight;count++)
    {
      vector_index_joint_data.resize(0);
      vector_index_weight_data.resize(0);
      for(k_size=0;k_size<dependencies_number[count];k_size++)
        {

          //joint
          k1=vector_index_str.find(" ",k1+1);
          X = vector_index_str.substr(k0,k1-k0);
          //get_name of joint
          joint_number_pointed = skeleton->get_access_number_of_joint_named(name_list[atoi(X.data())]);

          vector_index_joint_data.push_back(joint_number_pointed);
          k0=k1+1;


          //weight
          k1=vector_index_str.find(" ",k1+1);
          X = vector_index_str.substr(k0,k1-k0);
          vector_index_weight_data.push_back(atoi(X.data()));
          k0=k1+1;
        }

      skinned->add_index_joint(count,vector_index_joint_data);
      skinned->add_index_weight(count,vector_index_weight_data);

    }
  
#ifdef DEBUG
  printf("[index joint and weight Loaded for %d vertices]\n",count);
#endif

  //reorder weights and index

  std::vector <double> new_weight;
  std::vector <int_vector> new_index_weights;
  std::vector <int_vector> new_index_bones;

  
  new_weight.resize(mesh->get_vertex_number()*skeleton->get_N_joint());
  new_index_weights.resize(mesh->get_vertex_number());
  new_index_bones.resize(mesh->get_vertex_number());

  int k_vertex=0;
  int k_joint=0;
  int k_v;

  for(k_vertex=0;k_vertex<mesh->get_vertex_number();k_vertex++)
    {

      for(k_v=0;k_v<skinned->get_size_index_weight(k_vertex);k_v++)
        new_weight[k_vertex+skinned->get_index_joint(k_vertex,k_v)*mesh->get_vertex_number()] = skinned->get_weight(k_vertex,k_v);
      
      new_index_weights[k_vertex].resize(skeleton->get_N_joint());
      new_index_bones  [k_vertex].resize(skeleton->get_N_joint());
      for(k_joint=0;k_joint<skeleton->get_N_joint();k_joint++)
        {
          new_index_weights[k_vertex][k_joint] = k_vertex+k_joint*mesh->get_vertex_number();
          new_index_bones  [k_vertex][k_joint] = k_joint;
        }

    }

  skinned->set_weight(new_weight);
  skinned->set_index_weight(new_index_weights);
  skinned->set_index_joint(new_index_bones);

  

  skinned->fill_vertex_depending_on_bone();

#ifdef DEBUG
  printf("[index joint and weight loaded and sorted by bones in Skinned with success]\n");
#endif
  


  
  printf("[SKINNING ATTRIBUTES %s LOADED]\n\n",filename);
  
  return 0;
}

int File_parser::load_old_sk_skeleton(const char *filename,Skeleton *skeleton) const
{

  if(skeleton==NULL){
    printf("Error skeleton not allowed\n");exit(-1);}

  FILE *fid=NULL;

  char name_skeleton[1024]={'\0'};
  strcpy(name_skeleton,filename);
  strcat(name_skeleton,".sk");

  fid = fopen(name_skeleton,"r");
  if(fid==NULL)
    {cout<<"ERROR opening file "<<name_skeleton<<endl;exit(-1);}
  

  char buffer[1024];

  int is_first=1;
  Joint *current_joint = skeleton->get_root();
  Joint *father=NULL;

  int level=0;
  int k=0;
  float value=0.0;
  Matrix M;


  while(fscanf(fid,"%s",buffer)!=EOF)
    {
      switch(buffer[0])
        {
        case '#'://comments
          fgets(buffer,1024,fid);
          break;
        case 'n'://new joint
          if(is_first!=1)
            {
              //fgets(buffer,1024,fid);//read rest of line
              current_joint->add_son();
              father = current_joint;
              current_joint = current_joint->get_son(0);
              level++;
            }
          is_first=0;
          break;
        case 'M'://matrix
          for(k=0;k<16;k++)
            {
              if(fscanf(fid,"%f",&value)!=1)
                {printf("ERROR reading matrix value in skeleton reading %f\n",value);exit(-1);}
              M.set_value(value,k,0);
            }
          current_joint->set_matrix(M);
          break;
        case 'B'://Bind Pose
          for(k=0;k<16;k++)
            {
              if(fscanf(fid,"%f",&value)!=1)
                {printf("ERROR reading matrix value in skeleton reading %f\n",value);exit(-1);}
              M.set_value(value,k,0);
            }
          current_joint->set_bind_pose(M);
          break;
        case '_':
          if(buffer[1]=='d' && buffer[2]=='n')
            {
              level--;
              if(current_joint->get_father()!=NULL)
                current_joint = current_joint->get_father();
            }
          break;
        }


    }  
  

  
  if(fclose(fid)!=0)
    {
      cout<<"WARNING ERROR closing file"<<name_skeleton<<endl;
      exit(-1);
    }


  //set skeleton
  skeleton->read_skeleton();
  skeleton->init_time();
  skeleton->fix_init_bind_pose();
  skeleton->precalculate_matrix();
  

  return 0;
}