PerlinNoise.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include <algorithm>
#include <cstdint>
#include <random>
 
namespace CeresEngine::inline Math {
 
    template<typename T = double> class PerlinNoise {
    private:
        Int32 p[512];
 
        static constexpr T fade(T t) noexcept { return t * t * t * (t * (t * 6 - 15) + 10); }
 
        static constexpr T lerp(T t, T a, T b) noexcept { return a + t * (b - a); }
 
        static constexpr T grad(const Int32 hash, T x, T y, T z) noexcept {
            const Int32 h = hash & 15;
            const double u = h < 8 ? x : y;
            const double v = h < 4 ? y : h == 12 || h == 14 ? x : z;
            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
        }
 
    public:
        explicit PerlinNoise(const UInt32 seed) {
            for(Int32 i = 0; i < 256; ++i) {
                p[i] = i;
            }
 
            std::shuffle(std::begin(p), std::begin(p) + 256, std::default_random_engine(seed));
 
            for(size_t i = 0; i < 256; ++i) {
                p[256 + i] = p[i];
            }
        }
 
    public:
        T operator()(T x) const { return (*this)(x, T(), T()); }
 
        T operator()(T x, T y) const { return (*this)(x, y, T()); }
 
        T operator()(T x, T y, T z) const {
            const Int32 X = static_cast<Int32>(std::floor(x)) & 255;
            const Int32 Y = static_cast<Int32>(std::floor(y)) & 255;
            const Int32 Z = static_cast<Int32>(std::floor(z)) & 255;
 
            x -= std::floor(x);
            y -= std::floor(y);
            z -= std::floor(z);
 
            const double u = fade(x);
            const double v = fade(y);
            const double w = fade(z);
 
            const Int32 A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z;
            const Int32 B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z;
 
            return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z)), lerp(u, grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z))),
                lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1)),
                    lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1))));
        }
    };
 
} // namespace CeresEngine::inline Math