SO3Entity.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3ENTITY_H__
#define __SO3ENTITY_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SO3SceneGraph/SO3NodeScol.h"
#include "SO3Utils/SO3Point.h"
 
namespace SO3
{
 
class SEntity : public SNode, Ogre::Resource::Listener
{
public:
  enum EntityPrefabType
  {
    SO3_PREFAB_PLANE,
    SO3_PREFAB_CUBE,
    SO3_PREFAB_SPHERE
  };
protected:
        Ogre::Entity* O3Entity;
        SSkeleton* entitySKL;
private:
  std::string mGroupName;
  typedef std::unordered_map<std::string, Ogre::ushort> PoseHandleList;
  PoseHandleList poseHandleList;
  bool mReleaseResource;
  std::string mResourceName;
  Ogre::MeshPtr mMesh;
  bool mLoading;
  int mNumLodLevel;
 
public:
  SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const std::string& meshName, bool loadInBackground = false);
 
  SEntity(SScene* parent, const std::string& entityName, const std::string& groupName, Ogre::MeshPtr meshPointer);
 
  SEntity(SScene* parent, const std::string& entityName, const EntityPrefabType& prefabType);
 
  SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const SPointFloat& sizev, const SPointInt& seg, const SPointFloat& uv);
 
  SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const float& radius, const int& rings, const int& segments);
 
  SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const float& radius, const float& height, const int& segments);
 
  SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const float& base, const float& bottom, const float& dist);
 
  SEntity();
 
  ~SEntity();
 
  void LoadAsync();
 
  void FinishAsync();
 
  Ogre::Entity* getOgreEntityPointer();
 
  SSkeleton* GetSkeleton();
        
  std::string GetGroupName();
 
  virtual void SetCastShadows(const bool& castShadows);
 
  virtual bool GetCastShadows();
 
  virtual void SetRenderingDistance(const float& distance);
 
  virtual float GetRenderingDistance();
 
  virtual Ogre::Vector3 GetBoundingBoxSize(const bool& childs = false);
 
  virtual Ogre::Vector3 GetBoundingBoxCenter(const bool& childs = false);
  
  virtual Ogre::Vector3 GetWorldBoundingBoxSize(const bool& childs = false);
 
  virtual Ogre::Vector3 GetWorldBoundingBoxCenter(const bool& childs = false);
 
  unsigned int GetPolygonCount();
 
  unsigned int GetVerticesCount();
 
  void SetRenderQueue(const Ogre::RenderQueueGroupID& groupId);
 
  unsigned int GetNumSubEntities();
 
  void SetVisibilityFlags(const Ogre::uint32& flags);
 
  Ogre::uint32 GetVisibilityFlags();
 
  void SetVisibilityFlagIndexEnable(const Ogre::uint32& flagIndex, bool enable);
 
  bool GetVisibilityFlagIndexEnable(const Ogre::uint32& flagIndex);
 
  void _SetSkeleton(SSkeleton* newSkeleton);
 
  /*
  */
  void GenerateLOD(int nbLevels);
 
  /*
  */
  void SetFreeResource(bool state);
 
  void Reload();
 
  bool SetMaterial(SMaterial* mat, int subindex);
 
  void SetMinPixelSize(const float &minsize);
  float GetMinPixelSize();
 
  virtual void loadingComplete(Ogre::Resource* res);
 
protected:
private:
  void CommonConstructorsSequence();
  void BuildMissingComponents();
};
 
}
 
#endif