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 "Prerequisites.h"
 
#include "Lightning.h"
 
namespace SkyX { namespace VClouds{
 
    class VClouds;
 
    class LightningManager
    {
    public:
        class Listener 
        {
        public:
            inline virtual void lightningAdded(Lightning* l){}
        };
 
        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:
        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;
 
        VClouds *mVClouds;
    };
 
}}
 
#endif