Hydrax.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_Hydrax_H_
#define _Hydrax_Hydrax_H_
 
#include "Prerequisites.h"
#include "Application.h"
 
#include "Enums.h"
#include "Help.h"
#include "Mesh.h"
#include "Image.h"
#include "MaterialManager.h"
#include "RttManager.h"
#include "TextureManager.h"
#include "GodRaysManager.h"
#include "DecalsManager.h"
#include "GPUNormalMapManager.h"
#include "CfgFileManager.h"
#include "Module.h"
 
 
 
namespace Hydrax
{
    class Hydrax
    {
    public:
        Hydrax(Ogre::SceneManager *sm, Ogre::Camera *c, Ogre::Viewport *v);
 
        ~Hydrax();
 
        void create();
 
        void remove();
 
        void update(const Ogre::Real &timeSinceLastFrame);
 
        bool isComponent(const HydraxComponent &Component);
 
        void setComponents(const HydraxComponent &Components);
 
        void setModule(Module::Module* Module, const bool& DeleteOldModule = true);
 
        void setPolygonMode(const Ogre::PolygonMode& PM);
 
        void setShaderMode(const MaterialManager::ShaderMode &ShaderMode);
 
        void setPosition(const Ogre::Vector3 &Position);
 
        void rotate(const Ogre::Quaternion &q);
 
        inline const bool saveCfg(const Ogre::String &File, const Ogre::String& Path = "") const
        {
            return mCfgFileManager->save(File, Path);
        }
 
        inline const bool loadCfg(const Ogre::String &File) const
        {
            return mCfgFileManager->load(File);
        }
 
        void setPlanesError(const Ogre::Real &PlanesError);
 
        void _setStrength(const Ogre::Real &Strength);
 
        void setFullReflectionDistance(const Ogre::Real &FullReflectionDistance);
 
        void setGlobalTransparency(const Ogre::Real &GlobalTransparencyDistance);
 
        void setWaterColor(const Ogre::Vector3 &WaterColor);
 
        void setNormalDistortion(const Ogre::Real &NormalDistortion);
 
        void setSunPosition(const Ogre::Vector3 &SunPosition);
 
        void setSunStrength(const Ogre::Real &SunStrength);
 
        void setSunArea(const Ogre::Real &SunArea);
 
        void setSunColor(const Ogre::Vector3 &SunColor);
 
        void setFoamMaxDistance(const Ogre::Real &FoamMaxDistance);
 
        void setFoamScale(const Ogre::Real &FoamScale);
 
        void setFoamStart(const Ogre::Real &FoamStart);
 
        void setFoamTransparency(const Ogre::Real &FoamTransparency);
 
        void setDepthLimit(const Ogre::Real &DepthLimit);
 
        void setDistLimit(const Ogre::Real &DistLimit);
 
        void setSmoothPower(const Ogre::Real &SmoothPower);
 
        void setCausticsScale(const Ogre::Real &CausticsScale);
 
        void setCausticsPower(const Ogre::Real &CausticsPower);
 
        void setCausticsEnd(const Ogre::Real &CausticsEnd);
 
        void setGodRaysExposure(const Ogre::Vector3 &GodRaysExposure)
        {
            mGodRaysExposure = GodRaysExposure;
        }
 
        void setGodRaysIntensity(const Ogre::Real &GodRaysIntensity)
        {
            mGodRaysIntensity = GodRaysIntensity;
        }
 
        inline void setUnderwaterCameraSwitchDelta(const Ogre::Real& UnderwaterCameraSwitchDelta)
        {
            mUnderwaterCameraSwitchDelta = UnderwaterCameraSwitchDelta;
        }
 
        inline const bool& isCreated() const
        {
            return mCreated;
        }
 
        void setVisible(const bool& Visible);
 
        inline const bool& isVisible() const
        {
            return mVisible;
        }
 
        inline Ogre::Camera* getCamera()
        {
            return mCamera;
        }
 
        inline Ogre::Viewport* getViewport()
        {
            return mViewport;
        }
 
        inline Ogre::SceneManager* getSceneManager()
        {
            return mSceneManager;
        }
 
        inline Mesh* getMesh()
        {
            return mMesh;
        }
 
        inline MaterialManager* getMaterialManager()
        {
            return mMaterialManager;
        }
 
        inline RttManager* getRttManager()
        {
            return mRttManager;
        }
 
        inline TextureManager* getTextureManager()
        {
            return mTextureManager;
        }
 
        inline GodRaysManager* getGodRaysManager()
        {
            return mGodRaysManager;
        }
 
        inline DecalsManager* getDecalsManager()
        {
            return mDecalsManager;
        }
 
        inline GPUNormalMapManager* getGPUNormalMapManager()
        {
            return mGPUNormalMapManager;
        }
 
        inline CfgFileManager* getCfgFileManager()
        {
            return mCfgFileManager;
        }
 
        inline Module::Module* getModule()
        {
            return mModule;
        }
 
        inline const HydraxComponent& getComponents() const
        {
            return mComponents;
        }
 
        inline const Ogre::PolygonMode& getPolygonMode() const
        {
            return mPolygonMode;
        }
 
        inline const MaterialManager::ShaderMode& getShaderMode() const
        {
            return mShaderMode;
        }
 
