ProjectedGrid.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.
--------------------------------------------------------------------------------
 
Based on the Projected Grid concept from Claes Johanson thesis:
http://graphics.cs.lth.se/theses/projects/projgrid/
and Ren Cheng Ogre3D implementation:
http://www.cnblogs.com/ArenAK/archive/2007/11/07/951713.html
--------------------------------------------------------------------------------
*/
 
#ifndef _Hydrax_Modules_ProjectedGrid_H_
#define _Hydrax_Modules_ProjectedGrid_H_
 
 
 
#include "Hydrax.h"
#include "Mesh.h"
#include "Module.h"
 
 
 
namespace Hydrax{ namespace Module
{
    class ProjectedGrid : public Module
    {
    public:
        struct Options
        {
            int Complexity;
            float Strength;
            float Elevation;
            bool Smooth;
            bool ForceRecalculateGeometry;
            bool ChoppyWaves;
            float ChoppyStrength;
 
            Options()
                : Complexity(256)
                , Strength(35.0f)
                , Elevation(50.0f)
                , Smooth(false)
                , ForceRecalculateGeometry(false)
                , ChoppyWaves(true)
                , ChoppyStrength(3.75f)
            {
            }
 
            Options(const int &_Complexity)
                : Complexity(_Complexity)
                , Strength(35.0f)
                , Elevation(50.0f)
                , Smooth(false)
                , ForceRecalculateGeometry(false)
                , ChoppyWaves(true)
                , ChoppyStrength(3.75f)
            {
            }
 
            Options(const int   &_Complexity,
                    const float &_Strength,
                    const float &_Elevation,
                    const bool  &_Smooth)
                : Complexity(_Complexity)
                , Strength(_Strength)
                , Elevation(_Elevation)
                , Smooth(_Smooth)
                , ForceRecalculateGeometry(false)
                , ChoppyWaves(true)
                , ChoppyStrength(3.75f)
            {
            }
 
            Options(const int   &_Complexity,
                    const float &_Strength,
                    const float &_Elevation,
                    const bool  &_Smooth,
                    const bool  &_ForceRecalculateGeometry,
                    const bool  &_ChoppyWaves,
                    const float &_ChoppyStrength)
                : Complexity(_Complexity)
                , Strength(_Strength)
                , Elevation(_Elevation)
                , Smooth(_Smooth)
                , ForceRecalculateGeometry(_ForceRecalculateGeometry)
                , ChoppyWaves(_ChoppyWaves)
                , ChoppyStrength(_ChoppyStrength)
            {
            }
        };
 
        ProjectedGrid(Hydrax *h, Noise::Noise *n, const Ogre::Plane &BasePlane, const MaterialManager::NormalMode& NormalMode);
 
        ProjectedGrid(Hydrax *h, Noise::Noise *n, const Ogre::Plane &BasePlane, const MaterialManager::NormalMode& NormalMode, const Options &Options);
 
        ~ProjectedGrid();
 
        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();
 
        bool _renderGeometry(const Ogre::Matrix4& m,const Ogre::Matrix4& _viewMat, const Ogre::Vector3& WorldPos);
 
        Ogre::Vector4 _calculeWorldPosition(const Ogre::Vector2 &uv, const Ogre::Matrix4& m,const Ogre::Matrix4& _viewMat);
 
        bool _getMinMax(Ogre::Matrix4 *range);
 
        void _setDisplacementAmplitude(const float &Amplitude);
 
        void *mVertices;
 
        Mesh::POS_NORM_VERTEX* mVerticesChoppyBuffer;
 
        Ogre::Vector4 t_corners0,t_corners1,t_corners2,t_corners3;
 
        Ogre::Matrix4 mRange;
 
        Ogre::Plane mBasePlane,
                    mUpperBoundPlane,
                    mLowerBoundPlane;
 
        Ogre::Camera *mProjectingCamera,    // The camera that does the actual projection
                     *mRenderingCamera,     // The camera whose frustum the projection is created for
                     *mTmpRndrngCamera;     // Used to allow cameras with any inherited from a node or nodes
 
        Ogre::Vector3 mNormal, mPos;
 
        Ogre::Vector3 mLastPosition;
        Ogre::Quaternion mLastOrientation;
        bool mLastMinMax;
 
        Options mOptions;
 
        Hydrax* mHydrax;
    };
}}
 
 
#endif