source: Revenant/geoworld/include/gwmorphs/outflowchannels.h

#pragma once

#include <limits>
#include <algorithm>
#include <list>

#include "gwutil.h"
#include "fluidyn.h"
#include "geomorph.h"
#include "synthsession.h"
#include "gmregistry.h"

namespace geoworld
{
        namespace ofc
        {
                typedef mars::ParabolicFn<float, -1> EaseInFn;                                                          // Used for tapering the flow line
                typedef mars::ParabolicFn<float, -1> EaseOutFn;                                                         // Used for tapering the flow line

                const static EaseInFn EASE_IN_FN (1, 1.1f, -1.001f);
                const static EaseOutFn EASE_OUT_FN (1, 1.1f, -1.001f);
        }

        class OutflowChannelGM : public HeightMapGeoMorph, public BoundedGeoMorph
        {
        private:
                class OutflowChannelData
                {
                public:
                        GeoHeightMap::View & view;
                        GeoHeightMap hmbb;

                        OutflowChannelData (GeoHeightMap::View * pView)
                                : view(*pView), hmbb(*pView) {}
                };

                class FluiDynQueryBridge : public fldyn::IQueryBridge <FluiDynQueryBridge, FieldReal, GeoHeightMap::Precision>
                {
                private:
                        const IGeoWorldAccessor * _pAccessor;
                        const GMScalarField * _pfsDensity;
                        const GWSurfacePos _ptOffset;

                public:
                        inline FluiDynQueryBridge (const IGeoWorldAccessor * pAccessor, const GWSurfacePos & ptOffset)
                                : _pAccessor (pAccessor), _pfsDensity(pAccessor->queryField(FT_Density)), _ptOffset(ptOffset) {}

                        inline DensityPrecision density (const GeoHeightMap::Precision x, const GeoHeightMap::Precision y, const GeoHeightMap::Precision z) const
                                { return (*_pfsDensity) (x + _ptOffset.x, y + _ptOffset.y, z); }
                        inline DensityPrecision density (const GeoHeightMap::Precision x, const GeoHeightMap::Precision y) const
                                { return (*_pfsDensity) (x + _ptOffset.x, y + _ptOffset.y, (*_pAccessor)(x + _ptOffset.x, y + _ptOffset.y)); }
                        inline GeoHeightMap::Precision elevation (const unsigned int x, const unsigned int y) const
                                { return _pAccessor->mean(x + _ptOffset.x, y + _ptOffset.y); }
                };

        public:
                typedef mars::MidpointDisplacementGrid< typename GeoHeightMap::Precision > PerturbMapType;
                typedef mars::vector2D< float > PointType;
                typedef fldyn::ChannelSet <FluiDynQueryBridge, float, typename GeoHeightMap::Precision, OutflowChannelData> ChannelSetType;
                typedef fldyn::PathFinder <FluiDynQueryBridge, float, typename GeoHeightMap::Precision> ChannelFinderType;
                typedef ChannelFinderType::FlowLineType::Iterator<typename GeoHeightMap::Precision, ofc::EaseInFn, ofc::EaseOutFn> RasterIteratorType;

        private:
                class MyChannelSet : public ChannelSetType
                {
                private:
                        class BevelFn : public mars::GaussianFn< float, -1 >
                        {
                        private:
                                float _frDepth;

                        public:
                                BevelFn (const float frDepth)
                                        : GaussianFn(1.0f, frDepth, 1.0f / 3.0f, 0.0f), _frDepth(frDepth) {}

                                BevelFn & operator = (const BevelFn & copy)
                                {
                                        mars::GaussianFn< float, -1 >::operator = (copy);
                                        _frDepth = copy._frDepth;
                                        return *this;
                                }

                                inline float getBevelDepth () const { return _frDepth; }
                                
                                inline const float rforce (const float t) const
                                {
                                        return -f(t) / _frDepth;
                                }
                                inline const float bevel (const float t) const 
                                {
                                        return f(t) / _frDepth;
                                }
                        } _fnBevel;

                        const ofc::EaseInFn _fnEaseIn;
                        const ofc::EaseOutFn _fnEaseOut;

                        PerturbMapType * _perturb;
                        mars::RingBuffer< HMPrec > * _prbSediment;

                protected:
                        virtual void applyFlowLine (const FlowLineType & fl, OutflowChannelData * pData) const;

