Noise.hpp

#pragma once
 
#include <Infinity/api.h>
 
#include <Infinity/Types/Core/Data.hpp>
#include <Infinity/Types/Core/Value.hpp>
#include <Infinity/Types/Containers/Array.hpp>
#include <Infinity/Types/Math/Vector3.hpp>
 
#include <FastNoise/FastNoise.h>
#include <FastNoise/Metadata.h>
 
#include <string>
 
namespace Infinity::Types::Procedural
{
    class INFINITY_API_PUBLIC Noise : public Core::Data
    {
        public:
            Math::Vector3 position;
            
            float frequency = 0.02f;
 
            Noise();
            
            Noise(const std::string& base64Encoded);
            
            Noise(const Noise& other);
            
            ~Noise();
 
            std::unique_ptr<Core::Base> clone() const override;
 
            Noise& operator=(const Noise& other);
 
            const Infinity::Types::TypeID& typeId() const override;
 
            void generate2D(float* out, int xSize, int ySize, int seed) const;
 
            void generate3D(float* out, int xSize, int ySize, int zSize, int seed) const;
 
            FastNoise::SmartNode<>& generator();
            
            const FastNoise::SmartNode<>& generator() const;
 
            void setFromBase64Encoded(const std::string& encoded);
            
            std::string base64Encoded() const;
 
        private:
            FastNoise::SmartNode<> _gen;                                      
            FastNoise::NodeData* _data;                                       
            std::vector<std::unique_ptr<FastNoise::NodeData>> _nodeData;     
    };
}
 
INFINITY_TYPE(Infinity::Types::Procedural::Noise)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Procedural::Noise>)