PerlinNoise.hpp

#pragma once
#ifndef __H__OCULAR_MATH_PERLIN_NOISE__H__
#define __H__OCULAR_MATH_PERLIN_NOISE__H__

#include "ANoise.hpp"
#include "Math/Random/ARandom.hpp"

#include <memory>
#include <array>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Math
    {
        namespace Noise
        {
            class PerlinNoise : public ANoise
            {
            public:

                PerlinNoise();
                ~PerlinNoise();

                virtual float getValue(float const x);

                virtual float getValue(float const x, float const y);

                virtual float getValue(float const x, float const y, float const z);

                void setOctaves(uint32_t const octaves);

                void setPersistence(float const persistence);

                void setScale(float const scale);

                void seed(int64_t seed);

            protected:

                float getInterpolatedNoise(float const x);
                float getInterpolatedNoise(float const x, float const y);
                float getInterpolatedNoise(float const x, float const y, float const z);

                float getSmoothNoise(float const x, float const y);

                float getRandom(float const x, float const y);

            private:

                uint32_t m_Octaves;
                float    m_Persistence;
                float    m_Scale;

                std::array<uint32_t, 514>             m_Permutations;
                std::array<float, 514>                m_Gradient1;
                std::array<std::array<float, 2>, 514> m_Gradient2;
                std::array<std::array<float, 3>, 514> m_Gradient3[514][3];

                int64_t  m_Seed;

                std::shared_ptr<Random::ARandom> m_PRNG;
            };
        }
    }
}
//------------------------------------------------------------------------------------------

#endif