source: Revenant/geoworld/src/gwmorphs/crater.cpp@ 7ef8ec4

#include "crater.h"
#include "mars_ptr.h"
#include "geoworld.h"

namespace geoworld
{
        void CraterGM::init(SynthesisSession & manager, const IGeoWorldAccessor & accessor, const unsigned short nMaxWidth, const unsigned short nMaxHeight)
        {
                _gcOrigin = accessor.createCoords(_ptOrigin);
        }

        void CraterGM::doMorph (LockedGWSection & section) const
        {
                using namespace mars;
                using namespace geoworld;

                const unsigned short nDim = static_cast <unsigned short> (_zones.puz.outside() * 2.0f);         

                mars::ptr< NoiseGenerator< float >::NoiseMap > pMPField = _noise.compute(nDim, nDim);
                for (PerimiterUpliftZone::UpsideDEMIterator <PerimiterUpliftZone> it = _zones.puz.walkUpside (_gcOrigin); it; ++it)
                {
                        section.heightmap(it->x, it->y) = 
                                blend(
                                        section.heightmap(it->x, it->y),
                                        it->z + (*pMPField)(it->x, it->y), 
                                        _zones.puz.outslope.taper.f (
                                                static_cast< float > (it->x - _ptOrigin.x), 
                                                static_cast< float > (it->y - _ptOrigin.y)
                                        )
                                );
                }

                // TODO: Why are we walking the downside? is this an inverted function?
                for (CraterZone::DownsideDEMIterator <CraterZone> it = _zones.czone.walkDownside (_gcOrigin); it; ++it)
                {
                        section.heightmap(it->x, it->y) = static_cast< GeoHeightMap::Precision > (mars::RNDi(it->z + pMPField->getw(it->x, it->y)));    // TODO: Verify use of RNDi
                }

                for (CentralUpliftZone::UpsideDEMIterator <CentralUpliftZone> it = _zones.central.walkUpside (_gcOrigin); it; ++it)
                {
                        section.heightmap(it->x, it->y) = static_cast< GeoHeightMap::Precision > (mars::RNDi(it->z + pMPField->getw(it->x, it->y)));    // TODO: Verify use of RNDi
                }
        }

        GMScalarField * CraterGM::queryField( const FieldType enft, const GeoHeightMap & hm )
        {
                switch (enft)
                {
                case FT_Density: return new DensityScalarField(_zones.density, _gcOrigin);
                default: return NULL;
                }
        }

        void CraterGM::releaseField( const GMScalarField * pField )
        {
                delete pField;
        }

        mars::BBox< long > CraterGM::getBBox() const
        {
                return mars::BBox< long > (
                        _ptOrigin - static_cast< long > (floor (_zones.puz.outside())), 
                        _ptOrigin + static_cast< long > (ceil (_zones.puz.outside()))
                );
        }

        mars::ptr< PersistentGeoMorph::State > CraterGM::createState() const
        {
                CraterGMState * pState = new CraterGMState();

                pState->fBowlDepth = -_zones.czone.bowl.depth;
                pState->fCentralUpliftBroadnessScale = _fCentralUpliftBroadnessScale;
                pState->fCentralUpliftDepthScale = _fCentralUpliftDepthScale;
                pState->frBowlBroadness = _zones.czone.bowl.broadness;
                pState->frNoise = _noise.noise;
                pState->frScale = _zones.czone.bowl.scale;
                pState->fSpallFalloffFactor = _zones.puz.outslope.falloff;
                pState->gcOrigin = _gcOrigin;
                pState->ptOrigin = _ptOrigin;

                return dynamic_cast< PersistentGeoMorph::State * > (pState);
        }

        CraterGM::CraterGM( const VectorTag< GeoHeightMap::Precision >::V2 & ptOrigin, const float frSample, const float frScale, const float frBowlBroadness, const float fBowlDepth, const float fSpallFalloffFactor, const float frNoise, const float fCentralUpliftDepthScale, const float fCentralUpliftBroadnessScale ) 
        :       
                _zones(
                        CraterZone(
                                BowlFn(
                                        frScale,
                                        frBowlBroadness, 
                                        -fBowlDepth
                                )
                        ),
                        PerimeterUpsideEq(
                                frScale,
                                frBowlBroadness,
                                0.0f
                        ),
                        PerimeterDownsideEq(
                                frScale,
                                frBowlBroadness / 4.0f * mars::SQ(-fBowlDepth),
                                0.0f
                        ),
                        CentralUpliftEq(
                                frScale,
                                1.0f,
                                fCentralUpliftBroadnessScale * frBowlBroadness,
                                -fBowlDepth * fCentralUpliftDepthScale
                        ),
                        fSpallFalloffFactor
                ),
                _fCentralUpliftDepthScale(fCentralUpliftDepthScale),
                _fCentralUpliftBroadnessScale(fCentralUpliftBroadnessScale),
                _noise (0.4f, frNoise),
                // TODO: Messy redundant EqSet instantiation to satisfy constructor member initialization limitations
                _ptOrigin(ptOrigin)
        {}