        inline const Ogre::Vector3& getPosition() const
        {
            return mPosition;
        }
 
        inline const Ogre::Real& getPlanesError() const
        {
            return mPlanesError;
        }
 
        inline float getHeigth(const Ogre::Vector2 &Position)
        {
            if (mModule)
            {
                return mModule->getHeigth(Position);
            }
 
            return -1;
        }
 
        inline float getHeigth(const Ogre::Vector3 &Position)
        {
            return getHeigth(Ogre::Vector2(Position.x, Position.z));
        }
 
        inline const Ogre::Real& getFullReflectionDistance() const
        {
            return mFullReflectionDistance;
        }
 
        inline const Ogre::Real& getGlobalTransparency() const
        {
            return mGlobalTransparency;
        }
 
        inline const Ogre::Vector3& getSunPosition() const
        {
            return mSunPosition;
        }
 
        inline const Ogre::Vector3& getWaterColor() const
        {
            return mWaterColor;
        }
 
        inline const Ogre::Real& getNormalDistortion() const
        {
            return mNormalDistortion;
        }
 
        inline const Ogre::Real& getSunStrength() const
        {
            return mSunStrength;
        }
 
        inline const Ogre::Real& getSunArea() const
        {
            return mSunArea;
        }
 
        inline const Ogre::Vector3& getSunColor() const
        {
            return mSunColor;
        }
 
        inline const Ogre::Real& getFoamMaxDistance() const
        {
            return mFoamMaxDistance;
        }
 
        inline const Ogre::Real& getFoamScale() const
        {
            return mFoamScale;
        }
 
        inline const Ogre::Real& getFoamStart() const
        {
            return mFoamStart;
        }
 
        inline const Ogre::Real& getFoamTransparency() const
        {
            return mFoamTransparency;
        }
 
        inline const Ogre::Real& getDepthLimit() const
        {
            return mDepthLimit;
        }
 
        inline const Ogre::Real& getDistLimit() const
        {
            return mDistLimit;
        }
 
        inline const Ogre::Real& getSmoothPower() const
        {
            return mSmoothPower;
        }
 
        inline const Ogre::Real& getCausticsScale() const
        {
            return mCausticsScale;
        }
 
        inline const Ogre::Real& getCausticsPower() const
        {
            return mCausticsPower;
        }
 
        inline const Ogre::Real& getCausticsEnd() const
        {
            return mCausticsEnd;
        }
 
        inline const Ogre::Vector3& getGodRaysExposure() const
        {
            return mGodRaysExposure;
        }
 
        inline const Ogre::Real& getGodRaysIntensity() const
        {
            return mGodRaysIntensity;
        }
 
        inline const Ogre::Real& getUnderwaterCameraSwitchDelta() const
        {
            return mUnderwaterCameraSwitchDelta;
        }
 
        inline const bool& _isCurrentFrameUnderwater() const
        {
            return mCurrentFrameUnderwater;
        }
 
    private:
 
        class DeviceListener : public Ogre::RenderSystem::Listener
        {
        public:
            Hydrax* mHydrax;
 
            void eventOccurred(const Ogre::String& eventName, const Ogre::NameValuePairList *parameters);
        };
 
        void _updateNM();
 
        void _checkVisible();
 
        void _checkUnderwater(const Ogre::Real& timeSinceLastFrame);
 
        bool mCreated;
 
        bool mVisible;
 
        HydraxComponent mComponents;
        MaterialManager::ShaderMode mShaderMode;
 
        DeviceListener mDeviceListener;
 
        Ogre::PolygonMode mPolygonMode;
        Ogre::Vector3 mPosition;
        Ogre::Real mPlanesError;
 
        Ogre::Real mFullReflectionDistance;
        Ogre::Real mGlobalTransparency;
        Ogre::Vector3 mWaterColor;
        Ogre::Real mNormalDistortion;
 
        Ogre::Vector3 mSunPosition;
        Ogre::Real mSunStrength;
        Ogre::Real mSunArea;
        Ogre::Vector3 mSunColor;
 
        Ogre::Real mFoamMaxDistance;
        Ogre::Real mFoamScale;
        Ogre::Real mFoamStart;
        Ogre::Real mFoamTransparency;
 
        Ogre::Real mDepthLimit;
        Ogre::Real mDistLimit;
 
        Ogre::Real mSmoothPower;
 
        Ogre::Real mCausticsScale;
        Ogre::Real mCausticsPower;
        Ogre::Real mCausticsEnd;
 
        Ogre::Vector3 mGodRaysExposure;
        Ogre::Real mGodRaysIntensity;
 
        // Delta-displacement in Y-AXIS before changing to underwater mode
        Ogre::Real mUnderwaterCameraSwitchDelta;
 
        bool mCurrentFrameUnderwater;
 
        Mesh *mMesh;
        MaterialManager *mMaterialManager;
        RttManager *mRttManager;
        TextureManager *mTextureManager;
        GodRaysManager *mGodRaysManager;
        DecalsManager *mDecalsManager;
        GPUNormalMapManager *mGPUNormalMapManager;
        CfgFileManager *mCfgFileManager;
        Module::Module *mModule;
 
        Ogre::SceneManager *mSceneManager;
        Ogre::Camera *mCamera;
        Ogre::Viewport *mViewport;
    };
}
 
 
#endif