RadialGrid.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_Modules_RadialGrid_H_
#define _Hydrax_Modules_RadialGrid_H_
 
 
 
#include "Hydrax.h"
#include "Mesh.h"
#include "Module.h"
 
 
 
namespace Hydrax{ namespace Module
{
    class RadialGrid : public Module
    {
    public:
        struct Options
        {
            int Steps;
            int Circles;
            float Radius;
            bool Smooth;
            bool ChoppyWaves;
            float ChoppyStrength;
            float StepSizeCube;
            float StepSizeFive;
            float StepSizeLin;
            float Strength;
 
            Options()
                : Steps(250)
                , Circles(250)
                , Radius(100)
                , Smooth(false)
                , ChoppyWaves(true)
                , ChoppyStrength(3.5f)
                , StepSizeCube(0.00001f)
                , StepSizeFive(0.0f)
                , StepSizeLin(0.1f)
                , Strength(32.5f)
            {
            }
 
            Options(const int &_Steps,
                    const int &_Circles,
                    const float &_Radius)
                : Steps(_Steps)
                , Circles(_Circles)
                , Radius(_Radius)
                , Smooth(false)
                , ChoppyWaves(true)
                , ChoppyStrength(3.5f)
                , StepSizeCube(0.00001f)
                , StepSizeFive(0.0f)
                , StepSizeLin(0.1f)
                , Strength(32.5f)
            {
            }
 
            Options(const int &_Steps,
                    const int &_Circles,
                    const float &_Radius,
                    const bool  &_Smooth,
                    const bool  &_ChoppyWaves,
                    const float &_ChoppyStrength,
                    const float &_StepSizeCube,
                    const float &_StepSizeFive,
                    const float &_StepSizeLin,
                    const float &_Strength)
                : Steps(_Steps)
                , Circles(_Circles)
                , Radius(_Radius)
                , Smooth(_Smooth)
                , ChoppyWaves(_ChoppyWaves)
                , ChoppyStrength(_ChoppyStrength)
                , StepSizeCube(_StepSizeCube)
                , StepSizeFive(_StepSizeFive)
                , StepSizeLin(_StepSizeLin)
                , Strength(_Strength)
            {
            }
        };
 
        RadialGrid(Hydrax *h, Noise::Noise *n, const MaterialManager::NormalMode& NormalMode);
 
        RadialGrid(Hydrax *h, Noise::Noise *n, const MaterialManager::NormalMode& NormalMode, const Options &Options);
 
        ~RadialGrid();
 
        void create();
 
        void remove();
 
        void update(const Ogre::Real &timeSinceLastFrame);
 
        void setOptions(const Options &Options);
 
        void saveCfg(Ogre::String &Data);
 
        bool loadCfg(Ogre::ConfigFile &CfgFile);
 
        float getHeigth(const Ogre::Vector2 &Position);
 
        inline const Options& getOptions() const
        {
            return mOptions;
        }
 
        const bool _createGeometry(Mesh *mMesh) const;
 
    private:
        void _calculeNormals();
 
        void _performChoppyWaves();
 
        void *mVertices;
 
        Mesh::POS_NORM_VERTEX* mVerticesChoppyBuffer;
 
        Options mOptions;
 
        Hydrax* mHydrax;
    };
}}
 
 
#endif