MeshManager.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012-2015 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef _MESHMANAGER_HH_
#define _MESHMANAGER_HH_

#include <map>
#include <string>
#include <vector>
#include <boost/thread/mutex.hpp>

#include "gazebo/math/Vector3.hh"
#include "gazebo/math/Vector2d.hh"
#include "gazebo/math/Pose.hh"
#include "gazebo/math/Plane.hh"
#include "gazebo/common/SingletonT.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace common
  {
    class ColladaLoader;
    class ColladaExporter;
    class STLLoader;
    class Mesh;
    class Plane;
    class SubMesh;


    class GAZEBO_VISIBLE MeshManager : public SingletonT<MeshManager>
    {
      private: MeshManager();

      private: virtual ~MeshManager();

      public: const Mesh *Load(const std::string &_filename);

      public: void Export(const Mesh *_mesh, const std::string &_filename,
          const std::string &_extension, bool _exportTextures = false);

      public: bool IsValidFilename(const std::string &_filename);

      public: void GetMeshAABB(const Mesh *_mesh,
                               math::Vector3 &_center,
                               math::Vector3 &_min_xyz,
                               math::Vector3 &_max_xyz);

      public: void GenSphericalTexCoord(const Mesh *_mesh,
                                        math::Vector3 _center);


      public: void AddMesh(Mesh *_mesh);

      public: const Mesh *GetMesh(const std::string &_name) const;

      public: bool HasMesh(const std::string &_name) const;

      public: void CreateSphere(const std::string &_name, float _radius,
                                int _rings, int _segments);

      public: void CreateBox(const std::string &_name,
                             const math::Vector3 &_sides,
                             const math::Vector2d &_uvCoords);

      public: void CreateExtrudedPolyline(const std::string &_name,
                  const std::vector<math::Vector2d> &_vertices,
                  const double &_height,
                  const math::Vector2d &_uvCoords);

      public: void CreateCylinder(const std::string &_name,
                                  float _radius,
                                  float _height,
                                  int _rings,
                                  int _segments);

      public: void CreateCone(const std::string &_name,
                              float _radius,
                              float _height,
                              int _rings,
                              int _segments);

      public: void CreateTube(const std::string &_name,
                              float _innerRadius,
                              float _outterRadius,
                              float _height,
                              int _rings,
                              int _segments);

      public: void CreatePlane(const std::string &_name,
                               const math::Plane &_plane,
                               const math::Vector2d &_segments,
                               const math::Vector2d &_uvTile);

      public: void CreatePlane(const std::string &_name,
                               const math::Vector3 &_normal,
                               double _d,
                               const math::Vector2d &_size,
                               const math::Vector2d &_segments,
                               const math::Vector2d &_uvTile);

      private: void Tesselate2DMesh(SubMesh *_sm,
                                    int _meshWidth,
                                    int _meshHeight,
                                    bool _doubleSided);

      public: void CreateCamera(const std::string &_name, float _scale);

#ifdef HAVE_GTS
      public: void CreateBoolean(const std::string &_name, const Mesh *_m1,
          const Mesh *_m2, const int _operation,
          const math::Pose &_offset = math::Pose::Zero);
#endif

      private: ColladaLoader *colladaLoader;

      private: ColladaExporter *colladaExporter;

      private: STLLoader *stlLoader;

      private: std::map<std::string, Mesh*> meshes;

      private: std::vector<std::string> fileExtensions;

      private: boost::mutex mutex;

      private: friend class SingletonT<MeshManager>;
    };
  }
}
#endif