SO3Engine/SO3SceneGraph/SO3Scene.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 __SO3SCENE_H__
#define __SO3SCENE_H__

#include "../SCOLBasic/SO3Prerequisites.h"
#include "../SCOLBasic/SO3DataScol.h"
#include "../SO3SceneGraph/SO3Entity.h"
#include "../SO3SceneGraph/SO3EntityFap.h"
#include "../SO3SceneGraph/SO3Physics.h"
#include <Ogre.h>

namespace SO3
{

// Response Flash CallBack is Inside
class MMOUSE
{
public:
        int x;
        int y;
        int scroll;
        int index;  // Button id
        int state;
        int flags;
protected:
private:
public:
  MMOUSE()
  {
    x = 0;
    y = 0;
    scroll = 0;
          index = 0;
          state = 0;
          flags = 0;
  }

  MMOUSE(int cx, int cy, int cindex, int cscroll = 0, int cstate = 0, int cflags = 0)
  {
    x = cx;
    y = cy;
    scroll = cscroll;
          index = cindex;
          state = cstate;
          flags = cflags;
  }
  MMOUSE(const MMOUSE& mmouse)
  {
    x        = mmouse.x;
    y        = mmouse.y;
    scroll   = mmouse.scroll;
    index    = mmouse.index;
    state    = mmouse.state;
    flags    = mmouse.flags;
  }
        
  ~MMOUSE()
  {
  }
protected:
private:
};

class SO3MainFrameListener : public Ogre::FrameListener
{
public:
protected:
    SScene* m_scene;
private:

public:
  SO3MainFrameListener(SScene* scene);
  
  ~SO3MainFrameListener(void);
  
  bool frameStarted(const Ogre::FrameEvent& evt);
        
  bool frameEnded(const Ogre::FrameEvent& evt);
protected:
private:
};

class SO3ParticleFrameListener : public Ogre::FrameListener
{
public:
protected:
        SScene* m_scene;
private:

public:
  SO3ParticleFrameListener(SScene* scene);
        
  ~SO3ParticleFrameListener(void);
        
  bool frameStarted(const Ogre::FrameEvent& evt);
        
  bool frameEnded(const Ogre::FrameEvent& evt);
protected:
private:
};

class _SO3_Export SScene : public SData
{
public:

        const int channel;
        Ogre::SceneManager* O3SceneManager;
        Ogre::MeshManager* O3MeshManager;
        Ogre::MaterialManager* O3MaterialManager;
        Ogre::SkeletonManager* O3SkeletonManager;
        Ogre::TextureManager* O3TextureManager;
        Ogre::GpuProgramManager* O3GpuProgramManager;
        Ogre::HighLevelGpuProgramManager* O3HighLevelGpuProgramManager;
  Ogre::ParticleSystemManager* O3ParticleSystemManager;
        SO3ParticleFrameListener* particleListener;
  SO3MainFrameListener* mainListener;
        bool hasSkyBox;
        bool skyBoxDrawFirst;
        bool hasSkyDome;
        bool skyDomeDrawFirst;
        bool hasSkyPlane;
        bool skyPlaneDrawFirst;
        Ogre::MaterialPtr skyBoxMat;
        Ogre::MaterialPtr skyDomeMat;
        Ogre::MaterialPtr skyPlaneMat;
  Ogre::MaterialPtr materialCaster;
  Ogre::MaterialPtr materialReceiver;
        Ogre::Plane skyPlane;
        Ogre::String curMessage;
  int shadowCameraSetup;
        Ogre::ShadowCameraSetupPtr mCurrentShadowCameraSetup;
        SGroupMaterialMap listOfMaterial;
        SGroupTextureMap listOfTexture;
  SEnvironment* environment;  // Sky and water

protected:
private:
  SRoot* scolRoot;
  SNodeMap nodeList;
  SNode* rootNode;
  SPhysicWorld* physicWorld;
  SAnimMap animationList;
  int animationCounter;

public:
  SScene(SRoot* parent, std::string sceneName, int scolChannel);

  ~SScene();

  void clearOgreScene();

  Ogre::SceneManager* GetOgreScenePointer();

  SNode* GetRootNode();

  SNode* GetNode(std::string nodeName);

  const SNodeMap& GetNodeList() const;

  SNode* CreateNode(std::string newNodeName);

  void DeleteNode(SNode* existingNode);

  SCamera* CreateCamera(std::string newCameraName);

  void DeleteCamera(SCamera* existingCamera);

  SEntity* CreateEntity(std::string groupName, std::string newEntityName, std::string meshName);

  SEntityFap* CreateEntityFap(std::string newEntityFapName, std::string meshName, std::string pathStdFDP, std::string pathStdIndices);

  SEntity* CreateEntity(std::string newEntityName, SEntity::EntityPrefabType prefabType);

  SEntity* CreatePlane(std::string groupName, std::string newEntityName, SPointFloat sizev, SPointInt seg, SPointFloat uv);

  void DeleteEntity(SEntity* existingEntity);

  void ReloadEntities();

  SSkeleton* CreateSkeleton(std::string newSkeletonName, SEntity* entity);

  void DeleteSkeleton(SSkeleton* existingSkeleton);

  SBone* CreateBone(std::string newBoneName, SSkeleton* skeleton, unsigned short id);

  void DeleteBone(SBone* existingBone);

  SParticleSystem* CreateParticleSystem(std::string newParticleSystemName, std::string particleSystemTemplate);

  void DeleteParticleSystem(SParticleSystem* existingParticleSystem);

  SLight* CreateLight(std::string newLightName);

  void DeleteLight(SLight* existingLight);

  SDynamicCubeMap* CreateDynamicCubeMap(std::string newDynamicCubeMapName);

  void DeleteDynamicCubeMap(SDynamicCubeMap* existingDynamicCubeMap);

  SDynamicReflectionMap* CreateDynamicReflectionMap(SViewPort* viewport, std::string newDynamicReflectionMapName);

  void DeleteDynamicReflectionMap(SDynamicReflectionMap* existingDynamicReflectionMap);

  SMaterial* CreateMaterial(std::string groupname, std::string matname);

  void DeleteMaterial(SMaterial* material);

  SMaterial* GetMaterial(std::string groupName, std::string materialName);

  STexture* CreateTexture(std::string groupname, std::string texname, std::string path, int w=0, int h=0);

  void DeleteTexture(STexture* texture);

  STexture* GetTexture(std::string groupName, std::string texName);

  SRoot* GetParent();

  SPhysicWorld* GetPhysicsWorld();

  SSequenceAnimation* CreateAnimationSequence(std::string animationName);

  void AddAnimation(SAnim* existingAnimation);

  void RemoveAnimation(SAnim* existingAnimation);

  void RemoveAnimation(std::string animationName);

  void DeleteAnimation(SAnim* existingAnimation);

  unsigned short GetNumAnimations();

  SAnim* GetAnimation(std::string animationName);

  SAnimMap GetAnimations() const;

  SEnvironment* GetEnvironment() const; 
protected:
  void AddNode(SNode* existingNode);

  void RemoveNode(SNode* existingNode);

  void RemoveNode(std::string nodeName);
private:
  SScene();

};

}

#endif

---