GodRaysManager.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of Hydrax.
Visit ---
 
Copyright (C) 2008 Xavier Verguín González <xavierverguin@hotmail.com>
                                           <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 _Hydrax_GodRaysManager_H_
#define _Hydrax_GodRaysManager_H_
 
#include "Prerequisites.h"
#include "Perlin.h"
 
#include "Enums.h"
 
 
 
namespace Hydrax
{
    class Hydrax;
 
    class GodRaysManager
    {
    public:
        enum MaterialType
        {
            // Material used for god rays
            MAT_GODRAYS = 0,
            // Used for depth mat(for objects intersections)
            MAT_DEPTH   = 1
        };
 
        GodRaysManager(Hydrax *h);
 
        ~GodRaysManager();
 
        void create(const HydraxComponent& HC);
 
        void remove();
 
        void update(const Ogre::Real& timeSinceLastFrame);
 
        inline const bool& isCreated() const
        {
            return mCreated;
        }
 
        void addDepthTechnique(Ogre::Technique *Technique, const bool& AutoUpdate = true);
 
        inline void SetSimulationSpeed(const Ogre::Real& Speed)
        {
            mSimulationSpeed = Speed;
        }
 
        inline const Ogre::Real& getSimulationSpeed() const
        {
            return mSimulationSpeed;
        }
 
        void setNumberOfRays(const int& NumberOfRays);
 
        inline const int& getNumberOfRays() const
        {
            return mNumberOfRays;
        }
 
        inline void setRaysSize(const Ogre::Real& Size)
        {
            mRaysSize = Size;
        }
 
        inline const Ogre::Real& getRaysSize() const
        {
            return mRaysSize;
        }
 
        inline Noise::Perlin* getPerlin()
        {
            return mPerlin;
        }
 
        inline Ogre::SceneNode* getSceneNode()
        {
            return mProjectorSN;
        }
 
        inline void setVisible(const bool& Visible)
        {
            if (mCreated)
            {
                mManualGodRays->setVisible(Visible);
            }
        }
 
        inline const bool isVisible() const
        {
            if (!mCreated)
            {
                return false;
            }
 
            return mManualGodRays->isVisible();
        }
 
        void setObjectIntersectionsEnabled(const bool& Enable);
 
        inline const bool& areObjectsIntersectionsEnabled() const
        {
            return mObjectsIntersections;
        }
 
        inline const Ogre::Vector4 getNoiseParameters() const
        {
            return Ogre::Vector4(mNoiseDerivation,
                                 mNoisePositionMultiplier,
                                 mNoiseYNormalMultiplier,
                                 mNoiseNormalMultiplier);
        }
 
        inline void setNoiseParameters(Ogre::Vector4 Params)
        {
            mNoiseDerivation         = Params.x;
            mNoisePositionMultiplier = Params.y;
            mNoiseYNormalMultiplier  = Params.z;
            mNoiseNormalMultiplier   = Params.w;
        }
 
    private:
        class DepthMapListener : public Ogre::RenderTargetListener
        {
        public:
            GodRaysManager* mGodRaysManager;
 
            std::queue<std::string> mMaterials;
 
            void preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
 
            void postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt);
        };
 
        Ogre::Vector2 _calculateRayPosition(const int& RayNumber);
 
        void _createGodRays();
 
        void _createMaterials(const HydraxComponent& HC);
 
        void _updateRays();
 
        void _updateMaterialsParameters();
 
        void _updateProjector();
 
        void _createDepthRTT();
 
        bool _isComponent(const HydraxComponent &List, const HydraxComponent &ToCheck) const;
 
        bool mCreated;
 
        Ogre::ManualObject* mManualGodRays;
        Ogre::Camera *mProjectorCamera;
        Ogre::SceneNode *mProjectorSN;
 
        Noise::Perlin *mPerlin;
 
        Ogre::Real mNoiseDerivation;
        Ogre::Real mNoisePositionMultiplier;
        Ogre::Real mNoiseYNormalMultiplier;
        Ogre::Real mNoiseNormalMultiplier;
 
        Ogre::MaterialPtr mMaterials[2];
        std::vector<Ogre::Technique*> mDepthTechniques;
 
        Ogre::Real mSimulationSpeed;
        int mNumberOfRays;
        Ogre::Real mRaysSize;
        bool mObjectsIntersections;
 
        Ogre::TexturePtr mProjectorRTT;
        DepthMapListener mDepthMapListener;
 
        Hydrax *mHydrax;
    };
};
 
 
#endif