        CraterGM::CraterGM( const CraterGMState & state )
                : _zones(
                        CraterZone(
                                BowlFn(
                                        state.frScale,
                                        state.frBowlBroadness, 
                                        -state.fBowlDepth
                                )
                        ),
                        PerimeterUpsideEq(
                                state.frScale,
                                state.frBowlBroadness,
                                0.0f
                        ),
                        PerimeterDownsideEq(
                                state.frScale,
                                state.frBowlBroadness / 4.0f * mars::SQ(-state.fBowlDepth),
                                0.0f
                        ),
                        CentralUpliftEq(
                                state.frScale,
                                1.0f,
                                state.fCentralUpliftBroadnessScale * state.frBowlBroadness,
                                -state.fBowlDepth * state.fCentralUpliftDepthScale
                        ),
                        state.fSpallFalloffFactor
                ),
                _fCentralUpliftDepthScale(state.fCentralUpliftDepthScale),
                _fCentralUpliftBroadnessScale(state.fCentralUpliftBroadnessScale),
                _noise (0.4f, state.frNoise),
                // TODO: Messy redundant EqSet instantiation to satisfy constructor member initialization limitations
                _ptOrigin(state.ptOrigin),
                _gcOrigin(state.gcOrigin)
        {}

        CraterGM::DensityScalarField::ResultType CraterGM::DensityScalarField::operator () (const IndexType x, const IndexType y, const IndexType z) const
        {
                return std::max(1.0f, _zone.upside(static_cast< float > (x), static_cast< float > (y)));
        }
        CraterGM::DensityGradientField::ResultType CraterGM::DensityGradientField::operator () (const IndexType x, const IndexType y, const IndexType z) const
        {
                using namespace mars;

                const vector3Df dir (
                        static_cast< float > (_gcOrigin.x - x), 
                        static_cast< float > (_gcOrigin.y - y), 
                        static_cast< float > (_gcOrigin.z - z)
                );

                const float fMag = MAG(dir);

                return fMag > _zone.outside() ? vector3Df() : -mars::U(dir) * _zone.upsideGrad(static_cast< float > (x), static_cast< float > (y));
        }

        CraterGMFactory::~CraterGMFactory() {}

        GeoMorph * CraterGMFactory::createRandomInstance( const long x, const long y ) const
        {
                return new CraterGM(
                        GWSurfacePos(x, y), 
                        _rngfrSample.next(), 
                        _rngfrScale.next(), 
                        _rngfrBowlBroadness.next(), 
                        _rngfBowlDepth.next(), 
                        _fSpallFalloffFactor, 
                        _frNoise, 
                        _fCentralUpliftDepthScale, 
                        _fCentralUpliftBroadnessScale
                );
        }

        void CraterGMFactory::configure( IConfigGMFactory * pFactoryConfig, const IConfigGMFactory::Settings & settings )
        {
                const geoworld::IConfigSection & section = *pFactoryConfig->getSection();

                *section["sample"] >> _rngfrSample;
                *section["scale"] >> _rngfrScale;
                *section["broadness"] >> _rngfrBowlBroadness;
                *section["depth"] >> _rngfBowlDepth;
                *section["falloff"] >> _fSpallFalloffFactor;
                *section["noise"] >> _frNoise;
                *section["uplift_depth"] >> _fCentralUpliftDepthScale;
                *section["uplift_broadness"] >> _fCentralUpliftBroadnessScale;
        }

        void CraterGMFactory::save( const GeoMorph * pGM, mars::ObjectStream & outs ) const
        {
                const CraterGM * pCraterGM = dynamic_cast< const CraterGM * > (pGM);
                assert(pCraterGM != NULL);
                *(pCraterGM->createState()) >> outs;
        }

        const GeoMorph * CraterGMFactory::restore( mars::ObjectStream & ins ) const
        {
                CraterGM::CraterGMState state;

                state << ins;
                return new CraterGM(state);
        }

        mars::ObjectStream & CraterGM::CraterGMState::operator >> ( mars::ObjectStream & outs ) const
        {
                outs << frScale << frBowlBroadness << fBowlDepth << fCentralUpliftBroadnessScale << fCentralUpliftDepthScale << fSpallFalloffFactor << frNoise << ptOrigin << gcOrigin;
                return outs;
        }

        mars::ObjectStream & CraterGM::CraterGMState::operator << ( mars::ObjectStream & ins )
        {
                ins >> frScale >> frBowlBroadness >> fBowlDepth >> fCentralUpliftBroadnessScale >> fCentralUpliftDepthScale >> fSpallFalloffFactor >> frNoise >> ptOrigin >> gcOrigin;
                return ins;
        }

}