SO3NodeScol.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 __SO3NODESCOL_H__
#define __SO3NODESCOL_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SCOLBasic/SO3DataScol.h"
#include <Ogre.h>
 
namespace SO3
{
 
class _SO3_Export SNode : public SData
{
public:
  enum NodeType
  {
    NODE_TYPE_ID              = 0,
    ENTITY_TYPE_ID            = 1,
    CAMERA_TYPE_ID            = 2,
    LIGHT_TYPE_ID             = 3,
    SKELETON_TYPE_ID          = 4,
    BONE_TYPE_ID              = 5,
    PARTICLE_SYSTEM_TYPE_ID   = 6,
    DYNAMIC_CUBE_MAP_ID       = 7,
    DYNAMIC_REFLECTION_MAP_ID = 8,
    RENDER_TO_TEXTURE_ID      = 9,
    LINE_ENTITY_TYPE_ID       = 10,
    VIRTUAL_POINTER_TYPE_ID   = 11
  };
  enum NodeTransformSpace
  {
    SO3_LOCAL_TS              = 0,
    SO3_PARENT_TS             = 1,
    SO3_WORLD_TS              = 2
  };
 
protected:
        SScene* currentScene;
  Ogre::SceneNode* O3SceneNode;
  Ogre::MovableObject* ogreMovableObject;
  SBody* nodeBody;
  unsigned short animationCounter;
 
  //$BB initial PRS setInitialState use the local position, and keep this functionnality for animations
  Ogre::Vector3 initialPosition;
  Ogre::Quaternion initialOrientation;
        Ogre::Vector3 initialScale;
 
private:
  const NodeType type;
        SNode* nodeFather;
  SNode* autoTrackTargetNode;
  Ogre::StaticGeometry* staticGeometry;
  bool staticVisibility;
 
  SAnimMap animationList;
  SAnimIndexMap animationListByIndex;
        int mouseFlags;
        bool isForeGround;
        bool isMouseClick;
  SNodeMap childNodeList;
  bool mIsDirty;
  int mFlags;
  bool mPhysicsOverride;
  bool mVisible;
 
public:
  /*
  Constructor
  */
  SNode(SScene* parent, const std::string& nodeName, const bool& isRootNode=false);
 
  virtual ~SNode();
        
  SScene* GetParentScene();
 
  Ogre::SceneNode* GetOgreSceneNodePointer();
 
  Ogre::MovableObject* GetMovableObjectPointer();
 
  bool GetSceneNodeIsMouseForeground();
 
  void SetSceneNodeIsMouseForeground(const bool& mForeground);
 
  bool GetSceneNodeIsMouseClick();
 
  void SetSceneNodeIsMouseClick(const bool& mClickable);
 
  int GetSceneNodeMouseFlags();
 
  void SetSceneNodeMouseFlags(const int& flags);
 
  bool GetSceneNodeHasBody();
 
  SBody* GetSceneNodeBody();
        
  void RestoreStaticGraph();
 
  void SetAsStaticGeometry(const bool& state);
 
  bool GetAsStaticGeometry();
 
  Ogre::StaticGeometry* GetStaticGeometry();
 
  void SetFlags(const int& flags);
 
 
  void SetPhysicsOverride(bool state);
 
  bool GetPhysicsOverride();
 
  int GetFlags();
 
  void UpdateNodeBody(const bool& bScale);
  
  void DisableAutoTarget();
 
  NodeType GetNodeType();
 
  void AttachToParent(SNode* newParentNode);
 
  void DetachFromParent();
 
  SNode* GetParentSceneNode();
 
  const SNodeMap GetChildrenNodes() const;
 
  virtual int GetNumChildren();
 
  void DetachAllChildren();
 
  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);
 
  virtual Ogre::Matrix4 GetTransformationMatrix();
 
  virtual Ogre::Vector3 GetPosition();
 
  virtual void SetPosition(const Ogre::Vector3& pos);
 
  virtual Ogre::Quaternion GetOrientation();
 
  virtual void SetOrientation(const Ogre::Quaternion& quat);
 
  virtual void AddOrientation(const Ogre::Quaternion& quat);
 
  virtual Ogre::Vector3 GetScale();
 
  virtual void SetScale(const Ogre::Vector3& scale);
 
  virtual Ogre::Vector3 GetGlobalPosition();
 
  virtual void SetGlobalPosition(const Ogre::Vector3& pos, bool updateBody = true);
 
  virtual Ogre::Quaternion GetGlobalOrientation();
 
  virtual void SetGlobalOrientation(const Ogre::Quaternion& quat, bool updateBody = true);
 
  virtual Ogre::Vector3 GetGlobalScale();
 
  virtual void SetGlobalScale(const Ogre::Vector3& scale, bool updateBody = true);
 
  virtual void StoreInitialPRS();
 
  virtual void ResetToInitialPRS();
 
  void ResetToInitialPosition();
 
  virtual void ResetToInitialOrientation();
 
  void ResetToInitialScale();
 
  virtual Ogre::Vector3 GetInitialPosition();
 