                public:
                        MyChannelSet ();
                        MyChannelSet(
                                const mars::RangeX< float > & mmfBendZenith,
                                const unsigned int nBendZenithSteps,
                                const unsigned int nCandidateSampleAmt,
                                const mars::RangeX< float > & mmfSplineSeg,
                                const float fGravitySlopeGrace,
                                const float fCarveWeight,
                                const float frSnapToGuide,
                                const mars::RangeX< float > & mmfFlowLineWidth,
                                const mars::RangeX< unsigned int > & mmnKidsPerLevel,
                                const float fwStraightness,
                                const float fwElevationInfluence,
                                const float fwDensityInfluence,
                                const float fwChaosInfluence,
                                const unsigned int nSedimentHistorySize
                        );

                        void init ( const mars::ptr< FluiDynQueryBridge > & pQuery, const unsigned int nLevels, const mars::BBox< float > & bboxSearch );
                        void run ( GeoHeightMap::View * pView ) const;

                        mars::ObjectStream & operator >> (mars::ObjectStream & outs) const;
                        mars::ObjectStream & operator << (mars::ObjectStream & ins);

                        ~MyChannelSet();
                } _chans;

                GWSurfacePos                                            _ptStart;
                mars::RangeX< float >                           _mmfFlowLineWidth, _mmfSourceDisplacement;
                mars::RangeX< unsigned int>
                        _mmnLevels;
                mars::BBox< long > _bbox;

                float                                   
                        _fSourceSpread,
                        _fGeneralDir;
                unsigned int                    _nSourcePoints;

                OutflowChannelGM();

        public:
                OutflowChannelGM( 
                        const GWSurfacePos & ptStart, 
                        const float fGeneralDir,
                        const unsigned int nSourcePoints,
                        const mars::RangeX< float > & mmfSourceDisplacement,
                        const float fSourceSpread,
                        const mars::RangeX< float > & mmfBendZenith,
                        const unsigned int nBendZenithSteps,
                        const unsigned int nCandidateSampleAmt,
                        const mars::RangeX< float > & mmfSplineSeg,
                        const float fGravitySlopeGrace,
                        const float fCarveWeight,
                        const float frSnapToGuide,
                        const mars::RangeX< float > & mmfFlowLineWidth,
                        const mars::RangeX< unsigned int > & mmnLevels,
                        const mars::RangeX< unsigned int > & mmnKidsPerLevel,
                        const float fwStraightness,
                        const float fwElevationInfluence,
                        const float fwDensityInfluence,
                        const float fwChaosInfluence,
                        const unsigned int nSedimentHistorySize
                );
                ~OutflowChannelGM();
                
                virtual void init (SynthesisSession & manager, const IGeoWorldAccessor & accessor, const unsigned short nMaxWidth, const unsigned short nMaxHeight);
                virtual mars::BBox< long > getBBox() const { return _bbox; }
                virtual void doMorph (LockedGWSection & section) const;
                
                static OutflowChannelGM * createInstance (mars::ObjectStream & ins);
                mars::ObjectStream & operator >> (mars::ObjectStream & outs) const;
        };

        inline mars::ObjectStream & operator << (OutflowChannelGM *& pGM, mars::ObjectStream & ins)
        { 
                pGM = OutflowChannelGM::createInstance(ins); 
                return ins;
        }

        class OutflowChannelGMFactory : public GeoMorphFactory, public IPersistentGeoMorphFactory, public ISurfaceBoundedGeoMorphFactory
        {
        private:
                mars::RangeX< float >
                        _mmfBendZenith,
                        _mmfSplineSeg,
                        _mmfFlowLineWidth,
                        _mmfSourceSpread,
                        _mmfSourceDisplacement;

                mars::RangeX< unsigned int> 
                        _mmnSourcePoints,
                        _mmnLevels,
                        _mmnKidsPerLevel;

                unsigned int
                        _nBendZenithSteps,
                        _nCandidateSampleAmount,
                        _nSedimentHistorySize;

                float
                        _fGravitySlopeGrace,
                        _fCarveWeight,
                        _frSnapToGuide,
                        _fwStraightness,
                        _fwElevationInfluence,
                        _fwDensityInfluence,
                        _fwChaosInfluence;

        public:
                virtual GeoMorph * createRandomInstance(const long x, const long y) const;
                virtual void configure( IConfigGMFactory * pFactoryConfig, const IConfigGMFactory::Settings & settings );
                virtual void save (const GeoMorph * pGM, mars::ObjectStream & outs) const;
                virtual const GeoMorph * restore (mars::ObjectStream & ins) const;
        };
}