SimpleGrid.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_SimpleGrid_H_
#define _Hydrax_Modules_SimpleGrid_H_
 
 
 
#include "Hydrax.h"
#include "Mesh.h"
#include "Module.h"
 
 
 
namespace Hydrax{ namespace Module
{
    class SimpleGrid : public Module
    {
    public:
        struct Options
        {
            int Complexity;
            Size MeshSize;
            float Strength;
            bool Smooth;
            bool ChoppyWaves;
            float ChoppyStrength;
 
            Options()
                : Complexity(256)
                , MeshSize(Size(100))
                , Strength(32.5f)
                , Smooth(false)
                , ChoppyWaves(true)
                , ChoppyStrength(0.065f)
            {
            }
 
            Options(const int &_Complexity,
                    const Size &_MeshSize)
                : Complexity(_Complexity)
                , MeshSize(_MeshSize)
                , Strength(32.5f)
                , Smooth(false)
                , ChoppyWaves(true)
                , ChoppyStrength(0.065f)
            {
            }
 
            Options(const int   &_Complexity,
                    const Size  &_MeshSize,
                    const float &_Strength,
                    const bool  &_Smooth,
                    const bool  &_ChoppyWaves,
                    const float &_ChoppyStrength)
                : Complexity(_Complexity)
                , MeshSize(_MeshSize)
                , Strength(_Strength)
                , Smooth(_Smooth)
                , ChoppyWaves(_ChoppyWaves)
                , ChoppyStrength(_ChoppyStrength)
            {
            }
        };
 
        SimpleGrid(Hydrax *h, Noise::Noise *n, const MaterialManager::NormalMode& NormalMode);
 
        SimpleGrid(Hydrax *h, Noise::Noise *n, const MaterialManager::NormalMode& NormalMode, const Options &Options);
 
        ~SimpleGrid();
 
        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;
        }
 
    private:
        void _calculeNormals();
 
        void _performChoppyWaves();
 
        void *mVertices;
 
        Mesh::POS_NORM_VERTEX* mVerticesChoppyBuffer;
 
        Options mOptions;
 
        Hydrax* mHydrax;
    };
}}
 
 
#endif