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) 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 __SO3SCENE_H__
#define __SO3SCENE_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SCOLBasic/SO3DataScol.h"
#include "SO3Material/SO3Resource.h"
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3VirtualPointer.h"
#include "SO3Renderer/SO3LightingManager.h"
#include "SO3Renderer/SO3ShadowManager.h"
#include <Ogre.h>
 
#include <sstream>
#include <iostream>
 
namespace SO3
{
 
  // Response Flash CallBack is Inside
  class MMOUSE
  {
  public:
    int x;
    int y;
    int vx;
    int vy;
    int scroll;
    int btn;
    int index;
    int state;
    int flags;
  protected:
  private:
  public:
    MMOUSE()
    {
      x = 0;
      y = 0;
      vx = 0;
      vy = 0;
      scroll = 0;
      btn = 0;
      index = -1;
      state = 0;
      flags = 0;
    }
 
    MMOUSE(int cx, int cy, int cbtn, int cindex = 0, int cscroll = 0, int cstate = 0, int cflags = 0, int cvx = 0, int cvy = 0)
    {
      x = cx;
      y = cy;
      btn = cbtn;
      scroll = cscroll;
      index = cindex;
      state = cstate;
      flags = cflags;
      vx = cvx;
      vy = cvy;
    }
 
    MMOUSE(const MMOUSE& mmouse)
    {
      x = mmouse.x;
      y = mmouse.y;
      scroll = mmouse.scroll;
      btn = mmouse.btn;
      index = mmouse.index;
      state = mmouse.state;
      flags = mmouse.flags;
      vx = mmouse.vx;
      vy = mmouse.vy;
    }
 
    ~MMOUSE()
    {
    }
  protected:
  private:
  };
 
  class _SO3_Export SScene : public SData
  {
  public:
    Ogre::SceneManager* O3SceneManager;
    Ogre::MeshManager* O3MeshManager;
    Ogre::MaterialManager* O3MaterialManager;
    Ogre::SkeletonManager* O3SkeletonManager;
    Ogre::TextureManager* O3TextureManager;
    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;
    SEnvironment* environment;  // Sky and wate
  protected:
  private:
    SRoot* scolRoot;
    SNodeMap nodeList;
    SEntityMap asyncEntities;
    STerrainMap terrainList;
    SNode* rootNode;
    SPhysicWorld* physicWorld;
    SAnimMap animationList;
    int animationCounter;
    SLightingManager* lightingManager;
    Ogre::ColourValue cAmbientLight;
    SGroupMaterialMap listOfMaterial;
    SGroupTextureMap listOfTexture;
    Ogre::Timer mPreTimer;
    Ogre::Timer mPostTimer;
    SShadowManager::ShadowType mLastShadowType;
    Ogre::RaySceneQuery* mRayQuery;
 
    //debug overlay
    Ogre::Overlay* SO3DebugOverlay;
    Ogre::OverlayContainer* SO3DebugPanel;
    Ogre::TextAreaOverlayElement* SO3DebugTextArea;
    Ogre::ResourcePtr SO3DebugFont;
  public:
    SScene(SRoot* parent, const std::string& sceneName);
 
    ~SScene();
 
    void clearOgreScene();
 
    Ogre::SceneManager* GetOgreScenePointer();
 
    SNode* GetRootNode();
 
    SNode* GetNode(const std::string& nodeName) const;
 
    void PreUpdate();
 
    void PostUpdate();
 
    const SNodeMap& GetNodeList() const;
 
    const STerrainMap& GetTerrainList() const;
 
    SNode* CreateNode(const std::string& newNodeName);
 
    SNode* CreateNodeWithUniqueName(const std::string& basename);
 
    void DeleteNode(SNode* existingNode);
 
    SVirtualPointer* CreateVirtualPointer(const std::string& basename);
 
    SCamera* CreateCamera(const std::string& newCameraName);
 
    SEntity* CreateEntity(const std::string& groupName, const std::string& newEntityName, const std::string& meshName, bool loadInBackground = false);
 
    SEntity* CreateEntity(const std::string& newEntityName, const SEntity::EntityPrefabType& prefabType);
 
    SEntity* CreateEntity(const std::string& entityName, const std::string& ressourceGroup, Ogre::MeshPtr meshPointer);
 
    SEntity* CloneEntity(const std::string& newEntityName, SEntity* entity);
 
    SEntity* CreatePlane(const std::string& groupName, const std::string& newEntityName, const SPointFloat& sizev, const SPointInt& seg, const SPointFloat& uv);
 
    SEntity* CreateSphere(const std::string& groupName, const std::string& newEntityName, const float& radius, const int& rings, const int& segments);
 
    SEntity* CreateCone(const std::string& groupName, const std::string& newEntityName, const float& radius, const float& height, const int& segments);
 
    SEntity* CreateOctahedron(const std::string& groupName, const std::string& newEntityName, const float& base, const float& bottom, const float& dist);
 
    void DeleteEntity(SEntity* existingEntity);
 
    void ReloadEntities();
 
    SLineEntity* CreateLineEntity(const std::string& newLineEntityName, bool dashed = false, bool disableDepth = false);
 
    void DeleteLineEntity(SLineEntity* existingLineEntity);
 
    void UpdateLightsShadowParameters();
 
    SSkeleton* CreateSkeleton(const std::string& newSkeletonName, SEntity* entity);
 
    void DeleteSkeleton(SSkeleton* existingSkeleton);
 
    SBone* CreateBone(const std::string& newBoneName, SSkeleton* skeleton, const unsigned short& id);
 
