noise.h

/* *************************************************************************
                          noise.h  -  description
                             -------------------
    begin                : Die Jul 15 2003
    copyright            : (C) 2003 by Micha Riser
    email                : mriser@gmx.net
    
    $Id: noise_8h-source.html,v 1.1 2005/02/04 21:02:27 micha Exp $
    
 ************************************************************************* */

/* *************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ************************************************************************* */

#ifndef NOISE_H
#define NOISE_H

#include "types.h"
#include "vector.h"
#include "function.h"
#include "random.h"

template<class D, class R> class Noise {
    
public: 
    Noise() {} 
    virtual ~Noise() {}
    virtual void seed(long seedVal) = 0;

    virtual R evalN(const D&) const = 0;

    virtual R eval01(const D&) const = 0;

    R sum1FNoise(D p, int octaves, DBL a, DBL b) const {
        R sum(0);
        DBL ai = 1;
        for(int i=0; i<octaves; i++, ai/=a, p*=b)
            sum += evalN(p)*ai;
        return sum;
    }
    
};


class VNoise: public Noise<Vector3,Vector3> {

    typedef Noise<Vector3,DBL> NBase;
    
public:
    VNoise(NBase* ngx, NBase* ngy, NBase* ngz, long seedValue = 123):
      genx(ngx), geny(ngy), genz(ngz)
    {
        seed(seedValue);
    }

    ~VNoise() {
        delete(genx); delete(geny); delete(genz);
    }
    
    void seed(long seedValue) {
        genx->seed(seedValue);
        geny->seed(seedValue+1);  
        genz->seed(seedValue+2);                
    }

    Vector3 evalN(const Vector3& p) const {
        return Vector3(genx->evalN(p),geny->evalN(p),genz->evalN(p));
    }

    Vector3 eval01(const Vector3& p) const {
        return Vector3(genx->eval01(p),geny->eval01(p),genz->eval01(p));
    }
    
private:
    NBase *genx, *geny, *genz;

};


class PerlinNoiseCommon: public Noise<Vector3,DBL> {

public:
    PerlinNoiseCommon(DBL stddev): STDDEV(stddev) {};

    DBL evalN(const Vector3& p) const {
        return evaluate(p) / STDDEV;
    }

    DBL eval01(const Vector3& p) const {
        // <1% of the values are clipped
        return clip01( evaluate(p) / (STDDEV*2*2.58)+.5 );
    }

protected:
    const DBL STDDEV;
    unsigned int permutationTbl[514]; // 256*2 + 2
    Vector3 gradTbl[514];

    DBL evaluate(const Vector3& point) const;

    DBL sCurve(DBL v) const {return ((6*v-15)*v+10)*pow3(v);}

    DBL linInterp(DBL t, DBL a, DBL b) const {return t*(b - a) + a;}

    void setupValues(DBL comp, int & gridIdx0, int & gridIdx1, DBL& dist0, DBL& dist1) const;

};


class PerlinNoiseBaseGradients: public PerlinNoiseCommon {
public:
    PerlinNoiseBaseGradients(long sd = 123456789):
      PerlinNoiseCommon(0.256883) {seed(sd);}

    void seed(long seedVal);
          
private:   
    static const Vector3 baseGradients[16];

};


class PerlinNoiseRandomGradients: public PerlinNoiseCommon {
public:
    PerlinNoiseRandomGradients(long sd = 123456890):
      PerlinNoiseCommon(0.1496) {seed(sd);}

    void seed(long seedVal);
    
};


typedef PerlinNoiseRandomGradients PerlinNoise;
//typedef PerlinNoiseBaseGradients PerlinNoise;

#endif

---