CloudsManager.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_CloudsManager_H_
#define _SkyX_CloudsManager_H_

#include <vector>
#include "Prerequisites.h"

#include "ColorGradient.h"

namespace SkyX
{
  class SkyX;

  class DllExport CloudLayer
  {
  public:
    struct Options
    {
        Ogre::Real Height;
        Ogre::Real Scale;
        Ogre::Vector2 WindDirection;
        Ogre::Real TimeMultiplier;

        Ogre::Real DistanceAttenuation;
        Ogre::Real DetailAttenuation;
        Ogre::Real HeightVolume;
        Ogre::Real VolumetricDisplacement;


        Options()
            : Height(100)
            , Scale(0.001f)
            , WindDirection(Ogre::Vector2(1, 1))
            , TimeMultiplier(0.125f)
            , DistanceAttenuation(0.05f)
            , DetailAttenuation(1)
            , HeightVolume(0.25f)
            , VolumetricDisplacement(0.01f)
        {
        }

        Options(const Ogre::Real& _Height,
                const Ogre::Real& _Scale,
                const Ogre::Vector2& _WindDirection,
                const Ogre::Real& _TimeMultiplier)
            : Height(_Height)
            , Scale(_Scale)
            , WindDirection(_WindDirection)
            , TimeMultiplier(_TimeMultiplier)
            , DistanceAttenuation(0.05f)
            , DetailAttenuation(1)
            , HeightVolume(0.25f)
            , VolumetricDisplacement(0.01f)
        {
        }

        Options(const Ogre::Real& _Height,
                const Ogre::Real& _Scale,
                const Ogre::Vector2& _WindDirection,
                const Ogre::Real& _TimeMultiplier,
                const Ogre::Real& _DistanceAttenuation,
                const Ogre::Real& _DetailAttenuation,
                const Ogre::Real& _HeightVolume,
                const Ogre::Real& _VolumetricDisplacement)
            : Height(_Height)
            , Scale(_Scale)
            , WindDirection(_WindDirection)
            , TimeMultiplier(_TimeMultiplier)
            , DistanceAttenuation(_DistanceAttenuation)
            , DetailAttenuation(_DetailAttenuation)
            , HeightVolume(_HeightVolume)
            , VolumetricDisplacement(_VolumetricDisplacement)
        {
        }
    };


    CloudLayer(SkyX *s);

    CloudLayer(SkyX *s, const Options& o);

        ~CloudLayer();

    inline void setOptions(const Options& o)
    {
        mOptions = o;
        _updatePassParameters();
    }

    inline const Options& getOptions() const
    {
        return mOptions;
    }

    inline void setAmbientGradient(const ColorGradient& AmbientGradient)
    {
        mAmbientGradient = AmbientGradient;
    }

    inline const ColorGradient& getAmbientGradient() const
    {
        return mAmbientGradient;
    }

    inline void setSunGradient(const ColorGradient& SunGradient)
    {
        mSunGradient = SunGradient;
    }

    inline const ColorGradient& getSunGradient() const
    {
        return mSunGradient;
    }

    void _registerCloudLayer(Ogre::Pass* CloudLayerPass);

    void _unregister();

    void _updateInternalPassParameters();

  private:
    void _updatePassParameters();

    SkyX *mSkyX;

    Options mOptions;

    Ogre::Pass *mCloudLayerPass;

    ColorGradient mAmbientGradient;
    ColorGradient mSunGradient;
  };

    class DllExport CloudsManager
  {
  public:
    CloudsManager(SkyX *h);

        ~CloudsManager();

    void update();

    CloudLayer* add(const CloudLayer::Options& o);

    void remove(CloudLayer *cl);

    void removeAll();

    void registerAll();

    void unregister(CloudLayer* cl);

    void unregisterAll();

    inline const std::vector<CloudLayer*>& getCloudLayers() const
    {
        return mCloudLayers;
    }

  private:
    SkyX *mSkyX;

    std::vector<CloudLayer*> mCloudLayers;

    std::vector<CloudLayer*>::iterator CloudLayersIt;
  };
}

#endif