← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty-proposed

« back to all changes in this revision

Viewing changes to extern/carve/include/carve/mesh_impl.hpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-08-14 10:43:49 UTC
  • mfrom: (14.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20130814104349-t1d5mtwkphp12dyj
Tags: 2.68a-3
* Upload to unstable
* debian/: python3.3 Depends simplified
  - debian/control: python3.3 Depends dropped
    for blender-data package
  - 0001-blender_thumbnailer.patch refreshed
* debian/control: libavcodec b-dep versioning dropped

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/carve/include/carve/mesh_impl.hpp
676
676
 
677
677
    template<unsigned ndim>
678
678
    template<typename iter_t>
679
 
    void Mesh<ndim>::create(iter_t begin, iter_t end, std::vector<Mesh<ndim> *> &meshes) {
 
679
    void Mesh<ndim>::create(iter_t begin, iter_t end, std::vector<Mesh<ndim> *> &meshes, const MeshOptions &opts) {
680
680
      meshes.clear();
681
681
    }
682
682
 
684
684
 
685
685
    template<>
686
686
    template<typename iter_t>
687
 
    void Mesh<3>::create(iter_t begin, iter_t end, std::vector<Mesh<3> *> &meshes) {
688
 
      detail::FaceStitcher().create(begin, end, meshes);
 
687
    void Mesh<3>::create(iter_t begin, iter_t end, std::vector<Mesh<3> *> &meshes, const MeshOptions &opts) {
 
688
      detail::FaceStitcher(opts).create(begin, end, meshes);
689
689
    }
690
690
 
691
691
 
692
692
 
693
693
    template<unsigned ndim>
694
694
    template<typename iter_t>
695
 
    void MeshSet<ndim>::_init_from_faces(iter_t begin, iter_t end) {
 
695
    void MeshSet<ndim>::_init_from_faces(iter_t begin, iter_t end, const MeshOptions &opts) {
696
696
      typedef std::unordered_map<const vertex_t *, size_t> map_t;
697
697
      map_t vmap;
698
698
 
723
723
        } while (e != f->edge);
724
724
      }
725
725
 
726
 
      mesh_t::create(begin, end, meshes);
 
726
      mesh_t::create(begin, end, meshes, opts);
727
727
 
728
728
      for (size_t i = 0; i < meshes.size(); ++i) {
729
729
        meshes[i]->meshset = this;
735
735
    template<unsigned ndim>
736
736
    MeshSet<ndim>::MeshSet(const std::vector<typename MeshSet<ndim>::vertex_t::vector_t> &points,
737
737
                           size_t n_faces,
738
 
                           const std::vector<int> &face_indices) {
 
738
                           const std::vector<int> &face_indices,
 
739
                           const MeshOptions &opts) {
739
740
      vertex_storage.reserve(points.size());
740
741
      std::vector<face_t *> faces;
741
742
      faces.reserve(n_faces);
755
756
        faces.push_back(new face_t(v.begin(), v.end()));
756
757
      }
757
758
      CARVE_ASSERT(p == face_indices.size());
758
 
      mesh_t::create(faces.begin(), faces.end(), meshes);
 
759
      mesh_t::create(faces.begin(), faces.end(), meshes, opts);
759
760
 
760
761
      for (size_t i = 0; i < meshes.size(); ++i) {
761
762
        meshes[i]->meshset = this;
765
766
 
766
767
 
767
768
    template<unsigned ndim>
768
 
    MeshSet<ndim>::MeshSet(std::vector<face_t *> &faces) {
769
 
      _init_from_faces(faces.begin(), faces.end());
 
769
    MeshSet<ndim>::MeshSet(std::vector<face_t *> &faces, const MeshOptions &opts) {
 
770
      _init_from_faces(faces.begin(), faces.end(), opts);
770
771
    }
771
772
 
772
773
 
773
774
 
774
775
    template<unsigned ndim>
775
 
    MeshSet<ndim>::MeshSet(std::list<face_t *> &faces) {
776
 
      _init_from_faces(faces.begin(), faces.end());
 
776
    MeshSet<ndim>::MeshSet(std::list<face_t *> &faces, const MeshOptions &opts) {
 
777
      _init_from_faces(faces.begin(), faces.end(), opts);
777
778
    }
778
779
 
779
780
 
1010
1011
      vertex_storage.swap(vout);
1011
1012
    }
1012
1013
 
 
1014
 
 
1015
 
 
1016
    template<unsigned ndim>
 
1017
    void MeshSet<ndim>::separateMeshes() {
 
1018
      size_t n;
 
1019
      typedef std::unordered_map<std::pair<mesh_t *, vertex_t *>, vertex_t *> vmap_t;
 
1020
      vmap_t vmap;
 
1021
      typename vmap_t::iterator vmap_iter;
 
1022
 
 
1023
      for (face_iter i = faceBegin(); i != faceEnd(); ++i) {
 
1024
        face_t *f = *i;
 
1025
        for (typename face_t::edge_iter_t j = f->begin(); j != f->end(); ++j) {
 
1026
          edge_t &e = *j;
 
1027
          vmap[std::make_pair(f->mesh, e.vert)] = e.vert;
 
1028
        }
 
1029
      }
 
1030
 
 
1031
      std::vector<vertex_t> vout;
 
1032
      vout.reserve(vmap.size());
 
1033
 
 
1034
      for (n = 0, vmap_iter = vmap.begin(); vmap_iter != vmap.end(); ++vmap_iter, ++n) {
 
1035
        vout.push_back(*(*vmap_iter).second);
 
1036
        (*vmap_iter).second = & vout.back();
 
1037
      }
 
1038
 
 
1039
      for (face_iter i = faceBegin(); i != faceEnd(); ++i) {
 
1040
        face_t *f = *i;
 
1041
        for (typename face_t::edge_iter_t j = f->begin(); j != f->end(); ++j) {
 
1042
          edge_t &e = *j;
 
1043
          e.vert = vmap[std::make_pair(f->mesh, e.vert)];
 
1044
        }
 
1045
      }
 
1046
 
 
1047
      vertex_storage.swap(vout);
 
1048
    }
 
1049
 
1013
1050
  }
1014
1051
}