LightningManager.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_VClouds_LightningManager_H_
#define _SkyX_VClouds_LightningManager_H_

#include <vector>

#include "Prerequisites.h"

#include "Lightning.h"

namespace SkyX { namespace VClouds {

  class VClouds;

  class DllExport LightningManager
  {
  public:
    class Listener
    {
    public:
      inline virtual void lightningAdded(Lightning* l) {}
      virtual ~Listener() {}
    };

    explicit LightningManager(VClouds* vc);

    ~LightningManager();

    void create();

    void remove();

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

    Lightning* addLightning(const Ogre::Vector3& p, const Ogre::Vector3& d,
        const Ogre::Real l,
        const Ogre::uint32& div = static_cast<Ogre::uint32>(
          Ogre::Math::RangeRandom(12, 30)));

    void updateMaterial();

    inline void addListener(Listener* listener)
    {
      mListeners.push_back(listener);
    }

    void removeListener(Listener* listener);

    inline void removeListeners()
    {
      mListeners.clear();
    }

    inline const std::vector<Listener*>& getListeners() const
    {
      return mListeners;
    }

    void setEnabled(const bool& enable);

    inline const bool& isEnabled() const
    {
      return mEnabled;
    }

    void setLightningColor(const Ogre::Vector3& c);

    inline const Ogre::Vector3& getLightningColor() const
    {
      return mLightningColor;
    }

    void setLightningTimeMultiplier(const Ogre::Real& m)
    {
      mLightningTimeMultiplier = m;
    }

    inline const Ogre::Real& getLightningTimeMultiplier() const
    {
      return mLightningTimeMultiplier;
    }

    inline void setAverageLightningApparitionTime(const Ogre::Real& alat)
    {
       mAverageLightningApparitionTime = alat;
       mRemainingTime = alat;
    }

    inline const Ogre::Real& getAverageLightningApparitionTime() const
    {
      return mAverageLightningApparitionTime;
    }

    inline const bool& isCreated() const
    {
      return mCreated;
    }

    void _updateRenderQueueGroup(const Ogre::uint8& rqg);

    void _setVisible(const bool& v);

  private:
    VClouds *mVClouds;

    std::vector<Lightning*> mLightnings;
    std::vector<Ogre::SceneNode*> mSceneNodes;

    bool mEnabled;

    Ogre::Vector3 mLightningColor;
    Ogre::Real mLightningTimeMultiplier;

    Ogre::Real mAverageLightningApparitionTime;
    Ogre::Real mRemainingTime;

    Ogre::MaterialPtr mVolCloudsLightningMaterial;
    Ogre::MaterialPtr mLightningMaterial;

    std::vector<Listener*> mListeners;

    bool mCreated;
  };
}}
#endif