Simplex.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Math/Alge/Alge.h"
#include "Honey/Math/Random/Gen.h"

namespace honey
{

template<class Subclass, int Dim, class Real>
class SimplexNoiseCommon
{
public:
    typedef Vec<Dim,Real> Vec;
    
    SimplexNoiseCommon(RandomGen& gen, int size);
    
protected:
    typedef Alge_<Real> Alge;

    int _size;
    vector<int> _perm;
};


template<int Dim, class Real>
class SimplexNoise : SimplexNoiseCommon<SimplexNoise<Dim,Real>, Dim, Real>
{
    typedef SimplexNoiseCommon<SimplexNoise<Dim,Real>, Dim, Real> Super;
    using typename Super::Alge;
public:
    using typename Super::Vec;

    SimplexNoise(RandomGen& gen, int size = 256);
    

    Real noise(const Vec& x, optional<Vec&> dx = optnull);
};

template<class Real>
class SimplexNoise<1, Real> : SimplexNoiseCommon<SimplexNoise<1,Real>, 1, Real>
{
    typedef SimplexNoiseCommon<SimplexNoise<1,Real>, 1, Real> Super;
    using typename Super::Alge;
public:
    using typename Super::Vec;
    
    SimplexNoise(RandomGen& gen, int size = 256)            : Super(gen, size) {}
    Real noise(const Vec& x, optional<Vec&> dx = optnull);
private:
    void grad(int hash, Real& gx);
};

template<class Real>
class SimplexNoise<2, Real> : SimplexNoiseCommon<SimplexNoise<2,Real>, 2, Real>
{
    typedef SimplexNoiseCommon<SimplexNoise<2,Real>, 2, Real> Super;
    using typename Super::Alge;
public:
    using typename Super::Vec;
    
    SimplexNoise(RandomGen& gen, int size = 256)            : Super(gen, size) {}
    Real noise(const Vec& x, optional<Vec&> dx = optnull);
private:
    void grad(int hash, Real& gx, Real& gy);
};

template<class Real>
class SimplexNoise<3, Real> : SimplexNoiseCommon<SimplexNoise<3,Real>, 3, Real>
{
    typedef SimplexNoiseCommon<SimplexNoise<3,Real>, 3, Real> Super;
    using typename Super::Alge;
public:
    using typename Super::Vec;
    
    SimplexNoise(RandomGen& gen, int size = 256)            : Super(gen, size) {}
    Real noise(const Vec& x, optional<Vec&> dx = optnull);
private:
    void grad(int hash, Real& gx, Real& gy, Real& gz);
};

template<class Real>
class SimplexNoise<4, Real> : SimplexNoiseCommon<SimplexNoise<4,Real>, 4, Real>
{
    typedef SimplexNoiseCommon<SimplexNoise<4,Real>, 4, Real> Super;
    using typename Super::Alge;
public:
    using typename Super::Vec;
    
    SimplexNoise(RandomGen& gen, int size = 256)            : Super(gen, size) {}
    Real noise(const Vec& x, optional<Vec&> dx = optnull);
private:
    void grad(int hash, Real& gx, Real& gy, Real& gz, Real& gw);
};
extern template class SimplexNoise<1, Float>;
extern template class SimplexNoise<2, Float>;
extern template class SimplexNoise<3, Float>;
extern template class SimplexNoise<4, Float>;

extern template class SimplexNoise<1, Double>;
extern template class SimplexNoise<2, Double>;
extern template class SimplexNoise<3, Double>;
extern template class SimplexNoise<4, Double>;

}