MeshManager.hh

/*
 * Copyright 2011 Nate Koenig & Andrew Howard
 *
 * 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 "math/Vector3.hh"
#include "math/Vector2d.hh"
#include "math/Plane.hh"
#include "common/SingletonT.hh"

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


    class MeshManager : public SingletonT<MeshManager>
    {
      private: MeshManager();
    
      private: virtual ~MeshManager();
  
      public: const Mesh *Load(const std::string &filename);
  
      public: bool IsValidFilename(const std::string &filename);
  
      public: void SetMeshCenter(const Mesh *mesh,math::Vector3 center);
  
      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 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);
   
      private: ColladaLoader *colladaLoader;
      private: STLLoader *stlLoader;
  
      private: std::map<std::string, Mesh*> meshes;
  
      private: std::vector<std::string> fileExtensions;
  
      //Singleton implementation
      private: friend class SingletonT<MeshManager>;
    };
  }
}
#endif