  virtual Ogre::Quaternion GetInitialOrientation();
 
  virtual Ogre::Vector3 GetInitialScale();
 
  bool GetShowBoundingBox();
 
  void SetShowBoundingBox(const bool& showBounding);
 
  void SetAutoTracking(const bool& autoTrack, SNode* targetNode=0, const Ogre::Vector3& localDirectionVector=Ogre::Vector3::NEGATIVE_UNIT_Z, const Ogre::Vector3& offset=Ogre::Vector3::ZERO);
 
  SNode* GetAutoTrackingTarget();
 
  virtual void Pitch(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo=SNode::SO3_LOCAL_TS);
 
  virtual void Yaw(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo=SNode::SO3_LOCAL_TS);
 
  virtual void Roll(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo=SNode::SO3_LOCAL_TS);
 
  virtual void Rotate(const Ogre::Vector3& axis, const float& radianAngle, const SNode::NodeTransformSpace& relativeTo=SNode::SO3_LOCAL_TS);
 
  virtual void Translate(const Ogre::Vector3& d, const SNode::NodeTransformSpace& relativeTo=SNode::SO3_PARENT_TS);
 
  void SetDirection(const Ogre::Vector3& vec, const SNode::NodeTransformSpace& relativeTo=SNode::SO3_LOCAL_TS, const Ogre::Vector3& localDirectionVector = Ogre::Vector3::NEGATIVE_UNIT_Z);
 
  Ogre::Vector3 GetDirection(bool derived = false, Ogre::Vector3 axis = Ogre::Vector3::NEGATIVE_UNIT_Z);
 
  void LookAt(const Ogre::Vector3& targetPoint, const SNode::NodeTransformSpace& relativeTo, const Ogre::Vector3& localDirectionVector = Ogre::Vector3::NEGATIVE_UNIT_Z);
 
  bool GetVisible();
 
  void SetVisible(const bool& visible, const bool& cascade = true);
 
  SNodeAnimation* CreateNodeAnimation(const std::string& animationName, const float& animationLength);
 
  void DeleteAnimation(SAnim* existingAnimation);
 
  size_t GetNumAnimations();
 
  SAnim* GetAnimation(const std::string& animationName);
 
  SAnim* GetAnimation(const unsigned short& animationIndex);
 
  SAnimMap GetAnimations() const;
 
  bool IsAnimated();
 
  Ogre::Vector3 GetPositionFromNode(SNode* nodeRef);
 
  Ogre::Quaternion GetOrientationFromNode(SNode* nodeRef);
 
  Ogre::Vector3 GetScaleFromNode(SNode* nodeRef);
  
  virtual void SetInheritOrientation(const bool& state);
 
  virtual bool GetInheritOrientation();
 
  virtual void ResetOrientation();
 
  void DeleteBody();
 
  SBody* CreateBoxBody(const Ogre::Vector3& boxsetting);
 
  SBody* CreateBoxBody(const Ogre::Vector3& boxsetting, const Ogre::Vector3& offset, const Ogre::Quaternion& quat);
 
  SBody* CreateConeBody(const Ogre::Real& radius, const Ogre::Real& height);
 
  SBody* CreateConeBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat);
 
  SBody* CreateEllipsoidBody(const Ogre::Vector3& size);
 
  SBody* CreateEllipsoidBody(const Ogre::Vector3& size, const Ogre::Vector3& offset, const Ogre::Quaternion& quat);
 
  SBody* CreateCapsuleBody(const Ogre::Real& radius, const Ogre::Real& height);
 
  SBody* CreateCapsuleBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat);
 
  SBody* CreateCylinderBody(const Ogre::Real& radius, const Ogre::Real& height);
 
  SBody* CreateCylinderBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat);
 
  SBody* CreateChamferCylinderBody(const Ogre::Real& radius, const Ogre::Real& height);
 
  SBody* CreateChamferCylinderBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat);
 
  SBody* CreatePyramidBody(const Ogre::Vector3& size);
 
  SBody* CreatePyramidBody(const Ogre::Vector3& size, const Ogre::Vector3& offset, const Ogre::Quaternion& quat);
 
  SBody* CreateConvexHullBody(const Ogre::Real& tolerance);
 
  SBody* CreateConcaveHullBody(const Ogre::Real& tolerance);
  
  SBody* CreateTreeBody(const bool& optimize);
 
  bool IsDirty();
 
  void SetDirty(bool state);
 
  void UpdateNodeFromBody();
 
  void ResetNode();
protected:
  SNode(SScene* parent, const std::string& nodeName, const NodeType& nodeType);
 
  void AddAnimation(SAnim* existingAnimation);
 
  void RemoveAnimation(SAnim* existingAnimation);
 
  void RemoveAnimation(const std::string& animationName);
 
  Ogre::Vector3 GetSonsBoundingBox();
 
  Ogre::Vector3 GetSonsWorldBoundingBox();
private:
        SNode();
 
  void AddChildNode(SNode* newChild);
 
  void RemoveChildNode(SNode* existingChild);
};
 
}
 
#endif