SkyX.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of SkyX.
Visit http://www.paradise-studios.net/products/skyx/

Copyright (C) 2009-2012 Xavier Verguín González <xavyiy@gmail.com>

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 _SkyX_SkyX_H_
#define _SkyX_SkyX_H_

#include "Prerequisites.h"

#include "MeshManager.h"
#include "AtmosphereManager.h"
#include "GPUManager.h"
#include "MoonManager.h"
#include "CloudsManager.h"
#include "ColorGradient.h"
#include "Controller.h"
#include "BasicController.h"
#include "VCloudsManager.h"
#include "VClouds/VClouds.h"
#include "VClouds/GeometryManager.h"
#include "VClouds/GeometryBlock.h"
#include "VClouds/FastFakeRandom.h"
#include "VClouds/Ellipsoid.h"
#include "VClouds/DataManager.h"

namespace SkyX
{
  class DllExport SkyX : public Ogre::FrameListener,
                         public Ogre::RenderTargetListener
  {
  public:
    struct RenderQueueGroups
    {
      inline RenderQueueGroups(const Ogre::uint8& s, const Ogre::uint8& vc,
                              const Ogre::uint8& vcl)
        : skydome(s), vclouds(vc), vcloudsLightnings(vcl)
      {
      }

      Ogre::uint8 skydome;
      Ogre::uint8 vclouds;
      Ogre::uint8 vcloudsLightnings;
    };

    enum LightingMode
    {
      LM_LDR = 0,
      LM_HDR = 1
    };

    SkyX(Ogre::SceneManager* sm, Controller* c);

    ~SkyX();

        void create();

    void remove();

        void update(const Ogre::Real &timeSinceLastFrame);

    void notifyCameraRender(Ogre::Camera* c);

    inline bool isCreated() const
    {
      return mCreated;
    }

    void setVisible(const bool& visible);

    inline const bool& isVisible() const
    {
      return mVisible;
    }

    inline void setTimeMultiplier(const Ogre::Real& TimeMultiplier)
    {
      mTimeMultiplier = TimeMultiplier;
      mVCloudsManager->_updateWindSpeedConfig();
    }

    inline const Ogre::Real& getTimeMultiplier() const
    {
      return mTimeMultiplier;
    }

    inline MeshManager* getMeshManager()
    {
      return mMeshManager;
    }

    inline AtmosphereManager* getAtmosphereManager()
    {
      return mAtmosphereManager;
    }

    inline GPUManager* getGPUManager()
    {
      return mGPUManager;
    }

    inline MoonManager* getMoonManager()
    {
      return mMoonManager;
    }

    inline CloudsManager* getCloudsManager()
    {
      return mCloudsManager;
    }

    inline VCloudsManager* getVCloudsManager()
    {
      return mVCloudsManager;
    }

    inline void setController(Controller* c)
    {
      if (mController->getDeleteBySkyX())
      {
        delete mController;
      }

      mController = c;
    }

    inline Controller* getController() const
    {
      return mController;
    }

    void setRenderQueueGroups(const RenderQueueGroups& rqg);

    inline const RenderQueueGroups& getRenderQueueGroups() const
    {
      return mRenderQueueGroups;
    }

    void setLightingMode(const LightingMode& lm);

    inline const LightingMode& getLightingMode() const
    {
      return mLightingMode;
    }

    void setStarfieldEnabled(const bool& Enabled);

    inline const bool& isStarfieldEnabled() const
    {
      return mStarfield;
    }

    inline void setInfiniteCameraFarClipDistance(const Ogre::Real& d)
    {
      mInfiniteCameraFarClipDistance = d;
    }

    inline const Ogre::Real& getInfiniteCameraFarClipDistance() const
    {
      return mInfiniteCameraFarClipDistance;
    }

    inline Ogre::SceneManager* getSceneManager()
    {
      return mSceneManager;
    }

    inline Ogre::Camera* getCamera()
    {
            return mCamera;
    }

    bool frameStarted(const Ogre::FrameEvent& evt);

    void preViewportUpdate(const Ogre::RenderTargetViewportEvent& evt);

    inline const Ogre::Real& _getTimeOffset() const
    {
      return mTimeOffset;
    }

    void setEnabled(bool _enabled)
    {
      this->mEnabled = _enabled;
      this->setMoonEnabled(_enabled);
      this->setCloudsEnabled(_enabled);
    }

    inline bool getEnabled()
    {
      return this->mEnabled;
    }

    void setMoonEnabled(bool _enabled)
    {
      this->mMoonEnabled = _enabled;
      this->mMoonManager->setEnabled(_enabled);
    }

    inline bool getMoonEnabled()
    {
      return this->mMoonEnabled;
    }

    void setCloudsEnabled(bool _enabled)
    {
      this->mCloudsEnabled = _enabled;
      this->mVCloudsManager->getVClouds()->setEnabled(_enabled);
    }

    inline bool getCloudsEnabled()
    {
      return this->mCloudsEnabled;
    }

  private:

    bool mStarfield;

    LightingMode mLightingMode;

    Ogre::SceneManager *mSceneManager;

    Controller* mController;

    Ogre::Camera* mCamera;

    MeshManager* mMeshManager;

    AtmosphereManager* mAtmosphereManager;
    GPUManager* mGPUManager;
    MoonManager* mMoonManager;
    CloudsManager* mCloudsManager;

    RenderQueueGroups mRenderQueueGroups;

    bool mCreated;

    Ogre::Vector3 mLastCameraPosition;
    Ogre::Real mLastCameraFarClipDistance;
    Ogre::Real mInfiniteCameraFarClipDistance;

    bool mVisible;

    Ogre::Real mTimeMultiplier;
    Ogre::Real mTimeOffset;

    VCloudsManager* mVCloudsManager;

    bool mMoonEnabled;

    bool mCloudsEnabled;

    bool mEnabled;
  };
}

#endif