SO3Engine/SO3SceneGraph/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#ifndef __SO3NODESCOL_H__
#define __SO3NODESCOL_H__

#include "../SCOLBasic/SO3Prerequisites.h"
#include "../SCOLBasic/SO3DataScol.h"
#include <Ogre.h>

namespace SO3
{

class SNode : public SData
{
public:
  enum NodeType
  {
    NODE_TYPE_ID              = 0,
    ENTITY_TYPE_ID            = 1,
    CAMERA_TYPE_ID            = 2,
    LIGHT_TYPE_ID             = 3,
    SCENENODE_TYPE_ID         = 4,
    VIEWPORT_TYPE_ID          = 5,
    BODY_TYPE_ID              = 6,
    SKELETON_TYPE_ID          = 7,
    BONE_TYPE_ID              = 8,
    PARTICLE_SYSTEM_TYPE_ID   = 9,
    DYNAMIC_CUBE_MAP_ID       = 10,
    DYNAMIC_REFLECTION_MAP_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;
        
private:
  const NodeType type;
        SNode* nodeFather;
  SNode* autoTrackTargetNode;
  SAnimMap animationList;
  SAnimIndexMap animationListByIndex;
        int mouseFlags;
        bool isForeGround;
        bool isMouseClick;
  unsigned short animationCounter;
  SNodeMap childNodeList;

  //$BB initial PRS setInitialState use the local position, and keep this functionnality for animations
  Ogre::Vector3 initialPosition;
  Ogre::Quaternion initialOrientation;
        Ogre::Vector3 initialScale;

public:
  /*
  Constructor
  */
  SNode(SScene* parent, std::string nodeName, bool isRootNode=false);

  ~SNode();
        
  SScene* GetParentScene();

  Ogre::SceneNode* GetOgreSceneNodePointer();

  Ogre::MovableObject* GetMovableObjectPointer();

  bool getSceneNodeIsMouseForeground();

  void setSceneNodeIsMouseForeground(bool mForeground);

  bool getSceneNodeIsMouseClick();

  void setSceneNodeIsMouseClick(bool mClickable);

  int getSceneNodeMouseFlags();

  void setSceneNodeMouseFlags(int flags);

  bool getSceneNodeHasBody();

  SBody* getSceneNodeBody();
        
  void UpdateNodeBody(bool bScale);
 
  void destroyAssociatedMoveableObject();
  
  void SNode::disableAutoTarget();

  NodeType GetNodeType();

  void AttachToParent(SNode* newParentNode);

  void DetachFromParent();

  SNode* GetParentSceneNode();

  const SNodeMap GetChildrenNodes() const;

  virtual int GetNumChildren();

  void DetachAllChildren();

  virtual void SetCastShadows(bool castShadows);

  virtual bool GetCastShadows();

  virtual void SetRenderingDistance(float distance);

  virtual float GetRenderingDistance();

  virtual Ogre::Vector3 GetBoundingBoxSize(bool childs = false);

  virtual Ogre::Vector3 GetBoundingBoxCenter(bool childs = false);

  virtual Ogre::Matrix4 GetTransformationMatrix();

  virtual Ogre::Vector3 GetPosition();

  virtual void SetPosition(Ogre::Vector3 pos);

  virtual Ogre::Quaternion GetOrientation();

  virtual void SetOrientation(Ogre::Quaternion quat);

  virtual void AddOrientation(Ogre::Quaternion quat);

  virtual Ogre::Vector3 GetScale();

  virtual void SetScale(Ogre::Vector3 scale);

  virtual Ogre::Vector3 GetGlobalPosition();

  virtual void SetGlobalPosition(Ogre::Vector3 pos);

  virtual Ogre::Quaternion GetGlobalOrientation();

  virtual void SetGlobalOrientation(Ogre::Quaternion quat);

  virtual Ogre::Vector3 GetGlobalScale();

  virtual void SetGlobalScale(Ogre::Vector3 scale);

  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(bool showBounding);

  void SetAutoTracking(bool autoTrack, SNode* targetNode=0, Ogre::Vector3 localDirectionVector=Ogre::Vector3::NEGATIVE_UNIT_Z, Ogre::Vector3 offset=Ogre::Vector3::ZERO);

  SNode* GetAutoTrackingTarget();

  virtual void Pitch(float radianAngle, SNode::NodeTransformSpace relativeTo=SNode::SO3_LOCAL_TS);

  virtual void Yaw(float radianAngle, SNode::NodeTransformSpace relativeTo=SNode::SO3_LOCAL_TS);

  virtual void Roll(float radianAngle, SNode::NodeTransformSpace relativeTo=SNode::SO3_LOCAL_TS);

  virtual void Rotate(Ogre::Vector3 axis, float radianAngle, SNode::NodeTransformSpace relativeTo=SNode::SO3_LOCAL_TS);

  virtual void Translate(Ogre::Vector3 d, SNode::NodeTransformSpace relativeTo=SNode::SO3_PARENT_TS);

  void SetDirection(Ogre::Vector3 vec, SNode::NodeTransformSpace relativeTo=SNode::SO3_LOCAL_TS, Ogre::Vector3 localDirectionVector = Ogre::Vector3::NEGATIVE_UNIT_Z);

  void LookAt(Ogre::Vector3 targetPoint, SNode::NodeTransformSpace relativeTo, Ogre::Vector3 localDirectionVector = Ogre::Vector3::NEGATIVE_UNIT_Z);

  bool GetVisible();

  void SetVisible(bool visible, bool cascade = true);

  SNodeAnimation* CreateNodeAnimation(std::string animationName, float animationLength);

  void DeleteAnimation(SAnim* existingAnimation);

  unsigned short GetNumAnimations();

  SAnim* GetAnimation(std::string animationName);

  SAnim* GetAnimation(unsigned short animationIndex);

  SAnimMap GetAnimations() const;

  Ogre::Vector3 GetPositionFromNode(SNode* nodeRef);

  Ogre::Quaternion GetOrientationFromNode(SNode* nodeRef);

  Ogre::Vector3 GetScaleFromNode(SNode* nodeRef);
  
  virtual void SetInheritOrientation(bool state);

  virtual bool GetInheritOrientation();

  virtual void ResetOrientation();

  void DeleteBody();

  SBody* CreateBoxBody(Ogre::Vector3 boxsetting);

  SBody* CreateConeBody(Ogre::Real radius, Ogre::Real height);

  SBody* CreateEllipsoidBody(Ogre::Vector3 size);

  SBody* CreateCapsuleBody(Ogre::Real radius, Ogre::Real height);

  SBody* CreateCylinderBody(Ogre::Real radius, Ogre::Real height);

  SBody* CreateChamferCylinderBody(Ogre::Real radius, Ogre::Real height);

  SBody* CreatePyramidBody(Ogre::Vector3 size);

  SBody* CreateConvexHullBody(Ogre::Real tolerance);

  SBody* CreateTreeBody(bool optimize);

protected:
  SNode(SScene* parent, std::string nodeName, NodeType nodeType);

  void AddAnimation(SAnim* existingAnimation);

  void RemoveAnimation(SAnim* existingAnimation);

  void RemoveAnimation(std::string animationName);

  Ogre::Vector3 GetSonsBoundingBox();
private:
        SNode();

  void AddChildNode(SNode* newChild);

  void RemoveChildNode(SNode* existingChild);
};

}

#endif

---