OctavedNoise.h

Go to the documentation of this file.

 
// OctavedNoise.h
 
// Implements the cOctavedNoise class template representing a noise generator that layers several octaves of another noise
 
 
 
 
 
#pragma once
 
 
 
 
 
template <typename N>
class cOctavedNoise
{
public:
    cOctavedNoise(int a_Seed = 0):
        m_Seed(a_Seed)
    {
    }
 
 
    void SetSeed(int a_Seed)
    {
        m_Seed = a_Seed;
        for (auto oct: m_Octaves)
        {
            oct->SetSeed(a_Seed);
        }
    }
 
 
    void AddOctave(NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude)
    {
        m_Octaves.emplace_back(m_Seed, a_Frequency, a_Amplitude);
    }
 
 
    void Generate2D(
        NOISE_DATATYPE * a_Array,                        
        int a_SizeX, int a_SizeY,                        
        NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  
        NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  
        NOISE_DATATYPE * a_Workspace = nullptr           
    ) const
    {
        // Check that state is alright:
        if (m_Octaves.empty())
        {
            ASSERT(!"cOctavedNoise: No octaves to generate!");
            return;
        }
 
        // Allocate the workspace on the heap, if it wasn't given:
        std::unique_ptr<NOISE_DATATYPE[]> workspaceHeap;
        if (a_Workspace == nullptr)
        {
            workspaceHeap.reset(new NOISE_DATATYPE[ToUnsigned(a_SizeX * a_SizeY)]);
            a_Workspace = workspaceHeap.get();
        }
 
        // Generate the first octave directly into array:
        int ArrayCount = a_SizeX * a_SizeY;
        {
            const cOctave & FirstOctave = m_Octaves.front();
            FirstOctave.m_Noise.Generate2D(
                a_Workspace, a_SizeX, a_SizeY,
                a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
                a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency
            );
            NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
            for (int i = 0; i < ArrayCount; i++)
            {
                a_Array[i] = a_Workspace[i] * Amplitude;
            }
        }
 
        // Add each octave:
        for (auto itr = m_Octaves.cbegin() + 1, end = m_Octaves.cend(); itr != end; ++itr)
        {
            // Generate the noise for the octave:
            itr->m_Noise.Generate2D(
                a_Workspace, a_SizeX, a_SizeY,
                a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
                a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency
            );
            // Add it into the output:
            NOISE_DATATYPE Amplitude = itr->m_Amplitude;
            for (int i = 0; i < ArrayCount; i++)
            {
                a_Array[i] += a_Workspace[i] * Amplitude;
            }
        }  // for itr - m_Octaves[]
    }
 
 
    void Generate3D(
        NOISE_DATATYPE * a_Array,                        
        int a_SizeX, int a_SizeY, int a_SizeZ,           
        NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  
        NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  
        NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  
        NOISE_DATATYPE * a_Workspace = nullptr           
    ) const
    {
        // Check that state is alright:
        if (m_Octaves.empty())
        {
            ASSERT(!"cOctavedNoise: No octaves to generate!");
            return;
        }
 
        // Allocate the workspace on the heap, if it wasn't given:
        std::unique_ptr<NOISE_DATATYPE[]> workspaceHeap;
        if (a_Workspace == nullptr)
        {
            workspaceHeap.reset(new NOISE_DATATYPE[ToUnsigned(a_SizeX * a_SizeY * a_SizeZ)]);
            a_Workspace = workspaceHeap.get();
        }
 
        // Generate the first octave directly into array:
        int ArrayCount = a_SizeX * a_SizeY * a_SizeZ;
        {
            const cOctave & FirstOctave = m_Octaves.front();
            FirstOctave.m_Noise.Generate3D(
                a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
                a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
                a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency,
                a_StartZ * FirstOctave.m_Frequency, a_EndZ * FirstOctave.m_Frequency
            );
            NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
            for (int i = 0; i < ArrayCount; i++)
            {
                a_Array[i] = a_Workspace[i] * Amplitude;
            }
        }
 
        // Add each octave:
        for (auto itr = m_Octaves.cbegin() + 1, end = m_Octaves.cend(); itr != end; ++itr)
        {
            // Generate the noise for the octave:
            itr->m_Noise.Generate3D(
                a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
                a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
                a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency,
                a_StartZ * itr->m_Frequency, a_EndZ * itr->m_Frequency
            );
            // Add it into the output:
            NOISE_DATATYPE Amplitude = itr->m_Amplitude;
            for (int i = 0; i < ArrayCount; i++)
            {
                a_Array[i] += a_Workspace[i] * Amplitude;
            }
        }  // for itr - m_Octaves[]
    }
 
protected:
    class cOctave
    {
    public:
        N m_Noise;
 
        NOISE_DATATYPE m_Frequency;
 
        NOISE_DATATYPE m_Amplitude;
 
        cOctave(int a_Seed, NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude) :
            m_Noise(a_Seed),
            m_Frequency(a_Frequency),
            m_Amplitude(a_Amplitude)
        {
        }
    } ;
    typedef std::vector<cOctave> cOctaves;
 
 
    int m_Seed;
 
    cOctaves m_Octaves;
};