    void DeleteBone(SBone* existingBone);
 
    SParticleSystem* CreateParticleSystem(const std::string& newParticleSystemName, const std::string& particleSystemTemplate);
 
    void DeleteParticleSystem(SParticleSystem* existingParticleSystem);
 
    SLight* CreateLight(const std::string& newLightName);
 
    void DeleteLight(SLight* existingLight);
 
    SDynamicCubeMap* CreateDynamicCubeMap(const std::string& newDynamicCubeMapName);
 
    void DeleteDynamicCubeMap(SDynamicCubeMap* existingDynamicCubeMap);
 
    SRenderToTexture* CreateRenderToTexture(const std::string& newRttName, SCamera* povCamera);
 
    void DeleteRenderToTexture(SRenderToTexture* existingRenderToTexture);
 
    SDynamicReflectionMap* CreateDynamicReflectionMap(SViewPort* viewport, const std::string& newDynamicReflectionMapName);
 
    void DeleteDynamicReflectionMap(SDynamicReflectionMap* existingDynamicReflectionMap);
 
    SMaterial* CreateMaterial(const std::string& groupname, const std::string& matname, const bool& loadedFromScript = false);
 
    void DeleteMaterial(SMaterial* material);
 
    SMaterial* GetMaterial(const std::string& groupName, const std::string& materialName, bool searchOtherGroups = true);
 
    bool IsMaterialExist(SMaterial*);
 
    const SMaterialMap* GetMaterials(const std::string& groupName);
 
    const SGroupMaterialMap* GetMaterials();
 
    void CleanGroupMaterials(const std::string& groupName);
 
    STexture* CreateTexture(const std::string& groupname, const std::string& texname, const std::string& path, const int& w = 0, const int& h = 0);
 
    STexture* CreateTexture(const std::string& groupname, const std::string& texname, Ogre::Image image);
 
    void DeleteTexture(STexture* texture);
 
    STexture* GetTexture(const std::string& groupName, const std::string& texName);
 
    const STextureMap* GetTextures(const std::string& groupName);
 
    const SGroupTextureMap* GetTextures();
 
    void CleanGroupTextures(const std::string& groupName);
 
    STerrain* CreateTerrain(const std::string& name);
 
    void DeleteTerrain(STerrain* terrain);
 
    void UpdateAllTerrains();
 
    void DeleteAllTerrains();
 
    SRoot* GetParent();
 
    SPhysicWorld* GetPhysicsWorld();
 
    SSequenceAnimation* CreateAnimationSequence(const std::string& animationName);
 
    void AddAnimation(SAnim* existingAnimation);
 
    void RemoveAnimation(SAnim* existingAnimation);
 
    void RemoveAnimation(const std::string& animationName);
 
    void DeleteAnimation(SAnim* existingAnimation);
 
    unsigned short GetNumAnimations();
 
    SAnim* GetAnimation(const std::string& animationName);
 
    SAnimMap GetAnimations() const;
 
    SEnvironment* GetEnvironment() const;
 
    SLightingManager* GetLightingManager();
 
    SShadowManager::ShadowType GetShadowType();
 
    void SetShadowType(const SShadowManager::ShadowType& shadowType);
 
    SShadowManager::ShadowQuality GetShadowQuality();
 
    void SetShadowQuality(const SShadowManager::ShadowQuality& quality);
 
    SShadowManager* GetShadowManager();
 
    void DestroyInternalRessources();
 
    void ReloadInternalRessources();
 
    Ogre::ColourValue GetAmbientLight();
 
    void SetAmbientLight(const Ogre::ColourValue& color);
 
    void UpdateCamera(SViewPort* viewport);
 
    void RegisterViewport(SViewPort* viewport);
 
    void UnregisterViewport(SViewPort* viewport);
 
    bool ParseResourceScript(const std::string& groupName, const std::string& scriptName, const SResource::ResourceType& scriptType);
 
    void SetDebugEnable(const bool& enable);
 
    void SetDebugDisplay(const int& color, const int& posx, const int& posy, const int& width, const int& height, const int& charHeight);
 
    void SetDebugText(const std::string& text);
 
    void GetSimpleRayCast(Ogre::Ray cameraRay, SRaycastResult &result);
 
    void GetSimpleRayCast(Ogre::Ray cameraRay, SEntity* selected, SRaycastResult &result);
 
    Ogre::RaySceneQuery* GetRayquery() { return mRayQuery; };
 
    void SetMaterialsPointSize(Ogre::Real size);
  protected:
    bool NodeExist(const std::string &name);
 
    bool AddNode(SNode* existingNode);
 
    void RemoveNode(SNode* existingNode);
 
    void RemoveNode(const std::string& nodeName);
 
    void DeleteAllNodes();
 
    void DeleteAllAnimations();
 
    void DeleteAllMaterials();
 
    void DeleteAllTextures();
 
    bool UnloadResource(Ogre::ResourceManager* resMgr, const std::string& resName, const std::string& groupName);
    bool UnloadResource(Ogre::ParticleSystemManager* resMgr, const std::string& resName);
    bool UnloadMaterials(const std::string& filename, const std::string& groupName);
    bool UnloadCompositors(const std::string& filename, const std::string& groupName);
    bool UnloadParticles(const std::string& filename, const std::string& groupName);
    bool UnloadVertexPrograms(const std::string& filename, const std::string& groupName);
    bool UnloadFragmentPrograms(const std::string& filename, const std::string& groupName);
  private:
    SScene();
  };
 
}
 
#endif