gz/common/MeshManager.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2016 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 GZ_COMMON_MESHMANAGER_HH_
#define GZ_COMMON_MESHMANAGER_HH_
 
#include <map>
#include <utility>
#include <string>
#include <vector>
#include <memory>
 
#include <gz/math/Plane.hh>
#include <gz/math/Matrix3.hh>
#include <gz/math/Matrix4.hh>
#include <gz/math/Vector2.hh>
#include <gz/math/Vector3.hh>
#include <gz/math/Pose3.hh>
 
#include <gz/utils/ImplPtr.hh>
 
#include <gz/common/graphics/Types.hh>
#include <gz/common/SingletonT.hh>
#include <gz/common/graphics/Export.hh>
 
namespace gz
{
  namespace common
  {
    class Mesh;
    class SubMesh;
 
    class GZ_COMMON_GRAPHICS_VISIBLE MeshManager
        : public SingletonT<MeshManager>
    {
      private: MeshManager();
 
      private: virtual ~MeshManager();
 
      public: static MeshManager* Instance();
 
      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 MeshAABB(const Mesh *_mesh,
                  gz::math::Vector3d &_center,
                  gz::math::Vector3d &_min_xyz,
                  gz::math::Vector3d &_max_xyz);
 
      public: void GenSphericalTexCoord(const Mesh *_mesh,
                  const gz::math::Vector3d &_center);
 
      public: void AddMesh(Mesh *_mesh);
 
      public: bool RemoveMesh(const std::string &_name);
 
      public: void RemoveAll();
 
      public: const gz::common::Mesh *MeshByName(
                  const std::string &_name) const;
 
      public: bool HasMesh(const std::string &_name) const;
 
      public: void CreateSphere(const std::string &_name, const float _radius,
                                const int _rings, const int _segments);
 
      public: void CreateBox(const std::string &_name,
                             const gz::math::Vector3d &_sides,
                             const gz::math::Vector2d &_uvCoords);
 
      public: void CreateExtrudedPolyline(const std::string &_name,
                  const std::vector<std::vector<gz::math::Vector2d> >
                  &_vertices, const double _height);
 
      public: void CreateCylinder(const std::string &_name,
                                  const float _radius,
                                  const float _height,
                                  const int _rings,
                                  const int _segments);
 
      public: void CreateEllipsoid(const std::string &_name,
                                   const gz::math::Vector3d &_radii,
                                   const unsigned int _rings,
                                   const unsigned int _segments);
 
     public: void CreateCapsule(const std::string &_name,
                                const double radius,
                                const double length,
                                const unsigned int _rings,
                                const unsigned int _segments);
 
      public: void CreateCone(const std::string &_name,
                              const float _radius,
                              const float _height,
                              const int _rings,
                              const int _segments);
 
      public: void CreateTube(const std::string &_name,
                              const float _innerRadius,
                              const float _outterRadius,
                              const float _height,
                              const int _rings,
                              const int _segments,
                              const double _arc = 2.0 * GZ_PI);
 
      public: void CreatePlane(const std::string &_name,
                               const gz::math::Planed &_plane,
                               const gz::math::Vector2d &_segments,
                               const gz::math::Vector2d &_uvTile);
 
      public: void CreatePlane(const std::string &_name,
                               const gz::math::Vector3d &_normal,
                               const double _d,
                               const gz::math::Vector2d &_size,
                               const gz::math::Vector2d &_segments,
                               const gz::math::Vector2d &_uvTile);
 
      public: void SetAssimpEnvs();
 
      private: void Tesselate2DMesh(SubMesh *_sm,
                                    const int _meshWidth,
                                    const int _meshHeight,
                                    const bool _doubleSided);
 
      public: void CreateCamera(const std::string &_name, const float _scale);
 
      public: void CreateBoolean(const std::string &_name, const Mesh *_m1,
          const Mesh *_m2, const int _operation,
          const gz::math::Pose3d &_offset = gz::math::Pose3d::Zero);
 
      public: static std::vector<SubMesh> ConvexDecomposition(
                  const common::SubMesh &_subMesh,
                  std::size_t _maxConvexHulls = 16u,
                  std::size_t _voxelResolution = 200000u);
 
      public: static std::unique_ptr<Mesh> MergeSubMeshes(
                  const common::Mesh &_mesh);
 
      private: static void ConvertPolylinesToVerticesAndEdges(
                   const std::vector<std::vector<gz::math::Vector2d> >
                   &_polys,
                   const double _tol,
                   std::vector<gz::math::Vector2d> &_vertices,
                   std::vector<gz::math::Vector2i> &_edges);
 
      private: static size_t AddUniquePointToVerticesTable(
                      std::vector<gz::math::Vector2d> &_vertices,
                      const gz::math::Vector2d &_p,
                      const double _tol);
 
      GZ_UTILS_UNIQUE_IMPL_PTR(dataPtr)
 
      
      private: friend class SingletonT<MeshManager>;
    };
  }
}
#endif